rails y más cosas » spring http://www.railsymas.com Nuevas Tecnologías Sat, 28 Jan 2012 10:23:40 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 Spring mvc uno a muchos hibernate http://www.railsymas.com/2012/01/02/spring-mvc-uno-a-muchos-hibernate/ http://www.railsymas.com/2012/01/02/spring-mvc-uno-a-muchos-hibernate/#comments Mon, 02 Jan 2012 17:56:48 +0000 admin http://www.railsymas.com/?p=2578 Siguiendo con los ejemplos de spring framework con hibernate en este caso establecemos una relación uno a muchos con jpa

La siguiente imagen corresponde a una vista jsp donde tenemos una llamada a la acción que desencadena el ejemplo

Creamos la interface Unoamuchos que nos servirá de esqueleto para nuestra aplicación

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package recursos;
 
import java.util.List;
import modelos.Propietario;
import modelos.Automovil;
 
public interface Unoamuchos {
 
	public List<Propietario> listadoPropietarios();
	public List<Automovil>  listadoAutomoviles();
	public void introducirPropietario (Propietario propietario);
 
 
 
}

Implementación de la interface

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package recursos;
 
import modelos.Automovil;
import modelos.Propietario;
import java.util.List;
import org.springframework.orm.hibernate3.HibernateTemplate;
 
 
public class UnoamuchosImpl implements Unoamuchos {
 
 
 
 
		private HibernateTemplate hibernateTemplate;
 
		public HibernateTemplate getHibernateTemplate() {
			return hibernateTemplate;
		}
 
		public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
			this.hibernateTemplate = hibernateTemplate;
		}
		@SuppressWarnings("unchecked")
		public List <Propietario> listadoPropietarios()
		{
			return (List<Propietario>) hibernateTemplate.find("from Propietario");
		}
 
		@SuppressWarnings("unchecked")
		public List <Automovil> listadoAutomoviles()
		{
		  	return (List<Automovil>) hibernateTemplate.find("from Automovil");
		}
 
		public void introducirPropietario (Propietario propietario)
		{
			hibernateTemplate.saveOrUpdate(propietario);
		}
 
 
 
	}

Imagen del formulario de entrada de datos

Listado de datos una vez introducidos

Configuración del bean de gestión

1
2
3
4
5
6

 
   <bean name="/formulariopropietario.html" class="controlador.ControladorPropietario">
 
    <property name="methodNameResolver" ref="paramResolver"/>
    <property name="propieatarioDao" ref="propietarioDao"/>
   </bean>

Controlador encargado de la gestión

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

package controlador;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
 
import org.springframework.ui.ModelMap;
import ClasesBean.DatosPropietario;
import recursos.Unoamuchos;
import modelos.Propietario;
import modelos.Automovil;
import java.util.List;
import java.util.ArrayList;
 
public class ControladorPropietario extends MultiActionController {
 
    private Unoamuchos	propieatarioDao;
    private List<Automovil> listaautomoviles =  new ArrayList <Automovil> ();
 
 
	public Unoamuchos getPropieatarioDao() {
		return propieatarioDao;
	}
 
 
 
	public void setPropieatarioDao(Unoamuchos propieatarioDao) {
		this.propieatarioDao = propieatarioDao;
	}
 
 
 
	public ModelAndView introducirDatos ( HttpServletRequest request, HttpServletResponse response, DatosPropietario propietario) throws Exception
	{
 
		Propietario owner = new Propietario();
		Automovil automovil = new Automovil();
 
		automovil.setMarca(propietario.getMarca());
		automovil.setModelo(propietario.getModelo());
		owner.setNombre(propietario.getNombre());
		owner.setApellidos(propietario.getApellidos());
 
		listaautomoviles.add(automovil);
		owner.setPropietarioautomovil(listaautomoviles);
 
        propieatarioDao.introducirPropietario(owner);
 
 
    	ModelMap mapa = new ModelMap();
 
    	mapa.addAttribute("propietarios",propieatarioDao.listadoPropietarios() );
 
    	mapa.addAttribute("automoviles",propieatarioDao.listadoAutomoviles());
 
    	ModelAndView vista = new ModelAndView("resultadopropietario",mapa);
 
    	return vista;
 
 
 
	}
 
 
 
	public ModelAndView introducirPropietario (HttpServletRequest request, HttpServletResponse response, DatosPropietario propietario) throws Exception
	{
		ModelAndView vista = new ModelAndView ("formulariopropietario","propietario",propietario);
 
		return vista;
	}
 
 
 
 
}

Clase modelo propietario

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package modelos;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GenerationType;
import javax.persistence.Table;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.JoinTable;
import javax.persistence.JoinColumn;
 
 
@Entity
@Table (name="propietario")
public class Propietario {
 
	private long propietarioid;
	private String nombre;
	private String apellidos;
	private List<Automovil> propietarioautomovil;
 
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="propietario_id")
	public long getPropietarioid() {
		return propietarioid;
	}
	public void setPropietarioid(long propietarioid) {
		this.propietarioid = propietarioid;
	}
	@Column(name="nombre", nullable=false, length=25)
	public String getNombre() {
		return nombre;
	}
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	@Column(name="apellidos",nullable=false,length=50)
	public String getApellidos() {
		return apellidos;
	}
	public void setApellidos(String apellidos) {
		this.apellidos = apellidos;
	}
	@OneToMany(cascade = CascadeType.ALL)
	@JoinTable(name="propietario_automovil", joinColumns ={@JoinColumn (name="propietario_id")}, inverseJoinColumns={@JoinColumn (name="automovil_id")})
	public List<Automovil> getPropietarioautomovil() {
		return propietarioautomovil;
	}
	public void setPropietarioautomovil(List<Automovil> propietarioautomovil) {
		this.propietarioautomovil = propietarioautomovil;
	}
 
 
 
 
}

Clase modelo Automovil

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package modelos;
 
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Entity;
import javax.persistence.Table;
 
 
@Entity
@Table(name="automovil")
public class Automovil {
 
	private Long automovilid;
 
	private String marca;
	private String modelo;
 
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="automovil_id")
	public Long getAutomovilid() {
		return automovilid;
	}
	public void setAutomovilid(Long automovilid) {
		this.automovilid = automovilid;
	}
 
	@Column(name="marca",nullable=false,length=50)
	public String getMarca() {
		return marca;
	}
 
	public void setMarca(String marca) {
		this.marca = marca;
	}
	@Column(name="modelo",nullable=false,length=50)
	public String getModelo() {
		return modelo;
	}
	public void setModelo(String modelo) {
		this.modelo = modelo;
	}
 
 
 
 
}

Configuración de la factoria en dispatcher-servlet.xml

1
2
3
4
5
6
7
8
9
10

 <bean id="conexionFactoria" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="dataSource" ref="datasource"/>
    <property name="annotatedClasses">
       <list>
 
       <value>modelos.Propietario</value>  
       <value>modelos.Automovil</value> 
 
       </list>
    </property>


]]> http://www.railsymas.com/2012/01/02/spring-mvc-uno-a-muchos-hibernate/feed/ 0 Integración plantillas velocity Spring framework http://www.railsymas.com/2011/12/28/integracion-plantillas-velocity-spring-framework-eg/ http://www.railsymas.com/2011/12/28/integracion-plantillas-velocity-spring-framework-eg/#comments Wed, 28 Dec 2011 17:23:12 +0000 admin http://www.railsymas.com/?p=1645 En anteriores post ya se habían expuesto tanto la forma de descargar el proyecto velocity como las características generales de cómo trabajar con velocity.

Para facilitar el trabajo con platillas velocity habíamos recomendado un plugin para el editor eclipse
llamado veloeclipse

Ahora en este post vemos la forma de integrarlo en uno de los frameworks más importantes de java como es spring framework. Spring nos ofrece un importante soporte para dichas plantillas facilitando su integración

Simplemente el ejercicio que se muestra es una forma alternativa de mostrar los resultados al igual que hacíamos con spring mvc mostrando las vistas con jsp normales

Para ello vamos a configurar el motor de velocity para spring, crearemos dentro del fichero de configuración de spring en nuestro caso, dispatcher-servlet.xml un bean velocityconfigurer aunque el nombre del bean es opcional lo ponemos para acordarnos de que estamos creando una configuración para velocity

Dentro del bean velocityConfigurer tenemos una propiedad resourceLoaderPath con el valor WEB-INF/plantillasvelocity . Con esto estamos configurando el motor de plantillas velocity y le decimos a velocity donde encontrar las plantillas.

Una vez hecho lo anterior debemos de configurar la resolución de visualización para velocity
para ello creamos un bean nombre viewResolver de clase VelecityViewResolver y declaramos la propiedad suffix con el valo .vm

1
2
3
4
5
6
7
8
9
10

 
    <bean id="viewResolver" class="org.springframework.web.servlet.view.velocity.VelocityViewResolver" >
 
    <property name="suffix" value=".vm"/> 
 
    </bean>
 
    <bean id="velocityConfigurer"       class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
     <property name="resourceLoaderPath" value="/WEB-INF/plantillasvelocity"/>
    </bean>

Código para la página ejercicios.vm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<link rel="stylesheet" href="css/estilo.css" type="text/css"/>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Ejercicios</title>
</head>
	<body>
		<div id="contenedor">
            <h2>Ejercicios</h2>
	        <div class="campo">
             <a href="basico.html">1) Trabajo b&aacute;sico con plantillas</a>
			</div>
			<div class="campo">
            <a href="objetos.html"> 2) Trabajo con objetos  </a>
            </div>
			<div id="pie">
				<p>www.railsymas.com</p>
            </div>
        </div>
    </body>
 </html>

visualización de ejercicios.vm

Simplemente en ejercicios tenemos dos enlaces a dos acciones, la diferencia que se puede apreciar con respecto a jsp es que no hemos declarado ninguna librería

En este ejemplo básico se accede a una platilla en la que se muestra el mensaje almacenado en un bean de configuración

Código de básico.vm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<link rel="stylesheet" href="css/estilo.css" type="text/css"/>
<title>basico</title>
</head>
<body>
 
 <div id="contenedor">
 
  ${mensajeporpantalla}
 
  <div id="pie">
 
   <p>www.railsymas.com</p>
 
 </div>
 
 </div>
 
</body>
</html>

Visualización de la plantilla básico.vm

Dentro del fichero de configuración dispatcher-servlet.xml se declara el bean basico.html asociado al controlador con el nombre basico en el package controlador y una propieadad mensaje con el valor hola plantillas velocity que será lo que salga por pantalla

1
2
3

  <bean name="/basico.html" class="controlador.Basico">
    <property name="mensaje" value="hola plantilas velocity"/>
    </bean>

Código del controlador Basico.java

Simplemente generamos un setter para la propiedad mensaje y mediante ModelAndView cargamos los datos en la vista con el valor del string mensajeporpantalla

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

 
package controlador;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
 
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
 
 
 
 
public class Basico  extends AbstractController
{
    private String mensaje;
 
	public ModelAndView handleRequestInternal (HttpServletRequest request, HttpServletResponse response)
	{
		return new ModelAndView("basico","mensajeporpantalla",this.mensaje);
	}
 
 
 
	public void setMensaje(String mensaje) {
		this.mensaje = mensaje;
	}
 
 
 
}

En otro ejemplo más complejo se verán el tratamiento de objetos y formularios

]]> http://www.railsymas.com/2011/12/28/integracion-plantillas-velocity-spring-framework-eg/feed/ 0 Exportando los datos a pdf con spring framework http://www.railsymas.com/2011/10/31/exportando-los-datos-a-pdf-con-spring-framework/ http://www.railsymas.com/2011/10/31/exportando-los-datos-a-pdf-con-spring-framework/#comments Mon, 31 Oct 2011 16:20:07 +0000 admin http://www.railsymas.com/?p=2494 En el anterior post habíamos visto para la categoría de spring framework un ejemplo de relación uno a uno con hibernate donde teníamos la posibilidad de además de almacenar los datos exportarlos a excel

En el siguiente ejemplo vamos a exportar esos mismos datos a formato pdf

Datos introducidos para un estudiante laura, maria y juan

Visualización de datos

Pulsamos sobre el icono de fichero pdf

Código de la clase de recursos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

 package recursos;
 
import java.util.List;
import java.util.Map;
import java.util.Iterator;
 
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.view.document.AbstractPdfView;
 
import com.lowagie.text.Document;
import com.lowagie.text.Element;
 
import com.lowagie.text.pdf.PdfWriter;
import com.lowagie.text.pdf.PdfPTable;
import com.lowagie.text.pdf.PdfPCell;
 
 
import modelos.Estudiante;
import modelos.Direccion;
 
import java.io.ByteArrayOutputStream;
 
import com.lowagie.text.Paragraph;
 
import java.awt.Color;
 
public class GenerarPdf  extends AbstractPdfView {
 
 
	 private ByteArrayOutputStream fichero = new ByteArrayOutputStream();
 
 
	public void buildPdfDocument ( Map model, Document document, PdfWriter pdfwriter,HttpServletRequest request, HttpServletResponse response) throws Exception
	{  
 
		List<Estudiante> estudiantes = (List) model.get("estudiantes");
		List<Direccion> direcciones = (List) model.get("direcciones");
 
 
 
 
		document.open();
 
 
		PdfPTable tablaestudiantes = new PdfPTable(2);
 
		PdfPCell celdanombre = new PdfPCell(new Paragraph("nombre"));
		PdfPCell celdaedad = new PdfPCell(new Paragraph("edad"));
		PdfPCell tituloestudiantes = new PdfPCell( new Paragraph("listado estudiantes"));
		tituloestudiantes.setColspan(2);
		tituloestudiantes.setBackgroundColor(new Color(214,246,145));
		tituloestudiantes.setHorizontalAlignment(Element.ALIGN_CENTER);
		celdanombre.setHorizontalAlignment(Element.ALIGN_CENTER);
		celdanombre.setBackgroundColor(new Color(217,217,180));
		celdaedad.setHorizontalAlignment(Element.ALIGN_CENTER);
		celdaedad.setBackgroundColor(new Color(217,217,180));
 
 
		tablaestudiantes.addCell(tituloestudiantes);
		tablaestudiantes.addCell(celdanombre);
		tablaestudiantes.addCell(celdaedad);
 
 
 
	    for ( Iterator<Estudiante> iterador =  estudiantes.iterator(); iterador.hasNext();)
	    {
	    	Estudiante estudiante = (Estudiante) iterador.next();
	    	tablaestudiantes.addCell(estudiante.getNombre());
	    	tablaestudiantes.addCell(estudiante.getEdad());
	    }
 
 
	    document.add(tablaestudiantes);
 
	    document.add(new Paragraph("                                         "));
 
	    PdfPTable tabladirecciones =  new PdfPTable(2);
 
 
	    PdfPCell celdacalle= new PdfPCell(new Paragraph("calle"));
		PdfPCell celdalocalidad = new PdfPCell(new Paragraph("localidad"));
		PdfPCell titulodirecciones = new PdfPCell( new Paragraph("listado direcciones"));
 
		titulodirecciones.setColspan(2);
		titulodirecciones.setBackgroundColor(new Color(214,246,145));
		titulodirecciones.setHorizontalAlignment(Element.ALIGN_CENTER);
		celdacalle.setBackgroundColor(new Color(217,217,180));
		celdacalle.setHorizontalAlignment(Element.ALIGN_CENTER);
		celdalocalidad.setBackgroundColor(new Color(217,217,180));
		celdalocalidad.setHorizontalAlignment(Element.ALIGN_CENTER);
 
		tabladirecciones.addCell(titulodirecciones);
	        tabladirecciones.addCell(celdacalle);
	        tabladirecciones.addCell(celdalocalidad);
 
 
 
 
	    for ( Iterator<Direccion> iterador =  direcciones.iterator(); iterador.hasNext();)
	    {
	    	Direccion direccion = (Direccion) iterador.next();
	    	tabladirecciones.addCell(direccion.getCalle());
	    	tabladirecciones.addCell(direccion.getLocalidad());
	    }
 
	    document.add(tabladirecciones);
 
	    document.close();
 
 
	    response.setContentType("application/pdf");
 
	    response.setContentLength(this.fichero.size());
 
	    response.setHeader("Content-disposition","attachment; filename=estudiantes.pdf" );
 
	    ServletOutputStream out = response.getOutputStream();
 
	    this.fichero.writeTo(out);
 
	    out.flush();
 
 
 
	}
 
 
 
 
	public void llamandoBuildPdf(Map<String,List> model,HttpServletRequest request, HttpServletResponse response) throws Exception
	{
 
	   Document document = new Document();
 
	   document.addTitle("listado estudiantes hibernate ");
 
 
 
	   PdfWriter aux  =	PdfWriter.getInstance(document,this.fichero);
 
	   buildPdfDocument (model,document,aux, request, response);
 
 
 
 
	}
 
 
 
}

Gracias al controlador que lo hemos declarado como multiactioncontroller podemos realizar múltiples acciones en un mismo fichero de clase permitiéndonos introducir los datos en la base de datos así como exportarlos tanto a excel como a pdf

Modificamos la vista del formulario de estudiantes del anterior ejemplo para ello creamos un menú para tener las dos opciones disponibles

css encargada del menú

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

ul{
 
 margin-left:300px;
 
 }
 
 ul li { 
  float:left;
  margin-right:10px;
  list-style-type: none;
 }  
 
 #enlacepdf a{
 
   background-image: url("../imagenes/file_pdf.png");
   background-repeat: no-repeat;
   display:block;
   width:50px;
   height:50px;
 
 
 
 }
 
 #enlaceexcel a {
 background-image: url("../imagenes/file_excel.png");
 background-repeat: no-repeat;
 display:block;
 width:55px;
 height:55px;
 
 
 
 }

Dentro del controlador estudiante añadimos el método

generarPdf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

  public void generarPdf(HttpServletRequest request, HttpServletResponse response) throws Exception
    {
 
 
      List<Estudiante> estudiantes = estudianteDao.listadoEstudiantes();
 
      List<Direccion> direcciones = estudianteDao.listadoDireccion();
 
      Map modelmap = new HashMap <String,List>();
 
      modelmap.put("estudiantes", estudiantes);
 
      modelmap.put("direcciones", direcciones);      
 
      GenerarPdf pdf = new GenerarPdf();
 
      pdf.llamandoBuildPdf(modelmap, request, response);
 
 
 
 
 
 
 
    }

Cambiamos el código de la página para poder visualizar el menú

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

<%@ page language="java" contentType="text/html; charset=UTF-8" 
    pageEncoding="UTF-8"%>
<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<link rel="stylesheet" href="css/estilo.css" type="text/css"/>
<title><spring:message code="unoanuno.resultado"/></title>
</head>
<body>
 
 <div id="contenedor">
 
 
 
 <ul id="menu">
 <li>
 <div id="enlacepdf">
 <a href="<c:url value='formularioestudiante.html?method=generarPdf'/>"></a>
 </div>
 </li>
 <li>
 <div id="enlaceexcel">
  <a href="<c:url value='formularioestudiante.html?method=generarExcel'/>"></a>
 </div>
 </li>
 </ul>
 
 
 
 
 <div id="borrar">
   &nbsp;
 </div>
 
 <div class="campo">
 
 <c:out value="listado de  estudiantes"/>
 
 <br/>
 
 <div class="tabla">
 
 <table title="listado de estudiantes">
 <tr>
 <th>nombre</th>
 <th>edad</th> 
 </tr>
 <c:forEach items="${estudiantes}" var="estudiante">
 
  <tr>
 
  <td class="impar">  <c:out value="${estudiante.nombre}"/> </td>
  <td class="par">  <c:out value="${estudiante.edad}"/> </td>
  </tr>
 </c:forEach>
 
 </table>
 </div>
 
 
 </div>
 
 <div class="campo">
 
 <c:out value="listado de direcciones"/>
 
 <br/>
 
 <div class="tabla">
 
 <table title="listado de direcciones">
 
 <tr>
 <th>calle</th>
 <th>localidad</th> 
 </tr>
 
 <c:forEach items="${direcciones}" var="direccion">
 <tr> 
 <td class="impar"> <c:out value="${direccion.calle}"/> </td>
 <td class="par"> <c:out value="${direccion.localidad}"/> </td>
 </tr> 
 </c:forEach>
 
 </table>
 
 <a href="<c:url value="/ejercicios.html"/>">Regreso a ejercicios</a>
 
 </div>
 
 
 
 </div>
 
 
 
 
 <div id="pie">
   <p>www.railsymas.com</p>
 </div>
 </div>
 
</body>
</html>

Resultado

Al igual que en el ejemplo de excel en este ejemplo para el desarrollo de spring mvc pdf e hibernate no es el objetivo un tutorial sobre la librería itext por ello para mayor entendimiento y más ejemplos se deriva a la siguiente dirección web para completar conocimientos

Rose India

]]> http://www.railsymas.com/2011/10/31/exportando-los-datos-a-pdf-con-spring-framework/feed/ 0 Exportando datos a excel con spring framework http://www.railsymas.com/2011/10/26/exportando-datos-a-excel-con-spring-framework/ http://www.railsymas.com/2011/10/26/exportando-datos-a-excel-con-spring-framework/#comments Wed, 26 Oct 2011 15:27:15 +0000 admin http://www.railsymas.com/?p=2460 Habíamos visto la inserción de datos mediante jdbcTemplate de spring y luego un ejemplo sobre hibernate en una relación de uno a uno

En la primera imagen podemos observar un formulario para introducir los datos estará controlado por hibernate

Código del formulario de introducción de datos del estudiante “formularioestudiante.jsp”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

<%@ page language="java" contentType="text/html; charset=UTF-8"  pageEncoding="UTF-8"%>
<%@taglib uri="http://www.springframework.org/tags" prefix="spring"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title><spring:message code="unoauno.titulo"/></title>
<link rel="stylesheet" type="text/css" href="css/estilo.css"/>
</head>
<body>
 <div id="contenedor" >
 
   <h2><spring:message code="unoauno.titulo"/></h2>
 
   <form:form action="formularioestudiante.html"  method="post" commandName="datosestudiante"> 
   <div class="campo">
    <spring:message code="unoauno.nombre"/>
    <br/>
    <form:input path="nombre"/>
 
   </div>
 
   <div class="campo">
    <spring:message code="unoauno.edad"/>
    <br/>
    <form:input path="edad"/>
   </div>
 
   <div class="campo">
    <spring:message code="unoauno.calle"/>
    <br/>
    <form:input path="calle"/> 
   </div>
 
   <div class="campo">
    <spring:message code="unoauno.localidad"/>
    <br/>
    <form:input path="localidad"/>
   </div>
 
 
   <input type="hidden" name="method" value="introducirDatos"/>
 
   <input type="submit" value="enviar" class="boton"/>
 
 
   </form:form>
 
   <div id="pie">
    <p>www.railsymas.com</p>
   </div>
 
 </div>
</body>
</html>

En el formulario llamamos al método introducirDatos

Mensajes utilizados en las vistas de los ficheros jsp dentro del fichero messages_es_xx.properties

1
2
3
4
5
6
7

unoauno.titulo = formulario uno a uno spring hibernate
unoauno.nombre = Introduce tu nombre:
unoauno.edad =  Introduce tu edad:
unoauno.calle = Introduce la tu calle:
unoauno.localidad = Intoduce tu localidad:
 
unoanuno.resultado = Listados estudiantes y direcciones

En la siguiente imagen se muestra al usuario seleccionando un icono para lanzar la acción
de creación del fichero excel

Códigio del formulario resultadoestudiante.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

<%@ page language="java" contentType="text/html; charset=UTF-8" 
    pageEncoding="UTF-8"%>
<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<link rel="stylesheet" href="css/estilo.css" type="text/css"/>
<title><spring:message code="unoanuno.resultado"/></title>
</head>
<body>
 
 <div id="contenedor">
 
 
 
 
 <div id="enlaceexcel">
  <a href="<c:url value="formularioestudiante.html?method=generarExcel"/>"></a>
 </div>
 
 
 
 <div id="borrar">
   &nbsp;
 </div>
 
 <div class="campo">
 
 <c:out value="listado de  estudiantes"/>
 
 <br/>
 
 <div class="tabla">
 
 <table title="listado de estudiantes">
 <tr>
 <th>nombre</th>
 <th>edad</th> 
 </tr>
 <c:forEach items="${estudiantes}" var="estudiante">
 
  <tr>
 
  <td class="impar">  <c:out value="${estudiante.nombre}"/> </td>
  <td class="par">  <c:out value="${estudiante.edad}"/> </td>
  </tr>
 </c:forEach>
 
 </table>
 </div>
 
 
 </div>
 
 <div class="campo">
 
 <c:out value="listado de direcciones"/>
 
 <br/>
 
 <div class="tabla">
 
 <table title="listado de direcciones">
 
 <tr>
 <th>calle</th>
 <th>localidad</th> 
 </tr>
 
 <c:forEach items="${direcciones}" var="direccion">
 <tr> 
 <td class="impar"> <c:out value="${direccion.calle}"/> </td>
 <td class="par"> <c:out value="${direccion.localidad}"/> </td>
 </tr> 
 </c:forEach>
 
 </table>
 
 <a href="<c:url value="/ejercicios.html"/>">Regreso a ejercicios</a>
 
 </div>
 
 
 
 </div>
 
 
 
 
 <div id="pie">
   <p>www.railsymas.com</p>
 </div>
 </div>
 
</body>
</html>

En la siguiente imagen se muestra la pantalla contextual de creación del fichero excel estudiante para guardar o visualizar

Una vez abierto el fichero excel se visualizan los datos cargados

Basándonos en el ejemplo hibernate uno a uno

Una vez arrancado nuestro proyecto en la realización del ejemplo en el navegador tendríamos
urlproyecto\formularioestudiante.html?method=introducirEstudiante

El bean encargado de recoger la acción declarado en el fichero de configuración dispatcher-servlet.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

 
 <bean id="template" class="org.springframework.orm.hibernate3.HibernateTemplate">
      <property name="sessionFactory" ref="conexionFactoria"/>
    </bean>
 
 <bean id="estudianteDao" class="recursos.UnoaunoImpl">
 
        <property name="hibernateTemplate" ref="template"/>
 
    </bean>
 
 
 
    <bean name="/formularioestudiante.html" class="controlador.ControladorEstudiante">
      <property name="methodNameResolver" ref="paramResolver"/>
      <property name="estudianteDao" ref="estudianteDao"/>
    </bean>

La propiedad estudianteDao nos permite trabajar con una sesión factoria, el controlador estudiante recibe la petición para ser tratada.

Código controlador estudiante

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

package controlador;
 
import org.springframework.web.servlet.ModelAndView;
 
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import ClasesBean.DatosEstudiante;
import modelos.Direccion;
import modelos.Estudiante;
import recursos.Unoauno;
import org.springframework.ui.ModelMap;
import java.util.Map;
import java.util.List;
import java.util.HashMap;
 
import recursos.GenerarExcel;
 
public class ControladorEstudiante extends MultiActionController 
{
 
	private Unoauno estudianteDao;
 
 
	public Unoauno getEstudianteDao() {
		return estudianteDao;
	}
 
 
	public void setEstudianteDao(Unoauno estudianteDao) {
		this.estudianteDao = estudianteDao;
	}
 
    public ModelAndView introducirDatos (HttpServletRequest request, HttpServletResponse response, DatosEstudiante datosestudiante) throws Exception
    {
 
 
    	Direccion direccion = new Direccion();
    	Estudiante estudiante = new Estudiante();
 
    	direccion.setCalle(datosestudiante.getCalle());
    	direccion.setLocalidad(datosestudiante.getLocalidad());
    	estudiante.setNombre(datosestudiante.getNombre());
    	estudiante.setEdad(datosestudiante.getEdad());
    	estudiante.setEstudiantedireccion(direccion);
 
    	estudianteDao.introducirEstudiante(estudiante);
 
 
 
    	ModelMap mapa = new ModelMap();
 
    	mapa.addAttribute("estudiantes",estudianteDao.listadoEstudiantes() );
 
    	mapa.addAttribute("direcciones",estudianteDao.listadoDireccion());
 
    	ModelAndView vista = new ModelAndView("resultadoestudiante",mapa);
 
    	return vista;
    }
 
 
 
 
    public void generarExcel (HttpServletRequest request, HttpServletResponse response ) throws Exception
    {
    	List<Estudiante> estudiantes = estudianteDao.listadoEstudiantes();
    	List<Direccion> direcciones = estudianteDao.listadoDireccion();
 
    	Map modelmap = new HashMap <String,List> ();
 
    	modelmap.put("estudiantes", estudiantes);
    	modelmap.put("direcciones",direcciones);
 
    	GenerarExcel excel = new GenerarExcel();
 
    	excel.llamandoBuildExcelDocument(request, response, modelmap);
 
 
    	System.out.println("generar excel");
 
 
 
    }
 
 
	public ModelAndView introducirEstudiante (HttpServletRequest request, HttpServletResponse response, DatosEstudiante datosestudiante) throws Exception
	{
	  	return new ModelAndView("formularioestudiante","datosestudiante",datosestudiante);
	}
 
 
 
 
 
}

La clase controlador estudiante extiende de multiactionController que ya habíamos visto su funcionamiento en un post anterior

ejemplo de multiactionController

una vez que introducimos los datos en el sistema de bases de datos mediante hibernate mostramos la vista resultadoestudiante.jsp

Dentro del package recursos tenemos la clase encargada de generar el fichero excel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

package recursos;
 
 
 
import java.util.Iterator;
import java.util.Map;
import java.util.List;
 
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFRow;
 
 
 
import modelos.Estudiante;
import modelos.Direccion;
 
 
import org.springframework.web.servlet.view.document.AbstractExcelView;
 
import java.io.ByteArrayOutputStream;
 
 
public class GenerarExcel  extends AbstractExcelView
{   
 
 
	private ByteArrayOutputStream fichero = new ByteArrayOutputStream();
    private int numerofilas; 
 
	@SuppressWarnings("deprecation")
	@Override
	protected void buildExcelDocument(Map model, HSSFWorkbook libro ,
			HttpServletRequest request, HttpServletResponse response) throws Exception 
    {
		// TODO Auto-generated method stub
 
		List <Estudiante> estudiantes = (List) model.get("estudiantes");
		List <Direccion> direcciones = (List) model.get("direcciones");
 
		HSSFCellStyle estilo = libro.createCellStyle();
 
 
		//creación de una hoja
		HSSFSheet hoja = libro.createSheet("libro estudiantes");
 
 
 
		//creamos la fila cabecera
		HSSFRow fila0 =  hoja.createRow(0);
 
 
		fila0.createCell(0).setCellValue("nombre");
		fila0.createCell(1).setCellValue("edad");
 
		this.numerofilas = 1;
 
 
		for (Iterator iterador = estudiantes.iterator(); iterador.hasNext();)
		{
			Estudiante estudiante = (Estudiante) iterador.next();
 
			HSSFRow fila = hoja.createRow(this.numerofilas ++);
 
			fila.createCell(0).setCellValue(estudiante.getNombre());
			fila.createCell(1).setCellValue(estudiante.getEdad());
		}
 
 
		try
		{
 
 
		   libro.write(fichero);
 
		   fichero.close();
 
 
		   response.setContentType("application/vnd.ms-excel");
 
		    response.setContentLength(this.fichero.size());
 
		    response.setHeader("Content-disposition","attachment; filename=estudiantes.xls" );
 
		    ServletOutputStream out = response.getOutputStream();
 
		    this.fichero.writeTo(out);
 
		    out.flush();
 
		}
		catch (Exception e) 
		{  
			System.out.print("error");
 
		}
 
 
 
 
	}
 
	public void llamandoBuildExcelDocument ( HttpServletRequest request, HttpServletResponse response, Map model) throws Exception
	{   
 
		//creamos el libro
		HSSFWorkbook libro = new HSSFWorkbook ();	
 
 
 
 
 
		buildExcelDocument(model,libro,request, response);
 
	}
 
 
 
 
}

Clase dentro del package de recursos unoauno.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package recursos;
 
 
import java.util.List;
import modelos.Direccion;
import modelos.Estudiante;
 
public interface Unoauno {
 
	public void introducirEstudiante(Estudiante estudiante);
 
	public List<Estudiante> listadoEstudiantes ();
	public List<Direccion> listadoDireccion();
 
}

Clase encargada de la implementación de la interface Unoauno

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package recursos;
 
import modelos.Direccion;
import modelos.Estudiante;
import java.util.List;
import org.springframework.orm.hibernate3.HibernateTemplate;
 
 
public class UnoaunoImpl implements Unoauno
{
	private HibernateTemplate hibernateTemplate;
 
	public HibernateTemplate getHibernateTemplate() {
		return hibernateTemplate;
	}
 
	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}
	@SuppressWarnings("unchecked")
	public List <Estudiante> listadoEstudiantes()
	{
		return (List<Estudiante>) hibernateTemplate.find("from Estudiante");
	}
 
	@SuppressWarnings("unchecked")
	public List <Direccion> listadoDireccion()
	{
	  	return (List<Direccion>) hibernateTemplate.find("from Direccion");
	}
 
	public void introducirEstudiante (Estudiante estudiante)
	{
		hibernateTemplate.saveOrUpdate(estudiante);
	}
 
 
 
}

El objetivo del ejemplo era crear la interconexión entre diferentes tecnologías para llegar a una situación cotidiana a nivel de empresa pero sin pretender ser un estudio exaustivo en la introducción de liberías para excel en java por ello introducimos un enlace a un sitio donde amplian información

Rose India

Se intenta simpre evitar poner cosas que no esten en español pero en este caso por las ventajas que suponen para el lector se pone un enlace a una web en inglés pero hay que decir que es sencillo.

]]> http://www.railsymas.com/2011/10/26/exportando-datos-a-excel-con-spring-framework/feed/ 0 spring framework mvc hibernate uno a uno http://www.railsymas.com/2011/07/25/spring-framework-mvc-hibernate-uno-a-uno/ http://www.railsymas.com/2011/07/25/spring-framework-mvc-hibernate-uno-a-uno/#comments Mon, 25 Jul 2011 18:21:38 +0000 admin http://www.railsymas.com/?p=2421 Siguiendo con los ejemplos desarrollados sobre spring mvc para la getión de bases de datos creamos un ejemplo para una relación del tipo uno a uno

Formulario para la introducción de datos

Resultado de los datos introducidos

En este ejemplo aparecen dos clases implicadas estudiantes y dirección

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package modelos;
 
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Entity;
import javax.persistence.Table;
 
 
@Entity
@Table(name="direccion")
public class Direccion {
 
 
	private String calle;
	private String localidad;
 
 
 
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="direccion_id")
	public Integer getDireccion_id() {
		return direccion_id;
	}
	public void setDireccion_id(Integer direccionId) {
		direccion_id = direccionId;
	}
 
 
	@Column(name="calle",nullable=false,length=50)
	public String getCalle() {
		return calle;
	}
	public void setCalle(String calle) {
		this.calle = calle;
	}
 
	@Column(name="localidad",nullable=false,length=50)
	public String getLocalidad() {
		return localidad;
	}
	public void setLocalidad(String localidad) {
		this.localidad = localidad;
	}
 
 
 
 
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package modelos;
 
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Entity;
import javax.persistence.Table;
 
 
@Entity
@Table(name="direccion")
public class Direccion {
 
	private Integer direccion_id;
	private String calle;
	private String localidad;
 
 
 
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="direccion_id")
	public Integer getDireccion_id() {
		return direccion_id;
	}
	public void setDireccion_id(Integer direccionId) {
		direccion_id = direccionId;
	}
 
 
	@Column(name="calle",nullable=false,length=50)
	public String getCalle() {
		return calle;
	}
	public void setCalle(String calle) {
		this.calle = calle;
	}
 
	@Column(name="localidad",nullable=false,length=50)
	public String getLocalidad() {
		return localidad;
	}
	public void setLocalidad(String localidad) {
		this.localidad = localidad;
	}
 
 
 
 
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package recursos;
 
 
import java.util.List;
import modelos.Direccion;
import modelos.Estudiante;
 
public interface Unoauno {
 
	public void introducirEstudiante(Estudiante estudiante);
 
	public List<Estudiante> listadoEstudiantes ();
	public List<Direccion> listadoDireccion();
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package recursos;
 
import modelos.Direccion;
import modelos.Estudiante;
import java.util.List;
import org.springframework.orm.hibernate3.HibernateTemplate;
 
 
public class UnoaunoImpl implements Unoauno
{
	private HibernateTemplate hibernateTemplate;
 
	public HibernateTemplate getHibernateTemplate() {
		return hibernateTemplate;
	}
 
	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}
	@SuppressWarnings("unchecked")
	public List <Estudiante> listadoEstudiantes()
	{
		return (List<Estudiante>) hibernateTemplate.find("from Estudiante");
	}
 
	@SuppressWarnings("unchecked")
	public List <Direccion> listadoDireccion()
	{
	  	return (List<Direccion>) hibernateTemplate.find("from Direccion");
	}
 
	public void introducirEstudiante (Estudiante estudiante)
	{
		hibernateTemplate.saveOrUpdate(estudiante);
	}
 
 
 
}
]]> http://www.railsymas.com/2011/07/25/spring-framework-mvc-hibernate-uno-a-uno/feed/ 0 Ejemplo Spring framework mvc hibernate http://www.railsymas.com/2011/07/06/ejemplo-spring-framework-mvc-hibernate/ http://www.railsymas.com/2011/07/06/ejemplo-spring-framework-mvc-hibernate/#comments Wed, 06 Jul 2011 21:37:04 +0000 admin http://www.railsymas.com/?p=2376 En anteriores post habíamos creado ejemplos de conexión de bases de datos con spring mvc con jdbc introduciendo dos formas de desarrollo una de ellas permitía el uso de interface para spring reduciendo el tiempo de creación de métodos de acceso a bases de datos.

La utilización de una herramienta orm para la capa de persistencia puede ahorrar muchas líneas de código. Permitiendo concentrarse en los requisitos de la aplicación en lugar de escribir código sql extenso que puede provocar errores

Spring es compatible con varios marcos de trabajo orm entre los cuales se incluyen hibernate, ibatis, ojb, jdo, toplink.

El soporte del marco spring sobre hibernate se encuentra en el paquete org.springframework.orm.hibernate para la version hibernate2. Para la versión 3 de hibernate se encuenta en org.springfremework.orm.hibernate3

El marco spring permite el trabajo con archivos de mapeo xml de hibernate, donde tenemos un fichero hbm.xml y crear un bean de factoria de spring LocalSessionFactoryBean que produce una instancia local de SessionFactory que es la responsable de abrir y cerrar sesiones de hibernate.

La segunda posibilidad que ofrece el marco de spring para el trabajo de hibernate consiste en las anotaciones. El marco spring mediante AnnotationSessionFactoryBean crea un SessionFactory basado en anotaciones de clases de dominio.

Se crea por tanto una serie de clases de dominio anotadas para luego mediante AnnotationSessionBean factory crear una SessionFactory que permite el trabajo apertura, cierre y tratamiento de hibernate

Tenemos la propiedad datasource que corresponde a la referencia de una fuente de datos previamente creada en el archivo de configuración de spring como habíamos visto con jdbc spring, la propiedad annotatedClasses sirve para declarar la lista de clases anotadas. Por último la propieadad hibernateProperties permite declarar la configuración de hibernate donde lo más importante es la daclaración del dialecto a utilizar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

 
    <bean id="conexionFactoria" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="dataSource" ref="datasource"/>
    <property name="annotatedClasses">
       <list>
       <value>modelos.Libros</value>
 
       </list>
    </property>
 
    <property name="hibernateProperties">
      <props>
       <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop> 
       <prop key="hibernate.hbm2ddl.auto">update</prop>
       <prop key="hibernate.show_sql">true</prop>
      </props>
 
    </property> 
 
    </bean>
1
2
3
4
5
6
7
8
9

  <bean id="template" class="org.springframework.orm.hibernate3.HibernateTemplate">
      <property name="sessionFactory" ref="conexionFactoria"/>
    </bean>
 
 
    <bean id="libroDao" class="recursos.LibrosImpl">
      <property name="hibernateTemplate" ref="template"/>
 
    </bean>

Código de la clase bean Libros clase con anotaciones

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package modelos;
 
import javax.persistence.Entity;
import javax.persistence.GenerationType;
import javax.persistence.Table;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
 
@Entity
@Table(name="libros")
public class Libros 
{   
 
	private Long id;
	private String titulo;
	private String autor;
	private String tematica;
 
 
	public Libros()
	{
 
	}
 
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="id")
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
    @Column(name="titulo", nullable=false, length=50)
	public String getTitulo() {
		return titulo;
	}
	public void setTitulo(String titulo) {
		this.titulo = titulo;
	}
	@Column(name="autor", nullable=false, length=50)
	public String getAutor() {
		return autor;
	}
	public void setAutor(String autor) {
		this.autor = autor;
	}
	@Column(name="tematica", nullable=false, length=50)
	public String getTematica() {
		return tematica;
	}
	public void setTematica(String tematica) {
		this.tematica = tematica;
	}
 
 
}

En el ejemplo utilizamos jpa por el hecho de que en los frameworks jee de nueva generación la utilización de jpa es muy importante y así se van asentando los conceptos teóricos.

Jpa es un estándar para hacer mapeo objeto relacional permitiendo hacer el acceso a los datos de la base de datos mediante el uso de objetos que se declaran como persistentes.Jpa facilita el desarrollo de aplicaciones reduciendo el número de instrucciones para el tratamiento de los datos almacenados.

Jpa utiliza anotaciones par indicar que las clases son persistentes y establecer el mapeo entre clases y tablas. En jpa una clase persistente es una entidad, es por tanto una clase cuyas entidades de graban en la base de datos

Se utiliza @Entity para definir una clase como persistente, @Table para definir la tabla de la base de datos. Una entidad tiene una serie de propiedades y esas propiedades son semajentes a una clase de java. Las propiedades son persistentes y asume que existen como campos en la tabla. Si se quiere que una propiedad no sea persistente anteponemos @transient

@Column para especificar nombres, tipos y longitudes de campos de tablas. @Id para identificar la clave

Si hubiesemos optado por el modelo clásico de hibernate tendríamos un fichero xml de la siguiente forma

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping>
    <class name="modelos.Libros" table="libros" catalog="libros_jdbc">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="identity" />
        </id>
        <property name="titulo" type="string">
            <column name="titulo" length="50" not-null="true" />
        </property>
        <property name="autor" type="string">
            <column name="autor" length="50" not-null="true" />
        </property>
        <property name="tematica" type="string">
            <column name="tematica" length="50" not-null="true" />
        </property>
    </class>
</hibernate-mapping>

Tenemos la configuración para la base de datos libros_jdbc al igual que habíamos visto en los ejemplos de jdbctemplate

1
2
3
4
5
6
7
8

 <bean id="datasource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
 
     <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
     <property name="url" value="jdbc:mysql://localhost:3306/libros_jdbc"/>
     <property name="username" value="root"/>
     <property name="password" value="root"/>
 
     </bean>

Clases para la gestión del modelo madiante la implementación de la interface Libros

1
2
3
4
5
6
7
8
9
10
11

package recursos;
 
import modelos.Libros;
import java.util.List;
 
public interface Interfaceslibros {
 
	public void guardarLibro (Libros libro);
	public List<Libros> listadoLibros ();
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package recursos;
 
import java.util.List;
 
import org.springframework.orm.hibernate3.HibernateTemplate;
 
 
import modelos.Libros;
 
 
 
public class LibrosImpl implements  Interfaceslibros
{
 
 
	private HibernateTemplate hibernateTemplate;
 
 
 
	public HibernateTemplate getHibernateTemplate() {
		return hibernateTemplate;
	}
 
	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}
 
 
 
	public void guardarLibro (Libros libro)
	{
 
 
		hibernateTemplate.saveOrUpdate(libro);
	}
 
 
	@SuppressWarnings("unchecked")
	public List<Libros> listadoLibros( )
	{
 
		return (List<Libros>) hibernateTemplate.find("from Libros");
	}
 
 
}

Código del controlador, utilizamos una clase que extiende de multiactioncontroler que habíamos visto en anteriores post formulario multiactioncontroller. Esta clase nos permite guardar libros e insertar libros.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

package controlador;
 
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import modelos.Libros;
import recursos.Interfaceslibros;
 
 
 
public class ControladorHibernateLibros extends MultiActionController
{
	private Interfaceslibros daolibros;
 
 
 
	public void setDaolibros(Interfaceslibros daolibros) {
		this.daolibros = daolibros;
	}
 
 
 
	public ModelAndView guardarLibro (HttpServletRequest request, HttpServletResponse response, Libros libro) throws Exception
	{   
		daolibros.guardarLibro(libro);
 
		ModelAndView vista = new ModelAndView("resultadolibros","listado",daolibros.listadoLibros());
 
 
 
		return vista;
	}
 
 
 
	public ModelAndView insertarLibro (HttpServletRequest request, HttpServletResponse response,Libros libros) throws Exception
	{
	  	ModelAndView vista = new ModelAndView("formulariolibroshibernate");
 
	    vista.getModel().put("libros", new Libros());
 
	    return vista;
	}
 
}

insertamos los datos correspondientes a los libros

Código correspondiente a las páginas jsp formularioslibroshibernate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title><spring:message code="librohibernate.titulo"/></title>
<link type="text/css" rel="stylesheet" href="css/estilo.css"/>
</head>
<body>
 
  <div id="contenedor">
 
   <h2><spring:message code="librohibernate.titulo"/></h2>
 
   <form:form action="formulariolibroshibernate.html" method="post" commandName="libros"> 
 
   <div class="campo">
 
   <spring:message code="hibernate.titulolibro"/>
 
   <br/>
 
   <form:input path="titulo"/>
 
   </div>
 
   <div class="campo">
 
   <spring:message code="hibernate.autorlibro"/>
 
   <br/>
 
   <form:input path="autor"/>
 
   </div>
 
   <div class="campo">
 
   <spring:message code="hibernate.tematicalibro"/>
 
   <br/>
 
   <form:input path="tematica"/>
 
   </div>
 
   <input type="hidden" name="method" value="guardarLibro"/>
 
   <input type="submit" value="enviar" class="boton"/>
 
   </form:form>
 
   <div id="pie">
    <p>www.railsymas.com</p>
   </div>
  </div> 
 
</body>
</html>

configuración de la vista formulariolibroshibernate

1
2
3
4
5

 
    <bean name="/formulariolibroshibernate.html"    class="controlador.ControladorHibernateLibros">
      <property name="methodNameResolver" ref="paramResolver"/>
      <property name="daolibros" ref="libroDao"/>
    </bean>

resultado de la introducción de datos

Código correspondiente a la salida por pantalla de los datos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"     pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<link rel="stylesheet" type="text/css" style="stylesheet" href="css/estilo.css"/>
<title><spring:message code="resultadojdbc.titulo"/></title>
</head>
<body>
 <div id="contenedor">
 
    <h2><spring:message code="resultadojdbc.titulo"/></h2>
    <div id="tabla">
    <table title="listado de libros">
    <tr>
     <th>titulo</th>
     <th>autor</th>
     <th>tematica</th>
    </tr>
    <c:forEach items="${listado}" var="libro">
     <tr>
     <td class="impar"> <c:out value="${libro.titulo}"/> </td>
     <td class="par"><c:out value="${libro.autor}"/> </td> 
     <td class="impar"><c:out value="${libro.tematica}"/></td>
     </tr>
    </c:forEach>
    </table>
    </div>
    <div id="pie">
     <p> www.railsymas.com </p>
    </div>
 </div>
 
</body>
</html>
]]> http://www.railsymas.com/2011/07/06/ejemplo-spring-framework-mvc-hibernate/feed/ 2 Aplicación web flow jdbc spring framework 2º parte http://www.railsymas.com/2011/07/02/aplicacion-web-flow-jdbc-spring-framework-2%c2%ba-parte/ http://www.railsymas.com/2011/07/02/aplicacion-web-flow-jdbc-spring-framework-2%c2%ba-parte/#comments Sat, 02 Jul 2011 19:05:16 +0000 admin http://www.railsymas.com/?p=2336 Siguiendo el ejemplo anterior en el que se declaraban una serie de estados que integraban la aplicación de web flow para el framework spring.

En la primera parte del ejemplo habíamos creado el fichero de configuración con los estados correspondientes al flujo enlace ejemplo-de-aplicacion-para-spring-web-flow

Funcionamiento de la aplicación tenemos una serie de usuarios creados en la base de datos, es tarea de la aplicación reconocer dichos usuarios introducciendo el número de teléfono. Si dicho teléfono introducido en la primera pantalla corresponde con un cliente (usuario de la base de dastos) entonces se pasa directamente a una pantalla con sus datos y puede realizar la compra de unos productos. En caso de no ser reconocido el número de teléfono se le pasa a una pantalla con donde debe registrarse para luego acceder a la de compra una vez registrado

En este ejemplo estamos utilizando el manipulador de mapeo SimpeUrlHandlerMapping, este manipulador ayuda al dispatcherServlet a elegir qué controlador enviar la petición

Permite mapear patrones url directamente a controladores para ellos dentro de la propiedasdes del bean ulMapping declaramos el patrón ul dentro de la clave key y luego el valor de la propiedad sería el nombre del controlador en este caso flowController ya que es el utilizado para web flow pero podemos declarar más como por ejemplo (ejercicios) que es un controlador creado por el programador

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<bean id="urlMapping"
     class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
 
     <property name="mappings">
     <props>
      <prop key="/aplicacion.html">flowController</prop>
      <prop key="/hola.html">flowController</prop>
      <prop key="/ejercicios.html">ejercicios</prop>
 
     </props>
     </property>
 
 
    </bean>

Tenemos tres clases que son las encargadas de gestionar el flujo de la aplicación

recordamos que tenemos un fichero xml de configuración donde vienen los estados declarados

Tabla correspodiente a clientes

Tabla correspodiente a pedidos

Partiendo de los anteriores datos almacenados en las tablas, entramos en la aplicación con el teléfono de pedro

Al ser un usuario reconocido de la base de datos accedemos a la ficha para adquisición de un producto

Mostramos el resultado final

Segundo caso un usuario no existente en la base de datos introduce un número de teléfono

Aparece una pantalla donde tiene que registrase introduciendo su nombre y su número de teléfono de nuevo

Pasamos a la pantalla donde el cliente puede elegir los productos a comprar

Pantalla final con el resultado final de la compra

Código de la clase ClienteAplicacion.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

package actionflows;
 
 
import recursos.Cliente;
import recursos.Producto;
import ClasesBean.Pedido;
import recursos.ConexionCliente;
 
import javax.sql.DataSource;
 
 
import org.springframework.webflow.execution.Action;
import org.springframework.webflow.execution.Event;
import org.springframework.webflow.execution.RequestContext;
 
 
 
public class ClienteAplicacion implements Action {
 
	private DataSource conexion;
    private ConexionCliente clienteBases;
 
 
    public  ClienteAplicacion ()
    {
    	clienteBases = new  ConexionCliente();
 
    }
 
 
	public DataSource getConexion() {
		return conexion;
 
	}
 
 
 
 
	public void setConexion(DataSource conexion) {
		this.conexion = conexion;
		this.clienteBases.setConexion(this.conexion);
 
	}
 
 
 
 
	public Event execute(RequestContext context) throws Exception {
		// TODO Auto-generated method stub
 
		Event evento;
	    Pedido pedido;
 
 
		String telefono = context.getRequestParameters().get("telefono");
		Cliente cliente = this.clienteBases.buscarCliente(telefono);
 
 
		//insertamos el cliente al pedido
 
		if (cliente !=null)
		{
 
		    pedido = (Pedido) context.getFlowScope().get("pedido");
 
		    pedido.setCliente(cliente);
 
			evento =	new Event(this,"encontrado");
		}
		else
		{
			evento = new Event (this,"vacio");
		}
 
		return evento;
 
	}
 
 
 
 
 
}

Clase GestionPedido

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

package actionflows;
 
 
import recursos.Producto;
import ClasesBean.Pedido;
import recursos.ConexionCliente;
 
import javax.sql.DataSource;
 
 
import org.springframework.webflow.execution.Action;
import org.springframework.webflow.execution.Event;
import org.springframework.webflow.execution.RequestContext;
 
 
 
public class GestionPedido implements Action
{
	private DataSource conexion;
	private ConexionCliente clienteBases;
 
 
    public  GestionPedido ()
    {
    	clienteBases = new  ConexionCliente();
 
    }
 
 
	public DataSource getConexion() {
		return conexion;
 
	}
 
 
	 public void setConexion(DataSource conexion) {
			this.conexion = conexion;
			this.clienteBases.setConexion(this.conexion);
	  }
 
 
	private float CalculoTotal (int unidades , String nombre,Producto producto)
	{
		float total = 0;
 
		if (nombre.equals("telefono"))
		{
			producto.setPrecio(120);
			total = unidades * 120;
		}
		if (nombre.equals("televisor"))
		{
			producto.setPrecio(200);
			total = unidades * 200;
		}
		if (nombre.equals("frigorifico"))
		{  
			producto.setPrecio(450);
			total = unidades * 450;
		}
 
		return total;
	}
 
 
    public Event execute(RequestContext context) throws Exception
    {
 
 
	    Pedido pedido;
 
		pedido = (Pedido) context.getFlowScope().get("pedido");
 
 
		Producto  producto = (Producto) pedido.getProducto();
 
 
		pedido.setImporte( this.CalculoTotal(producto.getUnidades(),producto.getNombre(),producto));
 
 
		int posicion =this.clienteBases.encontrarCliente(pedido.getCliente().getTelefono());
 
		pedido.getCliente().setId(posicion);
 
		this.clienteBases.insertarPedido(pedido);
 
 
		return new Event(this,"satisfactorio");
 
    }
}

Clase RegistroCliente.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

package actionflows;
 
import org.springframework.webflow.execution.Action;
import org.springframework.webflow.execution.Event;
import org.springframework.webflow.execution.RequestContext;
import javax.sql.DataSource;
import recursos.ConexionCliente;
import recursos.Cliente;
import ClasesBean.Pedido;
 
 
public class RegistroCliente implements Action 
{  
 
  private DataSource conexion;
  private ConexionCliente clienteBases;
 
 
  public RegistroCliente ()
  {
	  clienteBases = new  ConexionCliente();
  }
 
 
  public DataSource getConexion() {
	return conexion;
  }
 
 
  public void setConexion(DataSource conexion) {
	this.conexion = conexion;
	this.clienteBases.setConexion(this.conexion);
  }
 
  public Event execute(RequestContext context) throws Exception
  {
	   Event evento;
 
 
 
	  Pedido pedido = (Pedido) context.getFlowScope().get("pedido");
 
	  Cliente cliente = pedido.getCliente();
 
 
	  this.clienteBases.insertarCliente(cliente);
 
 
 
	  evento =  new Event (this,"satisfactorio");
 
 
 
	   return evento;
   }
 }

Código correspondiente a las clases de recursos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package ClasesBean;
 
import recursos.Cliente;
import recursos.Producto;
 
import java.io.Serializable;
 
public class Pedido implements Serializable
{
 
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private Cliente cliente;
	private Producto producto;
	private float importe;
 
 
 
	public float getImporte() {
		return importe;
	}
 
 
	public void setImporte(float importe) {
		this.importe = importe;
	}
 
 
	public Pedido()
	{
		this.cliente = new Cliente();
	    this.producto = new Producto();
 
	}
 
 
	public Producto getProducto() {
		return producto;
	}
 
 
	public void setProducto(Producto producto) {
		this.producto = producto;
	}
 
 
	public Cliente getCliente() {
		return cliente;
	}
	public void setCliente(Cliente cliente) {
		this.cliente = cliente;
	}
 
 
 
 
}

Código de las clases de recursos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package recursos;
 
import java.io.Serializable;
 
public class Cliente implements Serializable {
 
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String nombre;
	private String telefono;
	private int id;
 
 
 
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getNombre() {
		return nombre;
	}
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	public String getTelefono() {
		return telefono;
	}
	public void setTelefono(String telefono) {
		this.telefono = telefono;
	}
 
 
 
}

Clase ConexionCliente.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

package recursos;
 
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
 
import recursos.Cliente;
import ClasesBean.Pedido;
 
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
 
public class ConexionCliente  {
 
 
	private DataSource conexion;
	private List listado;
	private Cliente cliente = null;
 
	public DataSource getConexion() {
		return conexion;
	}
 
	public void setConexion(DataSource conexion) {
		this.conexion = conexion;
	}
 
    public Cliente buscarCliente( String telefono)
    {
 
    	JdbcTemplate jdbctemplate = new JdbcTemplate(this.conexion);
 
    	String consulta = "select * from cliente where telefono = ?;";
 
    	System.out.println(telefono);
 
 
	    listado =  jdbctemplate.query(consulta,new Object [] {telefono}, new RowMapper () 
	    {
    	public Object mapRow (ResultSet resultado, int filas) throws  SQLException
    	{
    		Cliente cliente = new Cliente();
 
    	    cliente.setId(resultado.getInt("id"));
    		cliente.setNombre(resultado.getString("nombre"));
    	    cliente.setTelefono(resultado.getString("telefono"));
 
 
    	    return  cliente;
    	}
 
	    }
	    );
 
 
	    if (listado.isEmpty())
	    {
	    	  System.out.print("esta vacio");
	    }
	    else
	    {
	      this.cliente = (Cliente) listado.get(0);
	    }
 
 
	    return this.cliente;
 
 
    }
 
 
 
    public void insertarCliente (Cliente cliente)
    {
    	JdbcTemplate jdbctemplate = new JdbcTemplate (this.conexion);
 
    	String consulta = "insert into cliente (id,nombre,telefono) values (null,?,?);";
 
    	Object[] objeto  = new Object []  {cliente.getNombre(),cliente.getTelefono()}; 
 
    	jdbctemplate.update(consulta, objeto);
    }
 
 
    public void insertarPedido (Pedido pedido)
    {
 
    	JdbcTemplate jdbctemplate = new JdbcTemplate (this.conexion);
 
    	String consulta = "insert into pedidos (id,cliente_id,producto,unidades,gasto) values (null,?,?,?,?);";
 
 
 
 
 
    	Object[] objeto = new Object [] {pedido.getCliente().getId(),pedido.getProducto().getNombre(),pedido.getProducto().getUnidades(),pedido.getImporte()};
 
    	jdbctemplate.update(consulta,objeto);
    }
 
 
    public int encontrarCliente (String telefono)
    {
 
 
    	 JdbcTemplate jdbctemplate = new JdbcTemplate (this.conexion);
 
    	 String consulta = "select id from cliente where telefono ="+telefono;
 
         int resultado =jdbctemplate.queryForInt(consulta);
 
         return resultado;
 
    }
 
 
 
}

Declaración de los bean en el fichero de configuración dispatcher-servlet.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

 
 <bean id="datasource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
 
     <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
     <property name="url" value="jdbc:mysql://localhost:3306/libros_jdbc"/>
     <property name="username" value="root"/>
     <property name="password" value="root"/>
 
     </bean>
 
 
 <bean id="clienteAplicacion"
 
    class="actionflows.ClienteAplicacion">
 
    <property name="conexion" ref="datasource" />
 
    </bean>
 
 
    <bean id="RegistroCliente" class="actionflows.RegistroCliente">
 
    <property name="conexion" ref="datasource"/>
 
    </bean>
 
 
	<bean id="GestionPedido" class="actionflows.GestionPedido">
 
	<property name="conexion" ref="datasource"/>
 
	</bean>

Código de las jsp implicadas en el ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
 
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>formulario cliente</title>
<link rel="stylesheet" href="css/estilo.css" type="text/css"/>
 
</head>
<body>
<div id="contenedor">
 
<h2>formulario Aplicaci&oacute;n Web flow</h2>
 
<form:form method="post" action="aplicacion.html?">
 
<input type="hidden" name="_flowExecutionKey" value="${flowExecutionKey}"/>
 
 
<div class="campo">
 
<label>Telefono:</label>
 
<br/>
 
<input type="text" name="telefono"/>
 
<br/>
 
<input type="submit" name="_eventId_submit" value="enviar" class="boton"/>
 
</div>
 
</form:form>
 
 
 
<div id="pie">
 
 <p>www.railsymas.com</p>
</div>
 
</div>
 
</body>
</html>

formularionuevocliente.jsp formulario encargado de pedir los datos de nombre y de número de teléfono para insertar un nuevo cliente en la base de datos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Registro cliente</title>
<link rel="stylesheet" type="text/css" href="css/estilo.css"/>
</head>
<body>
 
<div id="contenedor">
 
 
<form:form method="post" action="aplicacion.html" commandName="cliente">
 
<input type="hidden" name="_flowExecutionKey" value="${flowExecutionKey}"/>
 
<div class="campo">
  <label>Introduce el nombre:</label>
  <br/>
  <form:input path="nombre"/>
 
</div>
<div class="campo">
  <label>Introduce el telefono:</label>
  <br/>
  <form:input path="telefono"/>
</div>
 
<input type="submit" value="enviar" class="boton" name="_eventId_submit"/>
 
&nbsp;
 
<input type="submit" value="cancelar" class="boton" name="_eventId_cancel"/>
 
</form:form>
 
 
 
 
<div id="pie">
 <p>www.railsymas.com</p>
</div>
</div>
 
 
 
</body>
</html>

Código de formulariopedido.jsp, es la encargada de mostrar los datos de productos para ser seleccionados

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>formulario pedidos aplicacion flow</title>
<link rel="stylesheet" href="css/estilo.css" type="text/css"/>
</head>
<body>
<div id="contenedor">
 
<h2> Formulario de pedido</h2>
 
 
 
<form:form method="post" action="aplicacion.html" commandName="producto">
 
 <label>Cliente : </label> ${pedido.cliente.nombre} 
 
 <br/>
 
 
 <div class="campo">
 
 <label>Lista de precios</label>
 
 <table title="lista de precios">
 <tr><th>Producto</th><th>Precio</th></tr>
 <tr><td class="impar">televisor</td><td class="par">200 Euros</td></tr>
 <tr><td class="impar">telefono</td><td class="par">120 Euros</td></tr>
 <tr><td class="impar">frigorífico</td><td class="par">450 Euros</td></tr>
 
 
 </table>
 
 </div>
 
 <div class="campo">
 
 <label> Nombre producto:</label>
 
  <br/>
 
  <form:select path="nombre">
 
   <form:option value="televisor" label="televisor"/>
 
   <form:option value="telefono" label="teléfono"/>
 
   <form:option value="frigorifico" label="frigorífico"/>
 
  </form:select>
 
 </div> 
 
 
 <div class="campo">
 
 <label> Numero de unidades:</label>
 
 <br/>
 
 <form:input path="unidades" size="3"/>
 
 
 </div>
 
 <input type="hidden" name="_flowExecutionKey" value="${flowExecutionKey}"/>
 <input type="submit" value="enviar" class="boton" name="_eventId_submit"></input>
 
</form:form>
 
<div id="pie">
<p>www.raislymas.com</p>
</div>
</div>
 
</body>
</html>
]]> http://www.railsymas.com/2011/07/02/aplicacion-web-flow-jdbc-spring-framework-2%c2%ba-parte/feed/ 0 Ejemplo de aplicación para spring web flow http://www.railsymas.com/2011/04/19/ejemplo-de-aplicacion-para-spring-web-flow/ http://www.railsymas.com/2011/04/19/ejemplo-de-aplicacion-para-spring-web-flow/#comments Tue, 19 Apr 2011 17:25:55 +0000 admin http://www.railsymas.com/?p=2037 Habíamos visto en anteriores post el desarrollo de un un ejemplo de aplicación básica de spring web flow en el que se sentaban las bases sobre esta tecnología, (algo obsoleta desde un punto de vista tecnológico).

En este ejemplo se profundiza un poco más además de aprovechar la conexión de base de datos de spring mvc para integrarla en un ejemplo completo donde se muestran diferentes estados por donde transita la aplicación y establecemos una persistencia de los datos introducidos en los formularios.

Enlazando con el contenido puesto sobre web flow en anteriores post ejemplo simple de web flow spring framework

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

<?xml version="1.0" encoding="UTF-8"?>
<flow 
  xmlns="http://www.springframework.org/schema/webflow"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/webflow
  http://www.springframework.org/schema/webflow/spring-webflow-1.0.xsd">
 
  <var name="pedido"
   class="ClasesBean.Pedido"
   scope="flow"/>
 
 
 
  <start-state idref="inicio"/>
 
 
  <view-state id="inicio"
 
  view="formulariocliente">
 
  <transition on="submit" to="verificarcliente"/>
 
 
  </view-state>  
 
  <action-state id="verificarcliente">
 
  <action bean="clienteAplicacion"/>
 
  <transition on="encontrado" to="pedido"/>
 
  <transition on="vacio" to="nuevocliente"/>
 
 
  </action-state>
 
  <view-state id="nuevocliente" view="formularionuevocliente">
 
  <render-actions>
 
  <action bean="clienteFormAction" method="setupForm"/>
 
  </render-actions>
 
  <transition on="submit" to="registrarcliente">
 
  <action bean="clienteFormAction" method="bind"/>
 
  <evaluate-action expression="flowScope.pedido.setCliente(requestScope.cliente)"/>
 
  </transition>
 
  </view-state>
 
  <action-state id="registrarcliente">
 
  <action bean="RegistroCliente"/>
 
 
 
  <transition on="satisfactorio"  to="pedido"/>  
 
  </action-state>
 
 
  <view-state id="pedido" view="formulariopedido">
 
  <render-actions>
   <action bean="productoFormAction" method="setupForm"/>
  </render-actions>
 
 <transition  on="submit" to="gestionarpedido">
 
  <action bean="productoFormAction" method="bind"/>
 
 <evaluate-action expression="flowScope.pedido.setProducto(requestScope.producto)"></evaluate-action>
 
  </transition>
 
  </view-state>
 
 
  <action-state id="gestionarpedido">
 
  <action bean="GestionPedido"/>
 
  <transition on="satisfactorio" to="datospedido"/>
 
  </action-state>
 
 
  <view-state id="datospedido" view="datospedido">
 
  <transition on="continue" to="fin"/>
  </view-state> 
 
 
  <end-state id="fin" view="flowRedirect:aplicacion-flow"/>  
 
 
 
</flow>
]]> http://www.railsymas.com/2011/04/19/ejemplo-de-aplicacion-para-spring-web-flow/feed/ 0 spring mvc jdbc ejemplo http://www.railsymas.com/2011/04/14/spring-mvc-jdbc-ejemplo/ http://www.railsymas.com/2011/04/14/spring-mvc-jdbc-ejemplo/#comments Thu, 14 Apr 2011 15:47:39 +0000 admin http://www.railsymas.com/?p=2178 Evidentemente como todo lenguaje o framework el acceso a bases de datos es un factor fundamental para el desarrollo
de un sitio web y como sistema de desarrollo spring no sería menos.

Vemos en el siguiente ejemplo características propias del framework spring en el acceso mediante jdbc que permiten un tratamiento rápido de la información mediante una abstraccíon propia del framework que permite hacer las cosas un poco más rapido que otros frameworks como struts.

Una característica que en los nuevos framewroks rad (rapid application development) suponen una constante vital y que veremos cuando empecemos dichos desarrollos

Como todos los ejemplos estamos utlizando una base de datos común tanto j2ee jdbc, struts y jsf en spring utlizamos también la misma para facilitar el entendimiento.

Enlace al post jdbc j2ee conexion-a-bases-de-datos-j2ee-jdbc

Clase bean asociada

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package ClasesBean;
 
public class DatosLibro {
 
	private String tematica;
	private String autor;
	private String titulo;
	public String getTematica() {
		return tematica;
	}
	public void setTematica(String tematica) {
		this.tematica = tematica;
	}
	public String getAutor() {
		return autor;
	}
	public void setAutor(String autor) {
		this.autor = autor;
	}
	public String getTitulo() {
		return titulo;
	}
	public void setTitulo(String titulo) {
		this.titulo = titulo;
	}
 
 
 
 
}

Configuración dentro del fichero dispatcher-servlet.xml, declaramos la clase controladora e indicamos que tenemos un formulario llamado (formulariolibro) y mostramos los resultados mediante el formulario (resultadolibros) y la referencia al bean datasources . Declaramos un bean datasource con el tipo de driver, el nombre de la base de datos y los valores del usuario para trabajar con la base de datos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 
<bean id="datasource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
 
     <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
     <property name="url" value="jdbc:mysql://localhost:3306/libros_jdbc"/>
     <property name="username" value="root"/>
     <property name="password" value="root"/>
 
     </bean>
 
 <bean name="/formulariolibros.html" class="controlador.ControladorJdbc">
     <property name="formView" value="formulariolibros"/>
     <property name="successView" value="resultadolibros"/>
     <property name="datasource" ref="datasource"/>
     </bean>

controlador jdbc

En el ejemplo de código del controlador se pueden ver dos formas de trabajar en spring con jdbc, la primera es la forma habitual similar a la de j2ee o struts ( esta forma viene representada por el código del método conexionLibros, donde para poder insertar, eliminar y editar datos tenemos que malgastar tiempo en tediosas líneas de código para capturar las excepciones derivadas del tratamiento de datos con jdbc.

Los otros dos métodos se corresponden a una característica de spring que nos permite en el tratamiento de jdbc de una forma más rápida y cómoda.

Las plantillas jdbc de spring nos permiten limpiar el código y liberar el peso de la gestión de recursos y manejo de excepciones
Nos permite por lo tanto escribir el código necesario para mover los datos. Spring nos permite abstraer el código estándar de jdbc, existen tres tipos de plantillas

JdbcTemplate nos crea la plantilla básica de acceso a jdbc y consultas sencillas indexadas
NamedParameterJdbcTemplate nos crea la plantilla de acceso a jdbc, permite hacer consultas con valores unidos a parámetros nombrados en sql
SimpleJdbcTemplate gestión de listas de parámetros variables simplificando la plantila jdbc

Para que jdbctemplate pueda funcionar necesitamos un datasource para conectar nuestra aplicación a la base de datos, se utiliza en los métodos insertarJdbcTemplate y listadoJdbcTemplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

package controlador;
 
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
 
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.ResultSet;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.SimpleFormController;
 
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import java.util.List;
 
 
 
import ClasesBean.DatosLibro;
 
public class ControladorJdbc extends SimpleFormController {
 
	private DataSource datasource;
	private List listado;
 
	public ControladorJdbc ( )
	{
		this.setCommandClass(DatosLibro.class);
		this.setCommandName("DatosLibro");
	}
 
	private void insertarJdbcTemplate (DatosLibro datoslibro )
	{
		JdbcTemplate jdbctemplate = new JdbcTemplate(this.datasource);
 
		String consulta = "insert into libros (id,titulo,autor,tematica) values (null,?,?,?);";
 
		Object[] objeto = new Object [] {datoslibro.getTitulo(),datoslibro.getAutor(),datoslibro.getTematica()};
 
		jdbctemplate.update(consulta, objeto);
 
	}
 
	private List listadoJdbcTemplate ( )
	{
		String consulta = "select titulo , autor, tematica from libros;";
 
	    JdbcTemplate jdbctemplate = new JdbcTemplate(this.datasource);
 
	    listado =  jdbctemplate.query(consulta, new RowMapper ()
	    {
	    	public Object mapRow (ResultSet resultado, int filas) throws  SQLException
	    	{
	    		DatosLibro libro = new DatosLibro();
 
	    	    libro.setTitulo(resultado.getString("titulo"));
	    	    libro.setAutor(resultado.getString("autor"));
	    	    libro.setTematica(resultado.getString("tematica"));
 
	    	    return libro;
	    	}
	    }
 
	    );
 
	    return listado;		
 
 
 
 
	}
 
 
	private void conexionLibros (DatosLibro datoslibro)
	{
		Connection conexion = null;
		String consulta = "insert into libros (id,titulo,autor,tematica) values (?,?,?,?);";
		PreparedStatement preparedstatement = null;
		try
		{
			conexion = this.datasource.getConnection();
 
			 preparedstatement = conexion.prepareStatement(consulta);
 
			preparedstatement.setInt(1,0);
			preparedstatement.setString(2,datoslibro.getTitulo());
			preparedstatement.setString(3, datoslibro.getAutor());
			preparedstatement.setString(4, datoslibro.getTematica());
 
			preparedstatement.execute();
 
			System.out.println("conexion");
 
		}
		catch (SQLException e)
		{
			System.out.println(e.getMessage());
		}
		finally
		{
			try
			{
			conexion.close();
			preparedstatement.close();
			}
			catch (SQLException e)
			{
				System.out.println(e.getMessage());
			}
		}
	}
 
	public ModelAndView onSubmit (Object command) throws Exception
	{   
 
		DatosLibro datoslibro = (DatosLibro) command;
		//this.conexionLibros(datoslibro);
		this.insertarJdbcTemplate(datoslibro);
		List listado = this.listadoJdbcTemplate();
		return new ModelAndView ("resultadolibros","listado",listado);
	}
 
	public void setDatasource(DataSource datasource) {
		this.datasource = datasource;
	}
 
 
}

Se introducen los datos 6 de título, autor y temática

código de las páginas jsp

Formulariolibros.jsp primera imagen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"  pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title><spring:message code="libros.titulo"/></title>
<link rel="stylesheet" type="text/css" href="css/estilo.css"/>
</head>
<body>
   <div id="contenedor">
   <h2><spring:message code="libros.titulo"/></h2>
   <form:form method="post" commandName="DatosLibro">
   <div class="campo">
     <spring:message code="libro.titulo"/>
     <br/>
     <form:input path="titulo"/>
   </div>
 
   <div class="campo">
     <spring:message code="libro.autor"/>
     <br/>
     <form:input path="autor"/>
   </div>
 
   <div class="campo">
    <spring:message code="libro.tematica"/>
    <br/>
    <form:input path="tematica"/>
   </div>
 
   <input type="submit" value="enviar" class="boton"/> 
 
   </form:form>
    <div id="pie">
    <p>www.railsymas.com</p>
   </div>
   </div>
</body>
</html>

Resultadolibros.jsp sengunda imagen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"     pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<link rel="stylesheet" type="text/css" style="stylesheet" href="css/estilo.css"/>
<title><spring:message code="resultadojdbc.titulo"/></title>
</head>
<body>
 <div id="contenedor">
 
    <h2><spring:message code="resultadojdbc.titulo"/></h2>
    <div id="tabla">
    <table title="listado de libros">
    <tr>
     <th>titulo</th>
     <th>autor</th>
     <th>tematica</th>
    </tr>
    <c:forEach items="${listado}" var="libro">
     <tr>
     <td class="impar"> <c:out value="${libro.titulo}"/> </td>
     <td class="par"><c:out value="${libro.autor}"/> </td> 
     <td class="impar"><c:out value="${libro.tematica}"/></td>
     </tr>
    </c:forEach>
    </table>
    </div>
    <div id="pie">
     <p> www.railsymas.com </p>
    </div>
 </div>
 
</body>
</html>
sprinjdbc1 springjdbc2 ]]> http://www.railsymas.com/2011/04/14/spring-mvc-jdbc-ejemplo/feed/ 0 Ejemplo de spring mvc tiles 2.0 http://www.railsymas.com/2011/04/09/ejemplo-de-spring-mvc-tiles-2-0/ http://www.railsymas.com/2011/04/09/ejemplo-de-spring-mvc-tiles-2-0/#comments Sat, 09 Apr 2011 22:21:38 +0000 admin http://www.railsymas.com/?p=2154 Spring mvc al igual que struts permite el uso y creación de plantillas para la creación de layouts

Como toda plantilla la finalidad principal es la de tener un esquema visual similar en todas las distintas secciones del sitio web, este tipo de esquema visuales suele ser rentable en sitios con unas cuantas secciones ya que el tiempo de desarrollo se recorta bastante.

Hoy en día con la entrada de los cms y framework de última generación todos con independencia del leguaje con el que se desarrollan suelen tener un buen soporte para plantillas posibilitado y abaratando los costes a la hora de renovar o desarrollar un nuevo site.

Por lo tanto frameworks obsoletos como struts, spring y jsf dentro de la aplicaciones j2ee permiten el desarrollo de layouts pero de una forma más costosa en el código.

sprintile1 springtile2 sprinttiles3 estructuratiles

La css es la misma que para el caso de struts tiles para la categoría de struts, tenemos un esqueleto general de la plantilla
es un fichero denominado plantilla.jsp con el siguiente código, tenemos cuatro bloques cabecera, menú, cuerpo y pie donde insertamos cada uno de los fragmentos que luego son cubiertos las páginas correspondientes.

En esencia es exacmente igual que en struts y muchos de los conceptos sirven para spring
struts-tiles

Código de plantilla.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"  pageEncoding="ISO-8859-1"%>
<%@taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<link rel="stylesheet" type="text/css" href="css/estiloplantilla.css"/>
<title><tiles:getAsString name="titulo"/></title>
</head>
<body>
  <div id="contenedor">
    <div id="cabecera">
      <tiles:insertAttribute name="cabecera"/>
    </div>
    <div id="contenido">
 
      <div id="menu">
       <tiles:insertAttribute name="menu"/>
      </div>
 
      <div id="cuerpo">
       <tiles:insertAttribute name="cuerpo"/>
      </div>
 
    </div>
    <div id="pie">
     <tiles:insertAttribute name="pie"/>
    </div>
 
  </div>
</body>
</html>

Necesitamos entonces el código de las otras tres páginas que correponden a los bloques de pie, menu y cuerpo así como las páginas correspondientes a los objetos y los personajes

cabecera.jsp

1
2
3
4
5

<%@taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>
<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<div id="imagencabecera">    	
       <img src="<spring:message code='imagen.cabecera'/>" title="<spring:message code='imagen.cabecera.alt'/>"/>     
</div>

menu.jsp

Nos permite seleccionar los enlaces correspondientes para acceder a la sección de objetos y personajes

1
2
3
4
5

<%@ taglib uri="http://java.sun.com/jsp/jstl/core"  prefix="c" %>
<ul id="menu_lateral">
 <li><a href="<c:url value="/objetos.html"/>"> objetos</a></li>
 <li><a href="<c:url value="/personajes.html"/>"> personajes</a></li>
</ul>

cuerpo de la aplicación será el bloque que cambiará de la vista de inicio a la vista de objetos y personajes

cuerpo.jsp

1
2
3
4
5
6
7
8

<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
 <p>
   Ejemplo de desarrollo con spring-tiles 2.0, tenemos una plantilla base y diferentes definiciones de 
   p&aacute;gina en un fichero xml llamado tiles-def.xml
  </p>
  <div id="contenido">
  <img src="<spring:message code="imagen.lapices"/>" alt="<spring:message code="imagen.lapices.alt"/>"/>
  </div>

pie de la aplicación pie.jsp

1
2
3
4
5

<p id="pizquierda">
 <a  href="ejercicios.html">Ejercicios </a>|<a href="plantilla.html"> Plantilla </a>| <a href="objetos.html"> Objetos</a> |<a href="personajes.html"> Personajes </a>
</p>
 
<p id="pderecha"> @CopyRight railsymas.com </p>

una vez tenemos el esquema básico las vistas pueden variar en función de las acciones de los usuarios al seleccionar la vista de objetos o de personajes y desde cualquiera de ellas volver a la de plantilla

Código de la página personajes, simplemente estamos modificando un bloque de la plantilla el correspondiente al cuerpo

1
2
3
4
5
6
7

<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
 
 
 <div id="imagenes">
 <img src="<spring:message code="imagen.personaje1"/>" alt="<spring:message code="imagen.personaje1.alt"/>"/>
 <img src="<spring:message code="imagen.personaje2"/>" alt="<spring:message code="imagen.personaje2.alt"/>"/>
 </div>

Código de la página personajes, simplemente estamos modificando un bloque de la plantilla el correspondiente al cuerpo

1
2
3
4
5
6

<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
 
 <div id="imagenes">
 <img src="<spring:message code="imagen.objeto1"/>" alt="<spring:message code="imagen.objeto1.alt"/>"/>
 <img src="<spring:message code="imagen.objeto2"/>" alt="<spring:message code="imagen.objeto2.alt"/>"/>
 </div>

Necesitamos crear un fichero de configuracion tiles-def.xml donde declaramos la estructura de las plantillas. Siguiendo el ejemplo de struts tiles las explicaciones son las mismas como resumen se crea un esqueleto base llamado plantilla del cual extienden objetos y personajes sobreescribiendo el cuerpo (al igual que la herencia de objetos)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

<?xml version="1.0" encoding="UTF-8"?>
 
<!DOCTYPE tiles-definitions PUBLIC
       "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
       "http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
 
 
<tiles-definitions>
 
    <definition name="${YOUR_DEFINITION_HERE}">
    </definition>
 
    <definition name="plantilla" template="WEB-INF/pages/tiles/plantilla.jsp">
     <put-attribute name="titulo" value="Plantillas Spring" type="string"/>
     <put-attribute name="cabecera"  value="/WEB-INF/pages/tiles/cabecera.jsp"/>
     <put-attribute name="menu"  value="/WEB-INF/pages/tiles/menu.jsp"/>
     <put-attribute name="cuerpo" value="/WEB-INF/pages/tiles/cuerpo.jsp"/>
     <put-attribute name="pie" value="/WEB-INF/pages/tiles/pie.jsp"/>
    </definition>
 
    <definition name="objetos" extends="plantilla">
     <put-attribute name="titulo" value="Plantilla Spring Objetos" type="string"/>
     <put-attribute name="cuerpo" value="/WEB-INF/pages/tiles/objetos.jsp"/>
    </definition>
 
    <definition name="personajes" extends="plantilla">
     <put-attribute name="titulo" value="Plantilla Spring Personajes" type="string"/>
     <put-attribute name="cuerpo" value="/WEB-INF/pages/tiles/personajes.jsp"/>
    </definition>
 
</tiles-definitions>

Dentro del archivo de configuración de spring en según el ejemplo dispatcher-sevlet,xml.

Para integrar tiles en spring mvc hay que decirle a tiles que abra el archivo de configuración de tiles para poner a disposición de la vistas al declarar una instacia TilesConfigurer. Tenemos una propiedad definitions donde se declara la lista de archivos de definición.(tiles-def.xml)

Por último es necesario configurar un resolutor de vista específico para tiles para que el usuario una vez elegida una pantalla pueda ver el resultado. Cambiamos InternalViewResolver por ResourceBundleViewResolver, con internal resolvían las vistas formadas por y prefijo nombre de vista y sufijo pero con Resource las url de las vistas se resuelven en un archivo de propiedades otra más que nos ofrece spring

para ello se crean las clases correspondientes a las vistas de los beans desde el archivo indicado por el valor basename
en este caso views por lo que entonces tenemos un fichero de propiedades views.properties si el valor fuese vistas entonces sería vistas.properties

1
2
3
4
5
6
7
8
9
10
11

personajes.(class) = org.springframework.web.servlet.view.tiles2.TilesView
personajes.url = personajes
 
objetos.(class) = org.springframework.web.servlet.view.tiles2.TilesView
objetos.url = objetos
 
plantilla.(class) = org.springframework.web.servlet.view.tiles2.TilesView
plantilla.url = plantilla
 
ejercicios.(class) = org.springframework.web.servlet.view.JstlView
ejercicios.url=/WEB-INF/pages/ejercicios.jsp

Y dentro del package Plantillas y para personas otra clase igual y para objetos otra clase igual

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package Plantillas;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
@Controller
 
public class Plantilla {
 
 
 
		@RequestMapping("/plantilla.html")
		public String redirect()
		{
			return "plantilla";
		}
 
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 
 
  <context:component-scan base-package="Plantillas" />   
 
    <bean id="viewTilesResolver" class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
      <property name="basename" value="views"/>
 
    </bean>    
    <bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
      <property name="definitions">
      <list>
         <value>/WEB-INF/tiles-def.xml</value>
      </list>
      </property>
    </bean>

ejemplo de tiles dinamicas dynamic-tiles-spring-mvc-module.htm

]]> http://www.railsymas.com/2011/04/09/ejemplo-de-spring-mvc-tiles-2-0/feed/ 0