Vaadin Spring e Hibernate

Servicio REST

2015-02-21T12:11:00.003-08:00

SERVICIO REST

Continuando con el proyecto anterior Vaadin,Spring,Hibernate vamos a crear un servicio REST sencillo donde listemos los usuarios de la BD, todo esto utilizando Spring. (Para saber que es REST remitirse al link)

Ya antes en el archivo web.xml habiamos mapeado la clase org.springframework.web.servlet.DispatcherServlet de Spring y estaba mapeada algo asì:

 <servlet-mapping>  
     <servlet-name>dispatcher</servlet-name>  
     <url-pattern>/html/*</url-pattern>  
   </servlet-mapping>

Y tenemos el archivo asociado dispatcher-servlet.xml donde definimos diferentes View Resolver, entre ellos para json y xml.

Teniendo lo anterior podemos crear la siguiente clase:

 package com.ejemplo.vaadin.rest;  
 import com.ejemplo.vaadin.dao.DaoUsuario;  
 import com.ejemplo.vaadin.entidades.Usuario;  
 import java.util.ArrayList;  
 import java.util.List;  
 import javax.servlet.http.HttpServletRequest;  
 import javax.servlet.http.HttpServletResponse;  
 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.servlet.ModelAndView;  
 /**  
  *  
  * @author josorio  
  */  
 @Controller  
 public class UsuariosController {  
   @Autowired  
   private DaoUsuario daoUsuario;  
   /**  
    * Lista todos los usuarios de la BD  
    * @param request  
    * @param response  
    * @return   
    */  
   @RequestMapping( method = {RequestMethod.GET}, value = "/listarusuarios" )  
   public ModelAndView obtener10Parqueaderos(HttpServletRequest request, HttpServletResponse response)  
   {  
     ModelAndView retorno = new ModelAndView();  
     List<Usuario> listaEntidades;  
     try{        
       listaEntidades = daoUsuario.listar();  
       if( listaEntidades == null )  
       {  
         listaEntidades = new ArrayList<Usuario>();  
       }  
     }catch(Exception e){  
       System.out.println("Error "+e.getMessage());  
       listaEntidades = new ArrayList<Usuario>();  
     }  
     retorno.addObject( "cantidad", listaEntidades.size() );  
     retorno.addObject( "datos", listaEntidades );  
     return retorno;  
   }  
 }

Ya con esto y si visitamos las urls:
../MavenEjemplo/html/listarusuarios.xml ó /MavenEjemplo/html/listarusuarios.json veremos nuestro webservice tipo REST corriendo.

Visita también

https://joarchitectus.wordpress.com

https://joarchitectus.wordpress.com/2018/03/23/vaadin-spring-e-hibernate/

Menú - Vaadin, Spring e Hibernate

2011-04-14T12:57:00.000-07:00

El objetivo de este post es crear un proyecto sencillo utilizando los framerworks Java: Vaadin, Spring e Hibernate de manera intregrada usando el modelo MVC, el cual se ha dividido en los siguientes capítulos:

El código del proyecto lo pueden encontrar en github construido con maven

https://github.com/juliandresog/VaadinEjemplo.git

En la misma linea que este blog esta el siguiente, el cual apunta a usar Sencha GXT http://senchagxtspringhibernate.blogspot.com/

Visita también
https://joarchitectus.wordpress.com/2018/03/23/vaadin-spring-e-hibernate/

Julián Andrés Osorio Galvis

CRUD Ejemplo - Vaadin - Vista

2011-04-14T12:19:00.000-07:00

En esta parte crearemos la interfaz web usando el framework Vaadin, aca crearemos un formulario básico con los campos necesarios para crear un registro de un usuario.

Ahora para crear la parte de la vista web del aplicativo modifico la clase MyApplication.java para que quede de la siguiente manera:

 /*
* MyApplication.java
*
* Created on 12 de abril de 2011, 04:09 PM
*/
package com.ejemplo.vaadin;
import com.ejemplo.vaadin.admusuarios.FormularioUsuario;
import com.ejemplo.vaadin.servicios.ServicioUsuarios;
import com.vaadin.Application;
import com.vaadin.ui.*;
import com.vaadin.data.*;
import org.springframework.beans.factory.annotation.Autowired;
/**
*
* @author josorio
* @version
*/
public class MyApplication extends Application {
@Autowired
ServicioUsuarios servicioUsuarios;
@Override
public void init() {
Window mainWindow = new Window("MyApplication");
Label label = new Label("Ejemplo de Vaadin, Spring e Hibernate");
mainWindow.addComponent(label);
FormularioUsuario formUsuario = new FormularioUsuario();
mainWindow.addComponent(formUsuario);
setMainWindow(mainWindow);
}
/**
* Método qu retorno el objeto injectado para que otras clases de la aplicación puedan usarlo
* @return El objeto ServicioUsuario injectado
*/
public ServicioUsuarios getServicioUsuarios() {
return servicioUsuarios;
}
}

Finalmente creo el formulario en Vaadin con los campos necesarios para registrar el usuario:

 /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.admusuarios;
import com.ejemplo.vaadin.MyApplication;
import com.ejemplo.vaadin.entidades.Usuario;
import com.vaadin.data.Property;
import com.vaadin.data.validator.EmailValidator;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.ComboBox;
import com.vaadin.ui.Form;
import com.vaadin.ui.TextField;
import com.vaadin.ui.Window.Notification;
@SuppressWarnings("serial")
public class FormularioUsuario extends Form {
/** Caja de texto para ingresar los nombres del usuario */
TextField txtNombres;
/** Caja de texto para ingresar los apellidos del usuario */
TextField txtApellidos;
/** Caja de texto para ingresar el correo del usuario */
TextField txtCorreo;
/** Caja de texto para ingresar la clave para el usuario*/
TextField txtClave;
/** Botón para realizar la acción de guardado */
Button btnGuardar;
public FormularioUsuario() {
txtNombres = new TextField("Nombres");
txtNombres.setDescription("Ingrese los nombres del usuario");
txtNombres.setRequired(true);
txtNombres.setRequiredError("Debe ingresar los nombres del usuario");
txtApellidos = new TextField("Apellidos");
txtApellidos.setDescription("Ingrese los apellidos del usuario");
txtApellidos.setRequired(true);
txtApellidos.setRequiredError("Debe ingresar los apellidos del usuario");
txtCorreo = new TextField("Correo");
txtCorreo.setDescription("Ingrese el correo electronico del usuario");
txtCorreo.setRequired(true);
txtCorreo.setRequiredError("El correo es un campo obligatorio, por favor ingrese un valor");
txtCorreo.addValidator(new EmailValidator("Debe ingresar una dirección de correo válida"));
txtClave = new TextField("Clave");
txtClave.setDescription("Ingrese la clave para el usuario");
txtClave.setRequired(true);
txtClave.setRequiredError("Debe ingresar una clave para el usuario");
addField("txtNombres", txtNombres);
addField("txtApellidos", txtApellidos);
addField("txtCorreo", txtCorreo);
addField("txtClave", txtClave);
btnGuardar = new Button("Guardar Usuario");
btnGuardar.addListener(new Button.ClickListener() {
public void buttonClick(ClickEvent event) {
if (isValid()) {
 Usuario usuario = formularioAEntidad();
 //ejecuto el guardado
 Integer respuesta = ((MyApplication) getApplication()).getServicioUsuarios().guardarUsuario(usuario);
 switch (respuesta.intValue()) {
   // Si la solicitud se procesó bien
   case 0:
     getWindow().showNotification("Se ha guardado el usuario correctamente");
     //Reseteamos el formulario para que quede limpio
     reset();
     break;
   // Si el usuario no existe
   case 1:
     getWindow().showNotification("Al parecer usted no "
         + "cuenta con privilegios para realizar ésta acción", Notification.TYPE_WARNING_MESSAGE);
     break;
   // Si se presentó un error
   case 2:
     getWindow().showNotification("No se ha encontrado una sesión activa "
         + "al procesar la solicitud", Notification.TYPE_ERROR_MESSAGE);
     break;
   //si excepcion de duplicate data
   case 4:
     getWindow().showNotification("Ya existe un usuario definido para este correo!", Notification.TYPE_ERROR_MESSAGE);
     break;
   // Si el resultado no es el esperado
   default:
     getWindow().showNotification("El servidor respondió "
         + "de forma inesperada, por favor "
         + "reporte este mensaje de error", Notification.TYPE_ERROR_MESSAGE);
 }
} else {
 getWindow().showNotification("Por favor ingrese todos los datos marcados con * "
     + "en el formulario", Notification.TYPE_ERROR_MESSAGE);
}
}
});
addField("btnGuardar", btnGuardar);
}
/**
* Método para cargar el formulario con los datos del objeto parámetro
* @param usuario - Entidad usuario
*/
public void entidadAFormuario(Usuario usuario) {
txtNombres.setValue(usuario.getNombres());
txtApellidos.setValue(usuario.getApellidos());
txtCorreo.setValue(usuario.getCorreo());
}
/**
* Método para crear una entidad con los datos ingresados al formulario
* @return El usuario creado
*/
public Usuario formularioAEntidad() {
Usuario retorno;
retorno = new Usuario();
retorno.setClave((txtClave.getValue().toString()));
retorno.setNombres(txtNombres.getValue().toString());
retorno.setApellidos(txtApellidos.getValue().toString());
retorno.setCorreo(txtCorreo.getValue().toString());
return retorno;
}
/**
* Resetear contenido formulario.
*/
public void reset() {
txtNombres.setValue("");
txtApellidos.setValue("");
txtCorreo.setValue("");
txtClave.setValue("");
}
}

Ya tenemos todo el código necesario para ejecutar la aplicación, al hacerlo veremos la siguiente pantalla:

La estructura final del proyecto es la siguiente:

En GitHub pueden encontrar el código fuente construido usando maven
https://github.com/juliandresog/VaadinEjemplo.git

Volver al menú

Menú

CRUD Ejemplo - Spring

2011-04-14T12:09:00.000-07:00

Ahora vamos a crear un bean para gestionar las operaciones a nivel de controlador, el cual definimos en el applicationContext.xml asi:

Este bean tiene inyectado el daoUsuarios y sirve de intermediario entre entre la vista y el modelo, que en este caso solo va a guardar una entidad usuario en la BD.

Este bean contiene el siguiente código:

 /*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package com.ejemplo.vaadin.servicios;

import com.ejemplo.vaadin.entidades.Usuario;

import java.util.List;

/**

* Servicio con los metodos necesarios para gestionar los usuarios en la BD

* @author josorio

*/

public interface ServicioUsuarios

{

/**

* Método para retornar una lista con todos los usuarios activos(no eliminados)

* en la base de datos

* @return Una lista con todos los usuarios en la BD

*/

public List<Usuario> usuarios();

/**

* Guarda el usuario entregado, si no existía lo crea

* @param usuario

* @return Alguno de los siguientes valores:

* <ul>

* <li>0: En caso de crear el usuario exitosamente</li>

* <li>1: En caso de el usuario no tener privilegios</li>

* <li>2: En caso de no haber sesión</li>

* <li>3: En caso de error</li>

* </ul>

*/

public Integer guardarUsuario( Usuario usuario );

}

 /*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package com.ejemplo.vaadin.servicios.impl;

import com.ejemplo.vaadin.dao.DaoUsuario;

import com.ejemplo.vaadin.entidades.Usuario;

import com.ejemplo.vaadin.servicios.ServicioUsuarios;

import java.io.Serializable;

import java.sql.BatchUpdateException;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import org.apache.commons.lang.exception.ExceptionUtils;

import org.hibernate.exception.ConstraintViolationException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.dao.DataIntegrityViolationException;

public class ServicioUsuariosImpl implements ServicioUsuarios, Serializable

{

@Autowired

DaoUsuario daoUsuarios;

/** @{inheritDoc} */

public List<Usuario> usuarios()

{

List<Usuario> retorno = null;

retorno = daoUsuarios.getActivos();

if( retorno == null )

{

retorno = new ArrayList<Usuario>();

}

return retorno;

}

/** @{inheritDoc} */

public Integer guardarUsuario( Usuario usuario )

{

Integer retorno = 1;

try

{

daoUsuarios.guardar( usuario );

retorno = 0;

}catch (ConstraintViolationException e) {

retorno = 4;

} catch (DataIntegrityViolationException e) {

retorno = 4;

}

catch( Exception e )

{

e.printStackTrace();

retorno = 3;

}

return retorno;

}

}

Este servicio es inyectado del lado de la vista para administrar los usuarios.

Siguiente: Vista

Volver al menú

Menú

CRUD Ejemplo - Hibernate - Modelo

2011-04-14T09:28:00.002-07:00

Para empezar a trabajar y previa configuración del proyecto es necesario añadir las librerías que se muestran en la siguiente pantalla:

Este ejemplo lo haremos sobre una base de datos postgres en donde crearemos la siguiente tabla:

 CREATE TABLE usuario
(
id serial NOT NULL,
nombres character varying(200) NOT NULL,
apellidos character varying(200) NOT NULL,
correo character varying(200) NOT NULL,
clave character varying(200) NOT NULL,
llave_cambio_clave character varying(200),
fechainactivado timestamp without time zone,
rol integer,
fecha_creacion timestamp without time zone,
bloqueo integer,
CONSTRAINT usuario_pkey PRIMARY KEY (id)
)

Para lo anterior si en el archivo aplication.properties ponemos la siguiente propiedad:
hibernate.hbm2ddl.auto=update con el campo update estamos indicando que al desplegar el war se actualice el esquema de base de datos según el modelo de entidades que definamos.

Ahora creo un DAO (Data Access Object) genérico para trabajar así:

 /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.dao;
import org.springframework.dao.DataAccessException;
import java.util.List;
/**
* (DAO, Objeto de Acceso a Datos)
* Componente de acceso a datos reutilizable para no reescribir las
* operaciones basicas sobre los objetos del dominio.
* @param <T>
*/
public interface DaoGenerico<T extends Object> {
/**
* Permite cargar una entidad de manera generica
* @param id el id de la entidad a cargar
* @return La entidad cargada
* @throws DataAccessException
*/
public T getById(int id) throws DataAccessException;
/**
* Permite guardar una entidad de manera generica
* @param entidad la entidad a guardar
* @throws DataAccessException
*/
public void guardar(T entidad) throws DataAccessException;
/**
* Permite borrar una entidad de manera generica
* @param entidad La entidad a borrar
* @throws DataAccessException
*/
public void borrar(T entidad) throws DataAccessException;
/**
* Refresca el objeto desde la base de datos aplicando bloqueo para update
* @param entity
*/
public void refrescarBloquear(T entity);
/**
* Lista todas las entidades en el repositorio del tipo definido
* @return El listado de instancias
* @throws DataAccessException
*/
public List<T> listar() throws DataAccessException;
}

 /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.dao.hibernate;
import com.ejemplo.vaadin.dao.DaoGenerico;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import org.hibernate.LockMode;
/**
* {@inheritDoc}
*/
public class DaoGenericoImpl<T> implements DaoGenerico<T>
{
protected Class<T> domainClass = extraerClaseDominio();
@Autowired
protected SessionFactory sessionFactory;
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
protected Class<T> extraerClaseDominio()
{
if( domainClass == null )
{
ParameterizedType thisType = ( ParameterizedType ) getClass().getGenericSuperclass();
domainClass = ( Class ) thisType.getActualTypeArguments()[0];
}
return domainClass;
}
/**
* {@inheritDoc}
*/
@Transactional(readOnly = true)
@SuppressWarnings("unchecked")
public T getById( int id )
{
return ( T ) sessionFactory.getCurrentSession().get( extraerClaseDominio(), id );
}
/**
* {@inheritDoc}
*/
@Transactional
public void guardar( T entity )
{
sessionFactory.getCurrentSession().saveOrUpdate( entity );
}
/**
* {@inheritDoc}
*/
@Transactional
public void borrar( T entity )
{
sessionFactory.getCurrentSession().delete( entity );
}
/**
* {@inheritDoc}
*/
@Transactional
public void refrescarBloquear( T entity )
{
sessionFactory.getCurrentSession().refresh( entity, LockMode.UPGRADE );
}
/**
* {@inheritDoc}
*/
@Transactional
@SuppressWarnings("unchecked")
public List<T> listar()
{
StringBuilder sb = new StringBuilder( "from " );
sb.append( extraerClaseDominio().getName() );
sb.append( " entity" );
return sessionFactory.getCurrentSession().createQuery( sb.toString() ).list();
}
}

Ahora creo la Entidad Usuario la cual puede ser generada automáticamente con las herramientas provistas por Netbeans la cual le agrega las anotaciones que necesitamos, quedando de la siguiente manera:

 /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.entidades;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import java.util.Date;
import java.util.List;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Transient;
/**
* Entidad Usuario que representa la tabla con el mismo nombre en la BD
* @author josorio
*/
@Entity
@Table(name = "usuario")
public class Usuario implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Basic(optional = false)
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.AUTO, generator = "gen_usuario")
@SequenceGenerator(name = "gen_usuario", sequenceName = "usuario_id_seq")
private Integer id;
@Basic(optional = false)
@Column(name = "correo")
private String correo;
@Basic(optional = false)
@Column(name = "clave")
private String clave;
@Basic(optional = false)
@Column(name = "nombres")
private String nombres;
@Basic(optional = false)
@Column(name = "apellidos")
private String apellidos;
@Column(name = "rol")
private Integer rol;
@Column(name = "fechainactivado")
@Temporal(TemporalType.TIMESTAMP)
private Date fechainactivado;
@Column(name = "llave_cambio_clave")
private String llaveCambioClave;
@Column(name = "fecha_creacion")
@Temporal(TemporalType.TIMESTAMP)
private Date fechaCreacion;
//  @Transient
//  @OneToMany(mappedBy = "usuario", fetch = FetchType.LAZY)
//  private List<ValesXpedido> valesXpedidoList;
//  @Transient
//  @OneToMany(mappedBy = "usuario1", fetch = FetchType.LAZY)
//  private List<ValesXpedido> valesXpedidoList1;
@Transient
String nombrecompleto;
public Usuario()
{
}
public Usuario(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getCorreo() {
return correo;
}
public void setCorreo(String correo) {
this.correo = correo;
}
public String getClave() {
return clave;
}
public void setClave(String clave) {
this.clave = clave;
}
public String getNombres() {
return nombres;
}
public void setNombres(String nombres) {
this.nombres = nombres;
}
public String getApellidos() {
return apellidos;
}
public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}
public Date getFechainactivado() {
return fechainactivado;
}
public void setFechainactivado(Date fechainactivado) {
this.fechainactivado = fechainactivado;
}
public String getLlaveCambioClave() {
return llaveCambioClave;
}
public void setLlaveCambioClave(String llaveCambioClave) {
this.llaveCambioClave = llaveCambioClave;
}
public Integer getInteger() {
return rol;
}
public void setInteger(Integer rol) {
this.rol = rol;
}
public Date getFechaCreacion() {
return fechaCreacion;
}
public void setFechaCreacion(Date fechaCreacion) {
this.fechaCreacion = fechaCreacion;
}
/**
* Método para asignar al usuario todos los datos del usuario que se entrega como parámetro
* @param usuario
*/
public void copiarDatos(Usuario usuario) {
this.id = usuario.getId();
this.apellidos = usuario.getApellidos();
this.clave = usuario.getClave();
this.correo = usuario.getCorreo();
this.fechainactivado = usuario.getFechainactivado();
this.llaveCambioClave = usuario.getLlaveCambioClave();
this.nombres = usuario.getNombres();
this.rol = usuario.getInteger();
this.fechaCreacion = usuario.getFechaCreacion();
}
public String getNombrecompleto() {
nombrecompleto = nombres+" "+apellidos;
return nombrecompleto;
}
public void setNombrecompleto(String nombrecompleto) {
this.nombrecompleto = nombrecompleto;
}
/**
* Setea en nulo los atributos del objeto. este método se invoca para anular la
* sesión del usuario
*/
public void resetear() {
this.id = -1;
this.rol = null;
this.clave = null;
this.nombres = null;
this.apellidos = null;
this.llaveCambioClave = null;
this.clave = null;
this.correo = null;
}
}

Ahora creo el DAO para gestionar la entidad Usuarios, el cual va a heredar del DAO genérico que creamos arriba y le añadiremos métodos específicos para administrar la entidad:

 /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.dao;
import com.ejemplo.vaadin.entidades.Usuario;
import java.util.List;
/**
* (DAO, Objeto de Acceso a Datos)
* DAO para la entidad Usuario
* @author arlex
*/
public interface DaoUsuario extends DaoGenerico<Usuario>
{
/**
* Metodo para obtener los usuarios activos (no eliminados) en la Base de datos
* @return un listado con los objetos Usuario recuperados
*/
public List<Usuario> getActivos();
/**
* Obtiene los usuarios el usuario activo al que corresponde el correo suministrado
* @param correo
* @return El usuario al que corresponde el correo suministrado, o null si no se encuentra
*/
public Usuario getActivoByCorreo( String correo );
}

 /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.dao.hibernate;
/**
*
* @author josorio
*/
import com.ejemplo.vaadin.dao.DaoUsuario;
import com.ejemplo.vaadin.entidades.Usuario;
import java.io.Serializable;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Transactional
@Repository
public class DaoUsuarioImpl extends DaoGenericoImpl<Usuario> implements DaoUsuario, Serializable
{
/**
* {@inheritDoc}
*/
public List<Usuario> getActivos()
{
List<Usuario> retorno = null;
try
{
Criteria criteria = sessionFactory.getCurrentSession().createCriteria( Usuario.class );
criteria.add( Restrictions.isNull( "fechainactivado" ) );
criteria.addOrder(Order.asc("nombres"));
retorno = ( List<Usuario> ) criteria.list();
}
catch( Exception e )
{
e.printStackTrace();
}
return retorno;
}
/**
* {@inheritDoc}
*/
public Usuario getActivoByCorreo( String correo )
{
Usuario retorno = null;
try
{
Criteria criteria = sessionFactory.getCurrentSession().createCriteria( Usuario.class );
criteria.add( Restrictions.eq( "correo", correo ) );
criteria.add( Restrictions.isNull( "fechainactivado" ) );
retorno = ( Usuario ) criteria.uniqueResult();
}
catch( Exception e )
{
e.printStackTrace();
}
return retorno;
}
}

Con esto terminamos la creación de las entidades y los DAO para administrar la información de la base de datos usando hibernate.

Siguiente: Controlador
Volver al menú

Menú

Configuración Inicial

2011-04-06T07:31:00.000-07:00

El IDE Netbeans puede ser bajado de forma gratuita de su página oficial http://www.netbeans.com/, en este tutorial suponemos un manejo básico de este IDE.

Para empezar a trabajar es necesario agregar un plugin al Netbeans, este proceso se describe claramente en el siguiente link:

http://vaadin.com/netbeans

Ahora se crea un nuevo proyecto web añadiendo los frameworsk de Vaadin, Spring e Hibernate.

Se modifican los diferentes archivos xml, como lo son el web.xml y los archivos de configuracion de spring applicationContext.xml y dispatcher-servlet.xml, ademas informacion de conexion con la base de datos para hibernate en un archivo properties.

web.xml (Descriptor comun que controla el comportamiento de la web)

 <?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet>
<servlet-name>VaadinApplication</servlet-name>
<servlet-class>com.ejemplo.vaadin.util.AutowiringApplicationServlet</servlet-class>
<init-param>
<param-name>application</param-name>
<param-value>com.ejemplo.vaadin.MyApplication</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/vaadin/html/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>VaadinApplication</servlet-name>
<url-pattern>/vaadin/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>VaadinApplication</servlet-name>
<url-pattern>/VAADIN/*</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file/>
</welcome-file-list>
</web-app>

applicationContext.xml (fichero de configuración básico de Spring)

Aca definimos los beans basicos y demas configuraciones necesarias para el proyecto.

 <?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:tx="http://www.springframework.org/schema/tx"
xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<context:property-placeholder location = "classpath:application.properties"/>
<!-- ############ Inicio Hibernate ############ -->
<!-- DATASOURCE DECLARATION -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- HIBERNATE SESSION FACTORY -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.generate_statistics">${hibernate.generate_statistics}</prop>
</props>
</property>
<property name="annotatedClasses">
<list>
<value>com.ejemplo.vaadin.entidades.Usuario</value>
</list>
</property>
<property name="eventListeners">
<map>
<entry key="merge">
<bean class="org.springframework.orm.hibernate3.support.IdTransferringMergeEventListener"/>
</entry>
</map>
</property>
</bean>
<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"
p:sessionFactory-ref="sessionFactory"/>
<!-- ############ Fin Hibernate ############ -->
<context:annotation-config />
<tx:annotation-driven/>
<aop:aspectj-autoproxy/>
<!-- Scan por los DAO -->
<context:component-scan base-package="com.ejemplo.vaadin.dao"/>
<!-- Declaramos los servicios explicitamente para poder referenciarlos-->
<bean class="com.ejemplo.vaadin.servicios.impl.ServicioUsuariosImpl" id="servicioUsuarios"/>
</beans>

dispatcher-servlet.xml (Archivo de configuracion de spring)

 <?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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<context:annotation-config />
<context:component-scan base-package="com.ejemplo.vaadin.rest"/>
<bean id="contentNegotiatingViewResolver"
class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
<property name="favorPathExtension" value="true" />
<property name="favorParameter" value="true" />
<!--
default media format parameter name is 'format'
-->
<property name="ignoreAcceptHeader" value="false" />
<property name="order" value="1" />
<property name="mediaTypes">
<map>
<entry key="html" value="text/html"/>
<entry key="json" value="application/json" />
<entry key="xml" value="application/xml" />
</map>
</property>
<property name="viewResolvers">
<list>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
</bean>
</list>
</property>
<property name="defaultViews">
<list>
<bean class="org.springframework.web.servlet.view.json.MappingJacksonJsonView" />
<bean class="org.springframework.web.servlet.view.xml.MarshallingView">
<constructor-arg>
<bean class="org.springframework.oxm.xstream.XStreamMarshaller" />
</constructor-arg>
</bean>
</list>
</property>
</bean>
<!-- Configure the multipart resolver -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- the maximum file size in bytes -->
<property name="maxUploadSize" value="20000000"/>
</bean>

</beans>

application.propertiesAlmacena los parámetros configurables de una aplicación. También se puede utilizar para el almacenamiento de cadenas para la internacionalización y localización (i18n).

 ################ BD ############################
## ESPECIFICOS DE LA BD
## BD DESARROLLO ###############################
jdbc.driverClassName=org.postgresql.Driver
## SERVIDOR BD
jdbc.url=jdbc:postgresql://localhost:5432/ejemplo
jdbc.username=usuario
jdbc.password=contrasena
#
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
############################################################
## FIN SERVIDOR BD
## HIBERNATE SETTINGS
hibernate.generate_statistics=true
hibernate.show_sql=false
hibernate.hbm2ddl.auto=false
########################################################

Se crea servlet para trabajar con Vaadin y con Spring convinados

Servlet necesario para trabajar con Spring y Vaadin relacionados, se define en el web.xml, permite la inyeccion de los beans definidos en el applicationContext.

 /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.util;
import com.vaadin.Application;
import com.vaadin.terminal.gwt.server.ApplicationServlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
//import org.apache.log4j.Logger;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
/**
* {@link ApplicationServlet} that autowires and configures the {@link Application}
* objects it creates using the containing Spring {@link WebApplicationContext}.
*
* <p>
* When using this servlet, annotations such as
* <code>@{@link org.springframework.beans.factory.annotation.Autowired Autowired}</code>
* and <code>@{@link org.springframework.beans.factory.annotation.Required Required}</code>
* and interfaces such as {@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware},
* etc. will work on your {@link Application} instances.
* </p>
*
* <p>
* An example:
* <blockquote><pre>
* &lt;bean id="applicationServlet" class="org.springframework.web.servlet.mvc.ServletWrappingController"
*   p:servletClass="com.example.AutowiringApplicationServlet"&gt;
*   &lt;property name="initParameters"&gt;
*     &lt;props&gt;
*       &lt;prop key="application"&gt;some.spring.configured.Application&lt;/prop&gt;
*       &lt;prop key="productionMode"&gt;true&lt;/prop&gt;
*     &lt;/props&gt;
*   &lt;/property&gt;
* &lt;/bean&gt;
* </pre></blockquote>
*
* @see org.springframework.web.servlet.mvc.ServletWrappingController
* @see AutowireCapableBeanFactory
*/
public class AutowiringApplicationServlet extends ApplicationServlet {
//  protected final Logger log = Logger.getLogger(getClass());
private WebApplicationContext webApplicationContext;
/**
* Initialize this servlet.
*
* @throws ServletException if there is no {@link WebApplicationContext} associated with this servlet's context
*/
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
//    log.debug("finding containing WebApplicationContext");
System.out.println("finding containing WebApplicationContext");
try {
this.webApplicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(config.getServletContext());
} catch (IllegalStateException e) {
throw new ServletException("could not locate containing WebApplicationContext");
}
}
/**
* Get the containing Spring {@link WebApplicationContext}.
* This only works after the servlet has been initialized (via {@link #init init()}).
*
* @throws ServletException if the operation fails
*/
protected final WebApplicationContext getWebApplicationContext() throws ServletException {
if (this.webApplicationContext == null) {
throw new ServletException("can't retrieve WebApplicationContext before init() is invoked");
}
return this.webApplicationContext;
}
/**
* Get the {@link AutowireCapableBeanFactory} associated with the containing Spring {@link WebApplicationContext}.
* This only works after the servlet has been initialized (via {@link #init init()}).
*
* @throws ServletException if the operation fails
*/
protected final AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws ServletException {
try {
return getWebApplicationContext().getAutowireCapableBeanFactory();
} catch (IllegalStateException e) {
throw new ServletException("containing context " + getWebApplicationContext() + " is not autowire-capable", e);
}
}
/**
* Create and configure a new instance of the configured application class.
*
* <p>
* The implementation in {@link AutowiringApplicationServlet} delegates to
* {@link #getAutowireCapableBeanFactory getAutowireCapableBeanFactory()}, then invokes
* {@link AutowireCapableBeanFactory#createBean AutowireCapableBeanFactory.createBean()}
* using the configured {@link Application} class.
* </p>
*
* @param request the triggering {@link HttpServletRequest}
* @throws ServletException if creation or autowiring fails
*/
@Override
protected Application getNewApplication(HttpServletRequest request) throws ServletException {
Class<? extends Application> cl = null;
try {
cl = getApplicationClass();
} catch (ClassNotFoundException e) {
//      log.error( "failed to find the application class" );
System.out.println("failed to find the application class");
}
//    log.debug("creating new instance of " + cl);
System.out.println("creating new instance of " + cl);
AutowireCapableBeanFactory beanFactory = getAutowireCapableBeanFactory();
try {
return beanFactory.createBean(cl);
} catch (BeansException e) {
throw new ServletException("failed to create new instance of " + cl, e);
}
}
}

Si desean compilar el proyecto usando maven este seria el pom.xml:

  
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ejemplo.vaadin</groupId>
    <artifactId>EjemploVaadin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>EjemploVaadin</name>

    <properties>
        <vaadin.version>6.8.15</vaadin.version>
        <gwt.version>2.7.0</gwt.version>
        <gwt.plugin.version>2.2.0</gwt.plugin.version>
        <spring.version>3.0.5.RELEASE</spring.version>
        <version.hibernate>3.5.3-Final</version.hibernate>
        <version.slf4j>1.5.8</version.slf4j>
        <version.log4j>1.2.14</version.log4j>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>com.vaadin</groupId>
            <artifactId>vaadin</artifactId>
            <version>${vaadin.version}</version>
        </dependency>
        
        <dependency>
            <groupId>com.google.gwt</groupId>
            <artifactId>gwt-user</artifactId>
            <version>${gwt.version}</version>
            <scope>provided</scope>
        </dependency>
        
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.3.1</version>
        </dependency>
        
        <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${version.hibernate}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-annotations</artifactId>
            <version>${version.hibernate}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>4.0.2.GA</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.4.GA</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${version.slf4j}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${version.slf4j}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${version.log4j}</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <artifactId>commons-collections</artifactId>
            <groupId>commons-collections</groupId>
            <version>3.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.16</version>
        </dependency>
        
        <dependency>
            <groupId>org.hsqldb</groupId>
            <artifactId>hsqldb</artifactId>
            <version>2.0.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <scope>runtime</scope>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>c</artifactId>
            <version>1.1.1</version>
            <scope>runtime</scope>
            <type>tld</type>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>fmt</artifactId>
            <version>1.1.1</version>
            <scope>runtime</scope>
            <type>tld</type>
        </dependency>
        
        
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>1.0.0.GA</version>
        </dependency>
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>1.0.0.GA</version>
            <classifier>sources</classifier>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>eclipselink</artifactId>
            <version>2.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>javax.persistence</artifactId>
            <version>2.0.3</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>org.eclipse.persistence.jpa.modelgen.processor</artifactId>
            <version>2.2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>jsr250-api</artifactId>
            <version>1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.8.1</version>
        </dependency>
        
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.1</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        
        <dependency>
            <groupId>commons-digester</groupId>
            <artifactId>commons-digester</artifactId>
            <version>1.7</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        
        <dependency>
            <groupId>postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>8.4-702.jdbc4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>

            <!-- Compile custom GWT components or widget dependencies with the GWT compiler -->
            <!-- 
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>gwt-maven-plugin</artifactId>
                <version>${gwt.plugin.version}</version>
                <configuration>
                    <modules>
                        <module>com.ejemplo.vaadin.widgetset.Widgetset</module>
                    </modules>
                    <webappDirectory>src/main/webapp/VAADIN/widgetsets</webappDirectory>
                    <extraJvmArgs>-Xmx512M -Xss1024k</extraJvmArgs>
                    <runTarget>DrDental</runTarget>
                    <hostedWebapp>${project.build.directory}/${project.build.finalName}</hostedWebapp>
                    <noServer>true</noServer>
                    <port>8080</port>
                    <compileReport>false</compileReport>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>resources</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>com.google.gwt</groupId>
                        <artifactId>gwt-user</artifactId>
                        <version>2.3.0</version>
                    </dependency>
                    <dependency>
                        <groupId>com.google.gwt</groupId>
                        <artifactId>gwt-dev</artifactId>
                        <version>2.3.0</version>
                    </dependency>
                </dependencies>
            </plugin>
            
            <plugin>
                <groupId>com.vaadin</groupId>
                <artifactId>vaadin-maven-plugin</artifactId>
                <version>1.0.2</version>
                <configuration>
                    <module>com.ejemplo.vaadin.widgetset.Widgetset</module>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>update-widgetset</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
                  -->

            <!-- A simple Jetty test server at http://localhost:8080/DrDental can be launched with the Maven goal jetty:run
        and stopped with jetty:stop -->
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <version>6.1.24</version>
                <configuration>
                    <stopPort>9966</stopPort>
                    <stopKey>Vaadin</stopKey>
                    <!-- Redeploy every x seconds if changes are detected, 0 for no automatic redeployment -->
                    <scanIntervalSeconds>0</scanIntervalSeconds>
                    <!-- make sure Jetty also finds the widgetset -->
                    <webAppConfig>
                        <contextPath>/vaadin</contextPath>
                        <baseResource implementation="org.mortbay.resource.ResourceCollection">
                            <!-- Workaround for Maven/Jetty issue http://jira.codehaus.org/browse/JETTY-680 -->
                            <!-- <resources>src/main/webapp,${project.build.directory}/${project.build.finalName}</resources> -->
                            <resourcesAsCSV>src/main/webapp,${project.build.directory}/${project.build.finalName}
                            </resourcesAsCSV>
                        </baseResource>
                    </webAppConfig>
                </configuration>
            </plugin>
        </plugins>
        <finalName>vaadin</finalName>
    </build>
    
    <repositories>
        <repository>
            <id>vaadin-snapshots</id>
            <url>http://oss.sonatype.org/content/repositories/vaadin-snapshots/</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>        
        <repository>
            <id>vaadin-addons</id>
            <url>http://maven.vaadin.com/vaadin-addons</url>
        </repository>
        <!--repository>
            <url>http://ftp.ing.umu.se/mirror/eclipse/rt/eclipselink/maven.repo</url>
            <id>eclipselink</id>
            <layout>default</layout>
            <name>Repository for library Library[eclipselink]</name>
        </repository-->
        <!--repository>
         <id>EclipseLink Repo</id>
         <url>http://www.eclipse.org/downloads/download.php?r=1&amp;nf=1&amp;file=/rt/eclipselink/maven.repo</url>
         --><!-- use this for javax.persistence-->
         <!--snapshots>
            <enabled>true</enabled>
         </snapshots> -->
      <!--/repository-->
    </repositories>
    
    <pluginRepositories>
        <pluginRepository>
            <id>codehaus-snapshots</id>
            <url>http://nexus.codehaus.org/snapshots</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
            <releases>
                <enabled>false</enabled>
            </releases>
        </pluginRepository>
        <pluginRepository>
            <id>vaadin-snapshots</id>
            <url>http://oss.sonatype.org/content/repositories/vaadin-snapshots/</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
            <releases>
                <enabled>false</enabled>
            </releases>
        </pluginRepository>
    </pluginRepositories>

</project>

Siguiente: Modelo
Volver al menú

Menú

Vaadin Spring e Hibernate

2011-04-05T15:22:00.000-07:00

Introducción

Vaadin: es un framework para aplicaciones web de código abierto. En contraste con las bibliotecas JavaScript y un plug-in de navegador que ofrece soluciones basadas en una arquitectura de servidor, lo que significa que la mayoría de la lógica se ejecuta en los servidores. La tecnología Ajax se utiliza en el lado del navegador para asegurar una experiencia de usuario rica e interactiva. Vaadin esta pensado para trabajar sin preocuparnos de estar en el lado del cliente o del servidor y se puede extender usando Google Web Toolkit (GWT). (Wikipedia).

Se puede obtener

información adicional en la página oficial, además se cuenta con tutoriales y códigos de ejemplo. http://vaadin.com/tutorial, http://demo.vaadin.com/sampler/

El Spring Framework (también conocido simplemente como Spring) es un framework de código abierto de desarrollo de aplicaciones para la plataforma Java. La primera versión fue escrita por Rod Jonhson, quien lo lanzó primero con la publicación de su libro Expert One-on-One Java EE Design and Development (Wrox Press, octubre 2002). También hay una versión para la plataforma .NET, Spring .NET . (Wikipedia). http://www.springsource.org/

Hibernate es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma Java (y disponible también para .Net con el nombre de NHibernate) que facilita el mapeo de atributos entre una base de datos relacional tradicional y el modelo de objetos de una aplicación, mediante archivos declarativos (XML) o anotaciones en los beans de las entidades que permiten establecer estas relaciones. Hibernate es software libre, distribuido bajo los términos de la licencia GNU LGPL. (Wikipedia). http://www.hibernate.org/

Contenido

La idea de este blog es mostrar como integrar estas tres tecnologías de desarrollo para construir aplicaciones web ricas basadas en java, no se entrará en mucho detalle en ninguno de los frameworks arriba mencionados, se supondrá que ya se tienen bases de programación en lenguaje JAVA y en el uso de los frameworks Spring, Hibernate y Vaadin (de ser necesario pueden consultar las páginas oficiales de cada uno).

Se trabajará con el IDE Netbeans 6.9.1 para efectos de desarrollo.

En los siguientes posts ire describiendo el proceso de integración de estos tres frameworks.

Menú

El código del proyecto lo pueden encontrar en github construido con maven

https://github.com/juliandresog/VaadinEjemplo.git