Tutorial de Netbeans 7.2 Parte 4

En este capítulo veremos más de las prestaciones que tiene Netbeans IDE 7.2.

Transcribiendo interfaces

Otra parte importante que proporciona el diseño de una aplicación en la que participaron arquitectos o analistas son las interfaces, o servicios funcionales del sistema.  Estos servicios implementan la lógica de negocio del sistema, además estas clases requerirán pruebas unitarias de funcionalidad.

Los programadores ahora deben transcribir las 3200 interfaces del sistema que se está construyendo. :D

La mayor carga de trabajo está en la transcripción de los métodos de la interfaz y muchos métodos o funciones reciben o retornan objetos de las clases entidad <Entity> del sistema.  Es por eso que todas las clases entidad ya deben estar codificadas.

Crear una interfaz

En un capítulo anterior vimos cómo crear paquetes y clases en un proyecto de aplicación Java con Netbeans.  Ahora utilizando el mismo procedimiento crearemos las interfaces dentro los paquetes que corresponda.  Según el diseño de la arquitectura del sistema.

Para ello selecciona el paquete.  Luego: New > Java Interface...

Luego de crear las interfaces ahora hay que transcribir los métodos.  Será necesario agregar los imports (Ctrl + Shift + I) correspondientes para que queden como se muestra a continuación.

Interfaz ModuloClientes.java

package org.heyma.tutorial.services;

import java.util.List;
import org.heyma.tutorial.model.Cliente;

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

    public void registrarCliente(Cliente cliente);

    public void actualizarDatos(Cliente cliente);

    public void eliminarCliente(Cliente cliente);

    public Cliente buscarCliente(int id);

    public List listarClientes();
}

Interfaz ModuloBanco.java

package org.heyma.tutorial.services;

import org.heyma.tutorial.model.Cliente;

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

    public void abrirCuenta(Cliente cliente);

    public void cerrarCuenta(Cliente cliente);
}

Implementación de las Interfaces

Para implementar una interfaz se debe crear una clase y agregar a continuación del nombre la instrucción implements seguido del nombre de la interfaz a implementar.  Esto requerirá el import de la Interfaz.

Esto provocará un error en la Clase referida a que se deben implementar los métodos de la Interfaz.  Ahora utilizando las opciones del editor de Netbeans vamos a generar código.

Como en el anterior capítulo vamos a utilizar la opción de: Insert code… (Alt + Insert) o seleccionando en un lugar vacío del cuerpo de la clase, es decir, entre las  llaves {  …  }.  Luego seleccionamos la opción: Implement Method…

Luego debemos seleccionar todos los métodos a menos que la Clase esté definida como Abstracta.

Luego presionamos el botón Generate, y veremos la Clase como se muestra a continuación.

package org.heyma.tutorial.services.impl;

import java.util.List;
import org.heyma.tutorial.model.Cliente;
import org.heyma.tutorial.services.ModuloClientes;

/**
 *
 * @author John
 */
public class ModuloBancoImpl implements ModuloClientes {

    @Override
    public void registrarCliente(Cliente cliente) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void actualizarDatos(Cliente cliente) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void eliminarCliente(Cliente cliente) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public Cliente buscarCliente(int id) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public List listarClientes() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

Finalmente quedará sustituir las líneas con:

throw new UnsupportedOperationException("Not supported yet.");

Por los algoritmos o la lógica funcional.  Tarea propia de los programadores.

Nota: El uso de la programación contra interfaces ayuda de gran manera al trabajo en equipo. Por ejemplo: Hay dos clases de servicios y asignadas a distintos programadores. Cuando una clase hace la llamada a métodos de la otra clase pero ninguna clase esta implementada, él programador no necesita esperar la implementación de la clase que necesita, puede utilizar su Interfaz que ya está disponible.

Ya que este tutorial trata de cómo utilizar Netbeans IDE,  no entraremos en el tema del uso de los paradigmas y las técnicas de programación.

Formatear el código (Alt + Shift + F)

No todos los programadores transcriben el código con el mismo estilo, pero una de las opciones que tiene el editor de Netbeans, es el formateo del código.

Esta opción está seleccionando en un lugar vacío del editor.  Luego: Format o Alt + Shift + F


En el siguiente capítulo veremos como importar nuestro proyecto a un Repositorio Subversion creando una cuenta de Google para el uso de Google Code.

Ir al Inicio

Anuncios

Tutorial de Netbeans 7.2 Parte 3

El Editor de Netbeans IDE 7.2

En este capítulo veremos las prestaciones más importantes del Editor de Netbeans IDE.  Sobre todo para agilizar las tareas más rutinarias en la práctica real en el desarrollo de aplicaciones Java.

En este capítulo veremos:

  • Codificación de clases
  • Resolver Importaciones (imports)
  • Los Getters y Setters

Codificación de clases

El diseño del sistema genera el primer trabajo de los programadores:  Construir la arquitectura del sistema.  Todos los paquetes, clases e interfaces deben ser creados.

Antes de codificar el cuerpo de las clases es bueno iniciar por la estructura de paquetes y luego crear las 2027 clases del sistema :D.

En el capítulo anterior vimos cómo crear paquetes y clases dentro de un proyecto en Netbeans.  Ahora codificaremos el cuerpo la una clase <Entity> Persona, mientras vemos algunas de las prestaciones del Editor de Netbeans.

Luego de crear la clase Persona el Editor nos mostrara lo siguiente

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.heyma.tutorial.model;

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

}

La mayor carga de trabajo en el desarrollo de las clases tipo entidad está en la transcripción de las propiedades, sin embargo es bastante sencillo y no es necesario un test funcional.

Transcribiendo las propiedades de la clase Persona.

En este caso ha generado errores y el icono en la barra de numeración lo indica.  Si no eres un principiante de programación en Java sabes que son las importaciones de Date y List lo que hace falta.

Resolver Importaciones (imports) Ctrl + Shift + I

Para resolver el error de dependencias o imports la opción se encuentra en el menú: Source > Fix imports ó Ctrl + Shift + I.  Pero la manera más ágil antes que una combinación de teclas es de la siguiente forma: seleccionar dentro el editor señalando un lugar vacío y luego la opción: Fix imports.

Si se encuentran ambigüedades Netbeans mostrará el siguiente cuadro para seleccionar las Clases Correctas.

Otra Opción está en seleccionar el icono que además de mostrar el error tiene una sugerencia.

Luego las importaciones se agregarán al código y los errores en la barra de numeración desaparece.

Finalmente este tipo de clases <Entidad> debe encapsular sus propiedades, usar métodos para asignar u obtener valores.  Estos métodos se llaman: Getters y Setters.

Los Getters y Setters – Alt+Insert

Para ello seleccionamos dentro el editor señalando un lugar vacóo a continuación de la última propiedad y luego la opción: Insert Code… ó Alt + Insert.

Según los requerimientos selecciona las propiedades que tendrán Getter y Setter y luego presiona en el botón Generate.

Con esto gran parte de código se habrá generado sin mucho esfuerzo.

La mayor parte de las opciones que tiene Netbeans están basadas en estándares y paradigmas de Programación.

En el siguiente capítulo veremos cómo crear interfaces y clases de implementación y agilizar este trabajo con Netbeans IDE 7.2.

Ir al Inicio

Introducción a Spring Framework 3.1

Spring Framework es uno de las herramientas o librerías más populares entre los desarrolladores de aplicaciones Web con tecnologías Java.

Recientemente una de las publicaciones de ZeroTurnaround DEVELOPER PRODUCTIVITY REPORT 2012 ha puesto en evidencia la tendencia que tiene entre los desarrolladores de Aplicaciones Web el Spring Framework.

Sería raro que jamás escucharas el nombre es este popular Framework para la plataforma Java, está basado en el principio o el patrón de Inversión de Control IoC o inyección de dependencias y una codificación compatible con Java 5 con soporte de @Anotaciones para evitar el uso de archivos xml.  En este caso “inversión” significa que la aplicación no controla su estructura, sino permite que sea el framework de IoC (en este caso Spring) quien lo haga.

Por ejemplo, supongamos que tenemos una clase “ClientesController”, que depende de una instancia de una clase “ClientesService” para realizar sus tareas. “ClientesController” debe crear una instancia de “ClientesService” usando el operador “new”  u obtener una de algún tipo de Fabrica.  Usando la técnica de IoC, Spring es donde entra en acción nos proporcionará en tiempo de ejecución una instancia de “ClientesService” en la clase “ClientesController”, o incluso podemos contar con una interfaz “IClientesService” y desarrollar “” sin tener la implementación.

El uso de interfaces y DI (Dependence Injection) son mutuamente benéficos, ya que hace más flexible y robusta nuestra aplicación y es mucho más fácil realizar pruebas unitarias. Pero la complejidad de escribir código que maneje las dependencias entre los componentes de una aplicación diseñada para usar interfaces puede llegar a ser mucho y esto, además, hace que los desarrolladores tengamos que escribir aún más código.

Afortunadamente, usando DI reducimos la cantidad de código extra que debemos escribir, para un diseño basado en interfaces, casi a cero.

En el contexto de DI, Spring actúa como un contenedor que proporciona las instancias de las clases de nuestra aplicación todas las dependencias que necesita, pero en una forma no intrusiva y automática. Todo lo que debemos hacer es crear un archivo de configuración que describa las dependencias; Spring se hará cargo del resto.

Como dije antes: Spring es un contenedor ya que no solo crea los componentes de nuestra aplicación, sino porque contiene y maneja al ciclo de vida y configuración de estos componentes. En Spring, podemos declarar cómo debe ser creado cada uno de los objetos de nuestra aplicación, cómo deben ser configurados, y cómo deben asociarse con los demás.

La implementación de DI de Spring se enfoca en el acoplamiento débil: los componentes de nuestra aplicación deben asumir lo menos posible acerca de otros componentes. La forma más fácil de lograr este bajo acoplamiento en Java es mediante el uso de Interfaces. Como cada componente de la aplicación solo está consciente de la interface de otros componentes, podemos cambiar la implementación del componente sin afectar a los componentes que usan el nuevo componente.

El uso de DI tiene como beneficios, además de lo que ya he mencionado arriba, los siguientes:

  • Reduce el código pegamento: Esto quiere decir que reduce dramáticamente la cantidad de código que debemos escribir para unir los distintos componentes. Aunque algunas veces esté código puede ser tan simple como usar el operador “new” para instanciar un nuevo objeto, otras puede ser más complejo, como realizar una búsqueda de dicha dependencia en un repositorio a través de JNDI, como en el caso de los recursos remotos. En esto caso, el uso de DI puede reducir de forma dramática la cantidad de código pegamento (o glue code) proporcionando búsquedas automáticas.
  • Externaliza dependencias: Como es posible colocar la configuración de dependencias en archivos XML podemos realizar una reconfiguración fácilmente, sin necesidad de recompilar nuestro código. Gracias a esto es posible realizar el cambio de la implementación de una dependencia a otra (como en el ejemplo de Hibernate que mencioné antes)
  • Las dependencias se manejan en un solo lugar: Toda la información de dependencias es responsabilidad de un solo componente, el contenedor de IoC de Spring, haciendo que este manejo de dependencias más simple y menos propenso a errores.
  • Hace que las pruebas sean más fáciles: Nuevamente, como nuestras clases serán diseñadas para que sea fácil el reemplazo de dependencias, podemos proporcionar mocks o dummies, que regresen datos de prueba, de servicios o cualquier dependencia que necesite el componente que estamos probando.

Como podemos ver, el uso de DI nos proporciona muchos beneficios, pero no sin sus correspondientes desventajas. En particular, es difícil ver qué implementación particular de una dependencia está siendo usada para qué objeto, especialmente para alguien que no está familiarizado con esta forma de trabajo.

Es importante antes de entrar en practica entender bien estos conceptos y los principios de Spring Framework.  Ya que conocer Java y Programación Orientada a Objetos no es suficiente para entrar en este tema.

Instalación de Java o JDK para Desarrolladores

Java Development Kit o (JDK), es un software que provee herramientas de desarrollo para la creación de programas en Java.

Ahora vamos a ingresar en el sitio oficial de Oracle para conseguir el JDK http://www.oracle.com, el software de Java para desarrolladores.

Esto nos llevará a la sección de paquetes donde seleccionaremos el Java SE 6 update 35.  Más adelante cuando tengas mayor experiencia y más conocimiento de la plataforma Java podras cambiar a Java SE 7.

Luego deberás checar la opción de aceptación de la Licencia y se activarán los links de descarga.

Selecciona el instalador compatible con tu Sistema Operativo.  En nuestro caso trabajamos con Windows x64.

Una vez que tengas una copia del instalador en tu equipo, instálalo como cualquier programa.

Felicidades! con esto ya tienes instalado la Plataforma Java para Desarrollo, el JDK de Oracle.

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.

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.