rails y más cosas » spring http://www.railsymas.com Nuevas Tecnologías Fri, 30 Jul 2010 22:45:13 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Simple web mvc spring http://www.railsymas.com/2010/07/07/simple-web-mcv-spring/ http://www.railsymas.com/2010/07/07/simple-web-mcv-spring/#comments Wed, 07 Jul 2010 18:23:23 +0000 admin http://www.railsymas.com/?p=1780 Ejemplo en el que vamos a ver algunos detalles sobre el manejo de peticiones además de el tratamiento de los datos bean para recuperarlos desde los controladores y mostrar los valores en la vista de las jsp

Código de la página index.jsp

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

 
<%@ page language="java" contentType="text/html;
 
charset=UTF-8" pageEncoding="UTF-8"%>
 
<!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>P&amp;aacute;gina de inicio</title>
</head>
 
<body>
<jsp:forward page="holamundo.html"/>
</body>
</html>

Código de la página bienvenida.jsp

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

     <%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
     <!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>bienvenida</title>
     </head>
     <body>
     <div id="contenedor">
      ${mensajebienvenida}
      <div id="pie">
      <p>www.railsymas.com</p>
      </div>
      </div>
       </body>
 
      </html>

Configuración necesaria para la visualización de las páginas jsp, se añade un prefijo y un sufijo la llamada para nombrebean.html y lo transforma en la correspondiente página jsp, se devuelve el valor holmundo de la propiedad mensaje

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

 
      <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver" >
 
      <property name="prefix">
 
      <value>/WEB-INF/pages/</value>
 
      </property>
 
      <property name="suffix">
 
      <value>.jsp</value>
 
      </property>
 
      </bean> 
 
      <bean name="/bienvenida.html" class="controlador.Controlador">
      <property name="mensaje" value="Holamundo"/>
      </bean>

Código del controlador

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

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

Creamos el fichero web.xml donde declaramos el servlet Dispatcher, indicamos además que todas las peticiones *.html sean tratadas por este servlet

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

<servlet>
 
<servlet-name>dispatcher</servlet-name>
 
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
 
 
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>

]]> http://www.railsymas.com/2010/07/07/simple-web-mcv-spring/feed/ 0 Paso de referencias al bean http://www.railsymas.com/2010/07/07/paso-de-referencias-al-bean/ http://www.railsymas.com/2010/07/07/paso-de-referencias-al-bean/#comments Wed, 07 Jul 2010 13:59:57 +0000 admin http://www.railsymas.com/?p=1775 A la hora de declarar beans con spring podemos establecer una jerarquía de beans para lo cual necesitamos

pasar en los atributos de las declaraciones las referencias a otros bean

Interface actividades

1
2
3
4
5
6
7

package tercerejemplo;
 
public interface Actividades {
 
	public abstract void actividad();
 
}

Clase Caminar

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

package tercerejemplo;
 
 
public class Caminar implements Actividades 
{
	private String mensaje;
 
	public Caminar(String mensaje)
	{
		this.mensaje = mensaje;
	}
 
	public void actividad ()
	{
		System.out.println(mensaje);
	}
 
 
}

Clase Hablar

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

package tercerejemplo;
 
 
public class Hablar implements Actividades
{
   private String palabras;
 
 
   public Hablar(String palabras)
   {
	   this.palabras = palabras;
   }
 
   public void actividad()
   {
	   System.out.println(this.palabras);
   }
}

Clase Medico

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

package tercerejemplo;
 
import java.util.Collection;
 
 
public class Medico extends Persona
{
 
	private Collection <Actividades> actividades;
	private String especialidad;
 
 
	public Medico (String nombreMedico)
	{
		super(nombreMedico);
	}
 
	public void setEspecialidad ( String especialidad)
	{
		this.especialidad = especialidad;
	}
 
	public void setActividades(Collection<Actividades> actividades)
	{
		this.actividades = actividades;
	}
 
	public void datos ()
	{
		System.out.println(this.nombre);
		System.out.println(this.especialidad);
		this.mostrarActividades();
	}
 
	public void mostrarActividades ()
	{
		for ( Actividades actividad : this.actividades  )
		{
			super.setActividad(actividad);
			super.actividades();
		}
	}
 
 
}

Clase persona

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 tercerejemplo;
 
 
public class Persona {
 
	Actividades actividad;
	String nombre;
 
	public Persona ()
	{
 
	}
 
	public Persona(String nombre)
	{ 
	   this.nombre = nombre;
	}
 
	public void setActividad(Actividades actividad)
	{
	   this.actividad = actividad;	
	}
 
	public void actividades ()
	{   
 
		actividad.actividad();
	}
 
}

Clase principal PersonaApp

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

package tercerejemplo;
 
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
 
import org.springframework.core.io.Resource;
import org.springframework.core.io.ClassPathResource;
 
 
public class PersonaApp {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
 
		Resource recurso = new ClassPathResource("Medico.xml");
 
		BeanFactory factoria = new XmlBeanFactory(recurso);
 
		Medico persona = (Medico) factoria.getBean("medico");
 
 
		persona.datos();
 
 
	}
 
}

]]> http://www.railsymas.com/2010/07/07/paso-de-referencias-al-bean/feed/ 0 Parámetros por nombre spring http://www.railsymas.com/2010/07/05/parametros-por-nombre-spring/ http://www.railsymas.com/2010/07/05/parametros-por-nombre-spring/#comments Mon, 05 Jul 2010 16:45:02 +0000 admin http://www.railsymas.com/?p=1761 Ejemplo para la inyección de dependencias en el que se configuran varios beans

Ficheros que intervienen en el ejemplo

Código de herramienta.java

1
2
3
4
5
6
7

package cuartoejemplo;
 
public interface Herramienta {
 
	abstract void utilidad();	
 
}

Código de Martillo.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

package cuartoejemplo;
 
public class Martillo implements  Herramienta
{
 
	private String longitud;
 
	public Martillo (String longitud)
	{
		this.longitud = longitud;
	}
 
	public void utilidad ()
	{
		System.out.println("Apuntalar cosas");
	}
 
	public void getLongitud ()
	{
		System.out.println("La logintud es "+this.longitud);
	}
 
 
}

Código de sierra.java

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

package cuartoejemplo;
 
public class Sierra implements Herramienta{
 
	private String color;
 
	public Sierra(String color)
	{ 
		this.color = color;
 
	}
 
	public void utilidad ()
	{  
		System.out.println("Sirve para serrar");
	}
 
	public void getColor()
	{
		System.out.println("Es de color"+this.color);
	}
 
}

Código de obrero.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

package cuartoejemplo;
 
public class Obrero 
{
    private String nombre;
    private Herramienta herramienta;
 
    public Obrero (String nombre)
    {
    	this.nombre = nombre;
    }
 
    public void getNombre ()
    {
    	System.out.println("nombre: "+this.nombre);
    }
 
 
    public void setHerramienta ( Herramienta herramienta)
    {
    	this.herramienta = herramienta;
    }
 
    public void getHeramienta ()
    {
    	herramienta.utilidad();
 
    }
 
    public void inicio ()
    {
    	System.out.println("inicio");
    }
 
    public void eliminar()
    {
    	nombre="";
        herramienta = null;
 
    }
 
}

Código de obreroapp.java la aplicación principal, donde se obtiene el bean declerado en el fichero obrero.xml, llamamos a al bean trabajador1

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

package cuartoejemplo;
 
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
 
import org.springframework.core.io.Resource;
import org.springframework.core.io.ClassPathResource;
 
 
 
public class ObreroApp {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		Resource recurso = new ClassPathResource("cuartoejemplo\\Obrero.xml");
 
		BeanFactory factory = new XmlBeanFactory (recurso);
 
		Obrero obrero   = (Obrero) factory.getBean ("trabajador1");
 
		obrero.getNombre();
 
		obrero.getHeramienta();
 
 
 
	}
 
}

Código de Obrero.xml, se pueden declarar los métodos de inicio y de destroy que se ejecutan al comienzo y al final de la vida del objeto.

Con el atributo id, establecemos el identificador para hacer uso de el en el programa principal. El atributo class establecemos la relación con el path a la clase, tiene como constructor el valor de obrero1

El bean herramienta declara un valor para el constructor de la clase con el valor de rojo

En el bean trabajodor1 tenemos el atributo autowire con el valor byname, estamos indicando una conexión automática del bean por nombre, de tal forma que se hace coincidir el valor de una propiedad con un bean del mismo nombre en este caso herramienta sin tener que pasar la referencia explicita del bean herramienta en trabajador1

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <bean id="herramienta" class="cuartoejemplo.Sierra">
       <constructor-arg value="rojo"/>            
    </bean>
 
    <bean id="trabajador1" class="cuartoejemplo.Obrero" autowire="byName"
      init-method="inicio"
      destroy-method="eliminar"           
     >       
 
    <constructor-arg value="obrero1"/>       
 
    </bean>
 
</beans>

Resultado

]]> http://www.railsymas.com/2010/07/05/parametros-por-nombre-spring/feed/ 0 Programación orientada a aspectos spring framework http://www.railsymas.com/2010/07/03/programacion-orientada-a-aspectos-springframework/ http://www.railsymas.com/2010/07/03/programacion-orientada-a-aspectos-springframework/#comments Sat, 03 Jul 2010 19:38:10 +0000 admin http://www.railsymas.com/?p=1724 Una breve introducción teórica, en este caso además se realiza un ejemplo para spring para poner en práctica los elementos teóricos.

La programación orientada a aspectos es un concepto que se puede aplicar a cualquier lenguaje de programación, toda aplicación tiene algunas funciones que implican diversos puntos de la aplicación, estas funciones se denominan aspectos transversales. La programación aop permite desacoplar esos aspectos transversales de los puntos de la aplicación a los que afectan.

En una aplicación dividimos los diferentes requerimientos en módulos, pero existen diferentes funcionalidades de la aplicación que afectan a los diferentes módulos de la aplicación. por ejemplo la seguridad, que tiene que estar presente en todos los puntos de la aplicación constituyendo un aspecto transversal que afecta a todos los puntos de la aplicación.

Dentro de la oap existen un conjunto de conceptos asociados con su correspondiente terminología.

Las notificaciones, constituyen el propósito de un aspecto, describe la tarea que se va a realizar así como el cuándo se va a realizar.

Punto de unión (joinpoint) es un punto en la ejecución de la aplicación y es esos puntos donde se inserta un aspecto. Estos puntos pueden ser la llamada a un método o el lanzamiento de una excepción, son los puntos donde la funcionalidad del aspecto aporta

Punto de corte (pointcut), un aspecto no tiene porque influir en todos los puntos de unión de la aplicación , los puntos reducen los puntos de unión, determinando el dónde

Un aspecto es la unión de una notificación y de un punto de corte y de una notificación.

Conjunto de archivos que se van a utilizar en este 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

package quintoejemplo;
 
public class Estudiante  {
 
	private String nombre;
	private String materia;
 
	public Estudiante (String nombre,String materia)
	{
		this.nombre = nombre;
		this.materia = materia;
	}
 
	public void getNombre()
	{
	  System.out.println("Nombre del estudiante"+this.nombre);  	
	}
 
 
	public void preparaExamen ()
	{
		System.out.println("Prepara el examen para "+this.materia);
	}
 
 
 
	public void celebraAprobado ()
	{
		System.out.println("Celebra el aprobado");
	}
 
 
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package quintoejemplo;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class EstudianteApp {
 
	 public static void main (String[] args )
	 {
		ApplicationContext contexto = new ClassPathXmlApplicationContext("quintoejemplo\\Examen.xml");
 
	    Examen examen= (Examen) contexto.getBean("examen1"); 
 
	    examen.realizar();
	 }
}
1
2
3
4
5
6
7

package quintoejemplo;
 
public interface Examen {
 
	public void  realizar ();
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package quintoejemplo;
 
public class ExamenImp implements Examen
{
    private String materia;
 
    public ExamenImp (String materia)
    {
    	this.materia = materia;
    }
 
	public void realizar()
    {
    	System.out.println("Realizando el examen de la materia "+this.materia);
    }
 
 
}
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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
 
    <aop:config>    
    <aop:aspect ref="realizacionexamen">    
    <aop:pointcut id="puntodecorte" expression="execution(* *.realizar(..))"/>    
    <aop:before      
     method="preparaExamen"
     pointcut-ref="puntodecorte"
     />    
    <aop:after
     method="celebraAprobado"
     pointcut-ref="puntodecorte"
    />    
    </aop:aspect>
 
    </aop:config>    
    <bean id="examen1" class="quintoejemplo.ExamenImp">       
       <constructor-arg value="matematicas"/> 
 
    </bean>    
    <bean id="realizacionexamen" class="quintoejemplo.Estudiante">
 
      <constructor-arg value="juan"/>
      <constructor-arg value="matematicas"/>
 
    </bean> 
 
</beans>


<-- post en trabajo--->

]]> http://www.railsymas.com/2010/07/03/programacion-orientada-a-aspectos-springframework/feed/ 0 Introducción a spring framework http://www.railsymas.com/2009/10/09/spring-framework-introduccion/ http://www.railsymas.com/2009/10/09/spring-framework-introduccion/#comments Fri, 09 Oct 2009 17:32:31 +0000 admin http://www.railsymas.com/?p=738 imagenspring

Spring es un marco de trabajo desarrollado por Rob johnson, spring es un marco de trabajo ligero, en el que se introducen dos conceptos muy importantes como son, la inyección de dependencias y la programación orientada a aspectos.

El marco de trabajo de spring permite configurar aplicaciones complejas desde componentes simples, los objetos se declaran desde ficheros xml. Spring tiene una gran funcionalidad mediante gestión de transacciones y un orm marco de persistencia.

Un problema común en los lenguajes de programación orientados a objetos y ya no digamos en la programación estructurada, es el acoplamiento. Spring facilita el acoplamiento débil mediante la inyeccion de dependencias DI, de tal forma que se crea como una capa de abstracción que permite la lógica de la aplicación no se vea afectada ante un cambio de la aplicacion.

Marco de trabajo con MVC (modelo vista controlador)

Soporte remoto, Invocación de métodos remotos (RMI), Http Invoker, Jax-rpc

Comunicación orientada a mensajes, Java Message Service (JMS)

Spring Portlet MVC, para agregación de varias funcionalidades en una sola página web.

Estructura de Spring

esquema

Eclipse tiene un plugin para desarrollo de aplicaciones spring, facilitando el trabajo con éste framework.

Podemos descargar el entorno he introducirlo el los plugins de eclipse y hacer un clean para resetearlo. La otra opción es desde help, windows update instalar el ( Spring ide para eclipse) introduciendo la ruta correspondiente



Creamos un nuevo proyecto, new project y escogemos spring project



Creamos una nueva librería con los jar del proyecto spring, si nos bajamos springframework con las dependencias, al descomprimir el archivo vamos al directorio dist para spring.jar y nos vamos al directorio li, jakarta-commons e importamos a la librería commons-loggin.jar

Dentro del directorio src, del projecto spring, creamos el package primerejemplo, se trata de un holamundo por consola

Holamundo.java

1
2
3
4
5
6
7
8

package primerejemplo;
 
public interface Holamundo {
 
	public abstract void mostrarMensaje();
 
 
}

HolamundoImpl.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

package primerejemplo;
 
public class HolamundoImpl implements Holamundo
{ 
	private String mensaje;
 
	public HolamundoImpl ()
	{
 
	}
 
	public HolamundoImpl (String mensaje)
	{
		this.mensaje = mensaje;
	}
 
	public void setMensaje (String mensaje)
	{
		this.mensaje = mensaje;
	}
 
	public String getMensaje()
	{
	   return mensaje;	
	}
 
	public void mostrarMensaje()
	{
		System.out.println(this.mensaje);
	}
 
 
 
}

HolamundoApp.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

 package primerejemplo;
 
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
 
public class HolamundoApp {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		Resource resource = new ClassPathResource("holamundo.xml");
 
		BeanFactory factory = new XmlBeanFactory(resource);
 
		Holamundo holamundo = (Holamundo) factory.getBean("beanprueba");
 
		holamundo.mostrarMensaje();
 
	}
 
}

En el directorio src raíz , creamos el fichero de configuración holamundo.xml para cargar los beans, spring ide permite la realización de estos archivos

1
2
3
4
5
6
7
8
9

 <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
 <bean id="beanprueba" class="primerejemplo.HolamundoImpl">
  <property name="mensaje" value="hola mundo"/>
 </bean>
</beans>

resultado de la ejecución

]]> http://www.railsymas.com/2009/10/09/spring-framework-introduccion/feed/ 0