Capítulo 3 – Configurando la Aplicación Spring Parte 2

En este capítulo vamos a integrar a nuestro proyecto una conexión de base de datos PostgreSQL 9.

Para ello vamos a configurar una conexión JDBC con Hibernate 4, y configurar Spring para que administre las transacciones con AspectJ una alternativa a AOPAlliance, gracias al soporte que tiene Spring para AOP (Programación Orientada a Aspectos).

Requerimientos

  1. Contar Con lo avanzado hasta el capitulo anterior de este tutorial
  2. Crear una base de datos “heyma” en PostgreSQL 9
  3. Descargar Hibernate ORM 4, hibernate-release-4.1.7.Final.zip
  4. Descargar AspectJ, aspectj-1.7.0.jar
  5. Descargar PostgreSQL JDBC 4, postgresql-9.1-902.jdbc4.jar

NOTA: En este capítulo se va a suponer que la Base de Datos PostgreSQL 9 ya está instalada y configurada correctamente.

Agregando Hibernate 4 al Proyecto “heyma”

En el Tutorial de Netbeans 7.2 hay un capítulo de cómo crear librerias en Netbeans IDE 7.2 para usar en nuestros proyectos.

El paquete descargado de Hibernate 4 (.zip) contiene las librerías que debemos agregar al proyecto, las 8 jars del directorio lib/required.

Para ello seleccionamos en: Libraries > Properties.

De la ventana de Propiedades seleccionamos en: Add JAR/Folder.

Seleccionamos todas las jars del directorio lib/required de Hibernate 4.

Con esto está listo la integración de Hibernate  en el proyecto “heyma“.

Instalación de AspectJ

El paquete de AspectJ aspectj-1.7.0.jar en realidad es un archivo ejecutable, un asistente (wizard) que instala las librerías en C:\aspectj1.7.

Con el mismo Procedimiento de integrar Hibernate al Proyecto vamos a agregar todas las jars del directorio donde se instalo AspectJ  C:\aspectj1.7\lib.

Instalacion del Driver JDBC de PostgreSQL

El archivo descargado postgresql-9.1-902.jdbc4.jar es una librería que únicamente debe agregarse al Proyecto igual que los procedimientos anteriores.

Luego de la Instalación o integración de librerías al Proyecto “heyma”, la ventata de propiedades de librerías debe estar como muestra la siguiente imagen.

Configurando e implementando una Prueba

Ahora el archivo applicationContext.xml debe quedar de la siguiente manera.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
          p:location="/WEB-INF/jdbc.properties" />

    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource"
          p:driverClassName="${jdbc.driverClassName}"
          p:url="${jdbc.url}"
          p:username="${jdbc.username}"
          p:password="${jdbc.password}" />

    <!-- ADD PERSISTENCE SUPPORT HERE (jpa, hibernate, etc) -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="org.heyma.webapp.model" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <bean class="org.springframework.transaction.aspectj.AnnotationTransactionAspect" factory-method="aspectOf">
        <property name="transactionManager" ref="transactionManager" />
    </bean>

    <context:annotation-config />
    <context:load-time-weaver />
    <context:spring-configured />
    <context:component-scan base-package="org.heyma.webapp" />
    <mvc:annotation-driven />

</beans>

Vamos a agregar un archivo de propiedades jdbc.properties al Proyecto con el siguiente código.

jdbc.driverClassName=org.postgresql.Driver
jdbc.dialect=org.hibernate.dialect.PostgreSQLDialect
jdbc.url=jdbc:postgresql://localhost:5432/heyma
jdbc.username=root
jdbc.password=123

Para agregar un archivo de Propiedades hacemos sobre WEB-INF > New.. > Properties file.  Si no aparece en el menú lo podremos localizar en la categoría Other, así de esta manera la vista del proyecto se vera como en la siguiente imagen.

Debemos tener la seguridad de que los parametros de conexión a la Base de Datos son las Correctas.

Con esto finalizamos la configuración del Proyecto para la conexión con una Base de Datos PostgreSQL 9, ahora tan solo queda agregar elementos o implementar alguna necesidad o requerimiento específico del Sistema. Para probar esta configuración vamos a implementar un Registro de Personas con algunos datos Básicos.

Estructura de paquetes y Componentes del Sistema (Entidades y Servicios)

Creamos la siguiente estructura de paquetes en el Proyecto

Según nuestro requerimiento de Registro de Personas se nota claramente que debemos crear la Entidad Persona, esta será una Clase Java en el paquete org.heyma.webapp.model con las @Anotaciones necesarias para ser una Entidad.

La Clase Persona.java

package org.heyma.webapp.model;

import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Temporal;

/**
 *
 * @author John
 */
@Entity
public class Persona {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int persona_id;
    private String nombres;
    private String apellidoPaterno;
    private String apellidoMaterno;
    @Temporal(javax.persistence.TemporalType.DATE)
    private Date fechaDeNacimiento;

    public int getPersona_id() {
        return persona_id;
    }

    public void setPersona_id(int persona_id) {
        this.persona_id = persona_id;
    }

    public String getNombres() {
        return nombres;
    }

    public void setNombres(String nombres) {
        this.nombres = nombres;
    }

    public String getApellidoPaterno() {
        return apellidoPaterno;
    }

    public void setApellidoPaterno(String apellidoPaterno) {
        this.apellidoPaterno = apellidoPaterno;
    }

    public String getApellidoMaterno() {
        return apellidoMaterno;
    }

    public void setApellidoMaterno(String apellidoMaterno) {
        this.apellidoMaterno = apellidoMaterno;
    }

    public Date getFechaDeNacimiento() {
        return fechaDeNacimiento;
    }

    public void setFechaDeNacimiento(Date fechaDeNacimiento) {
        this.fechaDeNacimiento = fechaDeNacimiento;
    }
}

La Interfaz Dao.java

package org.heyma.webapp.dao;

/**
 *
 * @author John
 */
public interface Dao {

    void save(Object obj);
}

La Clase DaoImpl.java (Implementación de Dao.java)

package org.heyma.webapp.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

/**
 *
 * @author John
 */
@Repository
public class DaoImpl implements Dao {

    @Autowired
    private SessionFactory sessionFactory;

    private Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }

    @Override
    public void save(Object obj) {
        getCurrentSession().save(obj);
    }
}

La Interfaz IPersonaSrv.java

package org.heyma.webapp.srv;

import org.heyma.webapp.model.Persona;

/**
 *
 * @author John
 */
public interface IPersonaSrv {

    public void guardarPersona(Persona persona);
}

La Clase PersonaImpl.java (Implementación de IPersonaSrv)

package org.heyma.webapp.srv;

import org.heyma.webapp.dao.Dao;
import org.heyma.webapp.model.Persona;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 *
 * @author John
 */
@Service
public class PersonaImpl implements IPersonaSrv {

    @Autowired
    Dao dao;

    @Override
    @Transactional
    public void guardarPersona(Persona persona) {
        dao.save(persona);
    }
}

Finalmente agregaremos dos metodos a MainController.java

    @RequestMapping("/registerpage.htm")
    public String registerPage() {
        return "registerPage"; //hace referencia a WEB-INF/jsp/registerPage.jsp
    }

    @RequestMapping(value = "/guardarpersona.htm", method = RequestMethod.POST)
    public String guardarPersona(Persona persona) {
        service.guardarPersona(persona);
        return "successPage"; //hace referencia a WEB-INF/jsp/successPage.jsp
    }

La Clase Maincontroller.java (Completo)

package org.heyma.webapp;

import org.heyma.webapp.model.Persona;
import org.heyma.webapp.srv.IPersonaSrv;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 *
 * @author John
 */
@Controller
public class MainController {

    @Autowired
    private IPersonaSrv service;

    @RequestMapping("/saludo.htm")
    public @ResponseBody
    String saludo() {
        return "Hola mundo";
    }

    @RequestMapping("/registerpage.htm")
    public String registerPage() {
        return "registerPage"; //hace referencia a WEB-INF/jsp/registerPage.jsp
    }

    @RequestMapping(value = "/guardarpersona.htm", method = RequestMethod.POST)
    public String guardarPersona(Persona persona) {
        service.guardarPersona(persona);
        return "successPage"; //hace referencia a WEB-INF/jsp/successPage.jsp
    }
}

Ambos métodos hacen referencia a dos páginas que deben crearse.  Estas Páginas son archivos JSP que deben crearse en WEB-INF/jsp del Proyecto.

La Página registerPage.jsp

<%--
    Document   : registerPage
    Created on : 27-08-2012, 03:02:55 PM
    Author     : John
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Página de Registro</title>
    </head>
    <body>
        <h1>Registro de Persona</h1>
        <form action="guardarpersona.htm" method="POST">
            <table>
                <tr>
                    <td>Nombres:</td>
                    <td><input type="text" name="nombres"></td>
                </tr>
                <tr>
                    <td>Apellido paterno:</td>
                    <td><input type="text" name="apellidoPaterno"></td>
                </tr>
                <tr>
                    <td>Apellido materno:</td>
                    <td><input type="text" name="apellidoMaterno"></td>
                </tr>
                <tr>
                    <td>Fecha de nacimeinto:</td>
                    <td><input type="text" name="fechaDeNacimeinto"></td>
                </tr>
                <tr>
                    <td></td>
                    <td><input type="submit" value="Guardar"></td>
                </tr>
            </table>
        </form>
    </body>
</html>

La Página successPage.jsp

<%--
    Document   : successPage
    Created on : 27-08-2012, 03:46:48 PM
    Author     : John
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Success</title>
    </head>
    <body>
        <h1>Success!</h1>
    </body>
</html>

Finalmente la estructura del Proyecto será.

Prueba Final

Ahora llego el momento de la prueba final, Desplegar la Aplicación en el servidor (Deploy) e ingresar un registro.

Luego de ejecutar Run o Deploy abrimos la Página de Registro en heyma/registerpage.htm

Si todo salio correctamente deberiamos ver la siguiente Página.

Para confirmar bastaría con ver en la Base de Datos “heyma” una tabla persona, creada automáticamente con el registro anterior.

Con esto hemos finalizado con el tema Configurando la Aplicación Spring Parte 2. En los siguientes capítulos vamos a implementar un requerimiento más avanzado y además vamos a integrar a nuestra Aplicación el Framework ExtJS 4 para la Interfaz de usuario.

Anuncios

Capítulo 2 – Configurando la Aplicación Spring Parte 1

En el capítulo anterior vimos, cómo iniciar un proyecto Web con Spring Framework en Netbeans 7.2

Ahora vamos a personalizar un poco más la configuración para desarrollar una aplicación completa.

Para probar nuestra primera parte de la configuración vamos a crear nuestro primer componente de Spring que dirá “Hola mundo” con una simple clase Java.

El Spring Framework 3 soporta @Anotaciones en lugar de escribir archivos XML para describir los componentes.  Para activar esto editaremos el archivo applicationContext.xml. De la siguiente manera.

Archivo WEB-INF/applicationContext.xml Original

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <!--bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
          p:location="/WEB-INF/jdbc.properties" />

<bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource"
    p:driverClassName="${jdbc.driverClassName}"
    p:url="${jdbc.url}"
    p:username="${jdbc.username}"
    p:password="${jdbc.password}" /-->

    <!-- ADD PERSISTENCE SUPPORT HERE (jpa, hibernate, etc) -->

</beans>

Archivo WEB-INF/applicationContext.xml Editado

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

    <context:component-scan base-package="org.heyma.webapp" />
    <mvc:annotation-driven />

    <!--bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
          p:location="/WEB-INF/jdbc.properties" />

<bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource"
    p:driverClassName="${jdbc.driverClassName}"
    p:url="${jdbc.url}"
    p:username="${jdbc.username}"
    p:password="${jdbc.password}" /-->

    <!-- ADD PERSISTENCE SUPPORT HERE (jpa, hibernate, etc) -->

</beans>

Las líneas marcadas son las que le agregamos al archivo applicationContext.xml.

NOTA: Existe un error en la plantilla de creación del proyecto de Netbeans las referencias de ubicación están apuntando a Spring 2.5 y se deben cambiar todas a 3.1.

   http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
   //En el original dice .../spring-tx-2.5

La línea 15 del archivo applicationContext.xml (Editado) hace referencia a un paquete que debemos agregar al proyecto.   Como se muestra en la siguiente imagen.

Ahora agregamos al paquete una clase Java con las @Anotaciones necesarias para convertirla en un Bean o Componente de Spring.  Será necesario agregar las dependencias correspondientes (imports) de Spring.

La clase se llamará MainController.java con el siguiente código.

package org.heyma.webapp;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 *
 * @author John
 */
@Controller
public class MainController {

    @RequestMapping("/saludo.htm")
    public @ResponseBody
    String saludo() {
        return "Hola mundo";
    }
}

Las líneas marcadas muestran las @Anotaciones de Spring que se están usando.  La Clase contiene además un método que retorna la cadena “Hola mundo” llamado saludo().

La Clase anterior sin @Anotaciones sería.

package org.heyma.webapp;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 *
 * @author John
 */
public class MainController {

    public String saludo() {
        return "Hola mundo";
    }
}

@Controller, Le dirá al contenedor que la Clase será un Componente o Bean de Spring, y se creará una instancia al momento de desplegar la aplicación.

@RequestMapping(“/urlDelServicio”), determina la URL para la llamada HTTP.  Se puede definir el tipo de petición GET o POST, esto lo veremos en siguientes tutoriales.

@ResponseBody, Definirá la respuesta según el objeto.  En nuestra primera experiencia retornaremos una cadena “Hola mundo”.

Ahora estamos listos para ejecutar Deploy o Run como en el capitulo anterior luego cambiando en la URL index.htm a saludo.htm veremos el resultado como se muestra en la siguiente imagen.

Con esto concluimos con la primera parte de la Configuración de una Aplicación Web con Spring Framework 3.1.

En el siguiente capítulo le agregaremos una Base de Datos PostgreSQL 9 a nuestro proyecto.

Ir al inicio

Capítulo 1 – Iniciar Spring en Netbeans 7.2

Iniciar Spring Framework 3.1 en Netbeans 7.2

Spring Framework 3.1, es un conjunto de librerias para el desarrollo de aplicaciones Java (aplicaciones cliente servidor y aplicaciones Web).  Esta versión de Spring es compatible con JDK 6 y 7, y se usan @Anotaciones en lugar de escribir archivos xml.

Para iniciar vamos a utilizar el Netbenas IDE 7.2, en la que viene integrado las librerias de Spring Framework 3.

Nota: Antes de comenzar puede que necesites revisar nuestro Tutorial de Netbeans 7.2.

Creando un nuevo Proyecto

Iniciamos en el menú de Netbeans: File > New Project…  Seleccionamos el tipo de proyecto: Java Web > Web Application.

Le damos el nombre “heyma” y establecemos una ubicación específica para el proyecto.

Luego seleccionamos el Servidor de Aplicaciones Glassfish y la versión de Java EE 6, manteniendo el valor del Context Path con “/heyma“.

Una aplicacion Spring puede desplegarse tambien en un servidor Tomcat un servidor más lijero recomendable para el momento de desarrollo.

Ahora viene el momento de la seleccion de Frameworks.  En esta ventana vamos a seleccionar el Spring Web MVC y seleccionar la versión 3.

Con estos pasos tan solo resta ejecutar la aplicación (Run o Deploy) para tener una aplicacion Web con Spring publicado en HTTP.

En los siguientes capítulos personalizaremos la configuración del proyecto para construir una aplicacion Web, implementaremos el framework ExtJS 4 para la interfaz de usuario y además le integraremos una base de datos PostgreSQL 9.