introducción a spring - uc3m · • el propio framework utiliza aspectos para implementar otras...

1

Servidores de Información 2008/2009 1

Introducción a Spring

Norberto FernándezDepartamento de Ingeniería Telemática

Universidad Carlos III de [email protected]


¿Qué es Spring?

• Framework de código abierto para el desarrollo de aplicaciones (empresariales) Java

• Origen: Rod Johnson, Expert One-to-One J2EE Design and Development (Octubre, 2002)

• Alternativa popular a J2EE (EJBs)• Veremos la versión 2.5

Fuente: Dzone

2


Motivación

• Malas experiencias con aplicaciones J2EEo Complejas,difíciles de probar, pobres prestaciones,...

• Críticas al uso de EJBs:o Rod Johnson, J2EE development without EJB (2004)

� Complejidad (descriptores, implementación interfaces,...) y baja productividad del programador

� Modelo remoto basado sólo en RMI� Muchas aplicaciones no necesitan componentes remotos� Difíciles de depurar (dependencias con contenedor, volver a

hacer deployment y volver a arrancar)� Mapeo O/R basado en entity beans limitado (p.ej. no

considera la relación de herencia)� ...


Motivación

• J2EE objetivo: estandarizar servicios de uso común en el desarrollo de aplicaciones empresarialeso Directorio (JNDI), transacciones (JTA), conexión a sistemas legados

(JCA), pooling de recursos, etc

• EJB es sólo una forma de llevar a la práctica a esos servicios a través de un modelo de componentes

• Sin embargo podemos usar las funcionalidades de los servicios sin tener EJBs ...

• ... este es el objetivo de Spring: ofrecer librerías con las funcionalidades de uso común por aplicaciones empresariales ...

• ... y más "ligeras" que los EJBs o Usar POJOs (Plain Old Java Objects) en su lugar

3


Módulos principales de Spring

• Spring Core (Inversión del control (IoC) / Inyección de dependencias (DI))

• Spring AOP (Programación orientada a aspectos) • Spring JDBC (Acceso a datos)• Spring MVC (desarrollo Web según el patrón MVC)• Spring Remoting (distribución)• Spring Transaction Abstraction (Gestión de

transacciones) • Otros: Spring TestContext (pruebas), Spring JMX

(gestión), Spring Security (seguridad), Spring Web Flow(control de flujos en aplicaciones Web)

Spring Core

Dependency Injection

4


IoC / DI: Introducción

• El núcleo de Spring (Spring Core)• Inversion of Control (IoC): Hollywood principle

o "Don't call us, we'll call you"• Los componentes no crean (con new) o buscan (p.ej. con

JNDI) las referencias a otros componentes que necesitan para realizar su trabajo, sino que simplemente declaran qué dependencias tienen (fichero de configuración, anotaciones) y un contenedor les proporciona (inyecta) estas dependenciaso Dependency Injection (DI)

• El contenedor se encarga de instanciar o localizar los componentes necesarios e inicializarlos antes de inyectar su referencia a quién la necesite


IoC / DI: Introducción

• Se suele combinar con programación basada en interfaces, para conseguir bajo acoplamiento entre componenteso Sólo dependencia con las interfaces, no con las implementaciones

concretas• Ventajas:

o Se reduce el código de pegamento� Llamadas a JNDI para localizar componentes� Código de conexión con componentes remotos

� El contenedor proporciona proxy

o Fichero de configuración de dependencias: tocar sólo ahí para cambiarlas� Sin tocar el código fuente y sin recompilar

o Facilidad para llevar a cabo pruebas� Reemplazar componentes por Mockup objects

5


DI: HolaMundo (I)

Interfaz del servicio:

package spring.core.ejemplos;

public interface MessagingService {public String sayMessage(String name);

}


DI: HolaMundo (II)

Implementación del servicio:


public class MessagingServiceImpl implements MessagingService {

Message msg = null;public void setMsg(Message msg) {

this.msg = msg;}public String sayMessage(String name) {

return msg.getMsg() + " " + name;}

}

6


DI: HolaMundo (III)

Message (interfaz e implementación):


public interface Message {public String getMsg();

}


public class HelloMessage implements Message {

public String getMsg() {return "Hello";

}}


DI: HolaMundo (IV)

Fichero de configuración XML de Spring (spring-beans.xml):

<?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.5.xsd">

<bean id="helloMsg" class="spring.core.ejemplos.HelloMessage"/>

<bean id="helloSrv" class="spring.core.ejemplos.MessagingServiceImpl"><property name="msg" ref="helloMsg"/>

</bean>

</beans>

7


DI: HolaMundo (y V)

Main de la aplicación:


import org.springframework.context.ApplicationContext;import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {

public static void main(String[] args) {

ApplicationContext context = new FileSystemXmlApplicationContext("src/spring/core/ejemplos/spring-beans.xml");

MessagingService hello = (MessagingService)context.getBean("helloSrv");System.out.println(hello.sayMessage(args[0]));

}}

Spring AOP

Programación Orientada a Aspectos

8


AOP: Introducción

• ¿Qué es?o Aspect Oriented Programmingo Permite combinar cierto código con otro (aspecto) para añadir cierta

funcionalidad al original sin necesidad de modificarloo Facilitar la implementación de funcionalidades transversales de una

aplicación � Ej.: logging, control acceso

• Tipos de AOPo Estática

� En tiempo de compilación� Se incluye la información de aspectos en los bytecodes

� Problema: recompilar para modificaro Dinámica

� En tiempo de ejecución� Problema: mayor coste computacional

� Interrumpir flujo programa para comprobar si hay que ejecutar el aspecto


AOP: Conceptos

• Joinpoint (Punto de cruce)o Punto concreto del flujo de ejecución

� Ej.: Llamada al método hola de una determinada clase

• Advice (Consejo)o Código que el aspecto ejecuta en un joinpoint

• Pointcuts (Punto de corte)o Combinación de joinpoints

� Ej.: Llamada a cualquier método de una clase concreta• Aspects (Aspecto)

o Combinación de advice (código) y pointcut (lugar donde se interrumpe el flujo normal para ejecutarlo)

• Target (Destinatario)o Objeto cuyo comportamiento modifica el aspecto

• Introductiono Permite añadir métodos o atributos a clases ya existentes

9


Spring AOP

• AOP dinámica• Implementada a través de Proxys• Más limitada que la de otras librerías (ej.: AspectJ)

o Ej.: Sólo un tipo de joinpoint (invocación a método)� Se puede combinar AspectJ con Spring si se necesita más

• El propio framework utiliza aspectos para implementar otras funcionalidadeso Ej.: Transacciones

• A continuación veremos el HolaMundo


Spring AOP: Hola Mundo (I)

Target:

package spring.aop.ejemplos;

public class HelloWorldServiceImpl implements HelloWorldService {

public String sayHello(String name) {return "Hello " + name;

}}

10


Spring AOP: HolaMundo (II)

Advice:

package spring.aop.ejemplos;

public class HelloWorldAdvice {

public void antes() {System.out.println("Llamando a sayHello");

}

public void despues(Object ret) {System.out.println("sayHello ha devuelto " + ret.toString());

}}


Spring AOP: HolaMundo (III)

Fichero de configuración:

<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.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<bean id="helloSrv" class="spring.aop.ejemplos.HelloWorldServiceImpl" /><bean id="helloAdvice" class="spring.aop.ejemplos.HelloWorldAdvice" />

<aop:config><aop:aspect ref="helloAdvice">

<aop:pointcut id="sayHelloPointCut" expression="execution(* *.sayHello(..))" /><aop:before method="antes" pointcut-ref="sayHelloPointCut" /><aop:after-returning method="despues" pointcut-ref="sayHelloPointCut"

returning="ret" /></aop:aspect>

</aop:config></beans>

11


Spring AOP: HolaMundo (y IV)

Main de la aplicación:package spring.aop.ejemplos;


public class Main {


ApplicationContext context = newFileSystemXmlApplicationContext("src/spring/aop/ejemplos/spring-beans.xml");

HelloWorldService hello = (HelloWorldService)context.getBean("helloSrv");System.out.println(hello.sayHello(args[0]));

}}

Spring Data Access

12


Acceso a datos

Una estructura Java típica de acceso a BD:

public void saveWhatever(Whatever w) {

Connection conn = null;PreparedStatement stmt = null;try {

conn = dataSource.getConnection();stmt = conn.prepareStatement(DB_QUERY);

...stmt.execute();

} catch (SQLException e) {…

} finally {try {

if(stmt != null) { stmt.close(); } if(conn != null) { conn.close(); }

} catch (SQLException e) { // noop }}


Acceso a datos

• Aspectos a mejorar en el ejemplo:o SQLException: excepción genérica o Captura de excepciones para no hacer nada

• ¿Cómo lo mejora Spring?o Mapeo de SQLException a excepciones específicas

� Subclases de org.springframework.dao.DataAccessException

o Uso de unchecked exceptions� DataAccessException es una subclase de java.lang.RuntimeException� Se pueden capturar si se desea, pero no es obligatorio

o Automatiza la gestión de conexiones� Se declara una fuente de datos y Spring la gestiona� No se accede directamente a las conexiones, sino que se utiliza un

JdbcTemplate� Usualmente un org.springframework.jdbc.core.JdbcTemplate

• Veremos acceso a BD relacionales, pero Spring ofrece integración con librerías ORM como Hibernate

13


Acceso a datos: HolaMundo (I)

• Vamos a trabajar con una base de datos de productos:

Prod_ID char(5), Nombre varchar(20), Stock int, Precio double

• Creamos un bean para trabajar con estos productos:

public class Producto {String id;String nombre;int stock;float precio;

// Aquí van los getters y setters }


Acceso a datos: HolaMundo (II)

Interfaz del servicio de acceso a datos:

package spring.jdbc.ejemplos;

public interface DataAccessService {

public void insertarProducto(Producto p);public Producto consultarProducto(String id);

}

14


Acceso a datos: HolaMundo (III)Implementación del servicio de acceso a datos (I):


import java.sql.ResultSet;import java.sql.SQLException;import java.util.List;import org.springframework.dao.DataAccessException;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.RowMapper;

public class DataAccessServiceImpl implements DataAccessService {

private JdbcTemplate jdbcTemplate;public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;}

...


Acceso a datos: HolaMundo (IV)

Implementación del servicio de acceso a datos (II):

...

private static final String PRODUCT_INSERT ="insert into Productos (prod_id, nombre, stock, precio) values (?,?,?,?)";

public void insertarProducto(Producto p) {jdbcTemplate.update(PRODUCT_INSERT,

new Object[]{p.getId(), p.getNombre(), p.getStock(), p.getPrecio()});}

...

15


Acceso a datos: HolaMundo (V)Implementación del servicio de acceso a datos (y III):private static final String PRODUCT_SELECT =

"select prod_id, nombre, stock, precio from Productos where prod_id=?";

public Producto consultarProducto(String id) {

List matches = jdbcTemplate.query(PRODUCT_SELECT,new Object[]{id},new RowMapper() {

public Object mapRow(ResultSet rs, int rowNum)throws SQLException, DataAccessException {

Producto p = new Producto();p.setId(rs.getString(1));p.setNombre(rs.getString(2));p.setStock(rs.getInt(3));p.setPrecio(rs.getFloat(4));return p;

}}

);

return matches.size() > 0 ? (Producto) matches.get(0) : null;}


Acceso a datos: HolaMundo (VI)Fichero de configuración de Spring:

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans


<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/Productos"/><property name="username" value="user"/><property name="password" value="*****"/><property name="initialSize" value="5" /><property name="maxActive" value="10" />

</bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

<property name="dataSource" ref="dataSource"/></bean><bean id="dao" class="spring.jdbc.ejemplos.DataAccessServiceImpl">

<property name="jdbcTemplate" ref="jdbcTemplate" /></bean>

</beans>

16


Acceso a datos: HolaMundo (y VII)Main de la aplicación:



public class Main {public static void main(String[] args) {

ApplicationContext context = newFileSystemXmlApplicationContext("src/spring/jdbc/ejemplos/spring-beans.xml");

DataAccessService daoSvc = (DataAccessService)context.getBean("dao");

Producto p = new Producto();p.setId("id123");p.setNombre("NuevoProducto");p.setPrecio((float)12.37);p.setStock(120);

daoSvc.insertarProducto(p);System.out.println(daoSvc.consultarProducto("id123"));

}}

Spring MVC

Desarrollo de aplicaciones Web

17


Spring MVC: Funcionamiento (I)

Fuente: Spring in action


Spring MVC: Funcionamiento (II)

(1) Las peticiones pasan a través de un servlet que actúa de Front Controller (DispatcherServlet)

(2) El DispatcherServlet consulta a un HandlerMapping para decidir a qué controlador le pasa la petición

o Usa la URL de la solicitud para decidir(3 y 4) El controlador procesa la petición, accede a la

lógica de negocio y potencialmente obtieneresultados (modelo, un Map) además selecciona lavista para presentar el modeloo Para que el controlador no esté acoplado a la vista, se

devuelve un identificador lógico (nombre) de vista o Devuelve al DispatcherServlet un objeto que encapsula

ambos: ModelAndView

18


Spring MVC: Funcionamiento (y III)

(5) El DispatcherServlet utiliza un ViewResolver pararesolver el nombre en una vista concretao Normalmente un JSP, pero se soportan otros Velocity,

XSLT,Tiles, ...(6) El DispatcherServlet utiliza la vista para mostrar el

modelo al usuario


Spring MVC: DispatcherServlet

• Objeto de la clase DispatcherServlet del paquete org.springframework.web.servlet

• Actúa como un broker: despacha las peticiones que recibe al controlador responsable de tratarlas

• Configurar el /WEB-INF/web.xml de la aplicación para que el dispatcher reciba las peticiones

• Lee su configuración del fichero dispatcher-servlet.xmlo Ubicado en el /WEB-INF/ de la aplicacióno Referencia al HandlerMappingo Referencias a los controladoreso Referencia al ViewResolver

19


Spring MVC: HandlerMapping• Interfaz HandlerMapping del paquete

org.springframework.web.servlet• Spring proporciona varias implementaciones. Dos de las

más utilizadas son:o Paquete: org.springframework.web.servlet.handlero BeanNameUrlHandlerMapping

� Selección por nombre del bean (el nombre coincide con la URL de invocación). Es el HandlerMapping por defecto

<bean name="/home.htm" class="this.is.an.example.HomePageController"/>

o SimpleUrlHandlerMapping� Se define una tabla que asocia URLs a controladores� Lo veremos en el ejemplo


Spring MVC: Controller

• Interfaz Controller del paquete org.springframework.web.servlet.mvc

• Método principal:

ModelAndView handleRequest(HttpServletRequest request,HttpServletResponse response) throws Exception;

• Usualmente para implementar un controlador se extiende de la clase abstracta AbstractController del mismo paquete

• Al controlador se le inyecta (si es necesario) la referencia al bean que ofrece el servicio de la lógica de negocio

20

39

Spring MVC: ViewResolver• Interfaz ViewResolver del paquete

org.springframework.web.servlet• Método:

View resolveViewName(String viewName, Locale locale) throws Exception

• Spring ofrece algunas implementaciones:o Paquete: org.springframework.web.servlet.viewo ResourceBundleViewResolver

� Un fichero bundle contiene las definiciones de vista (mapeo nombre de vista aimplementación de vista). Por ejemplo, bundle views_EN.properties:

nombre-vista.class=org.springframework.web.servlet.view.JstlViewnombre-vista.url=/WEB-INF/views/en_GB/user/edit.jsp

o UrlBasedViewResolver� No mapeo: el nombre es directamente una referencia a la vista� No implementa soporte para localización� Veremos en el ejemplo el uso de una de sus

subclases: InternalResourceViewResolver


Spring MVC: View

• Interfaz View del paquete org.springframework.web.servlet• Métodos principales:

String getContentType() void render(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception

• Spring proporciona múltiples implementaciones de esta interfazo JstlView, VelocityView, TilesView, XsltView, ...

21


Spring MVC: HolaMundo (I)

/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?><web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

<servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>2</load-on-startup>

</servlet>

<servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.do</url-pattern>

</servlet-mapping>

<welcome-file-list><welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>


Spring MVC: HolaMundo (II)

Página de bienvenida: index.jsp

<%@page contentType="text/html" 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>Spring MVC Hello World</title>

</head>

<body><form method="post" action="greet.do">

Type in your name here: <input type="text" name="name"/><input type="submit" value="Go!"/>

</form></body>

</html>

22


Spring MVC: HolaMundo (III)

/WEB-INF/dispatcher-servlet.xml


<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.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd>

<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"><property name="mappings">

<props><prop key="greet.do">greetingController</prop></props></property>

</bean><bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">

<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/><property name="prefix" value="/WEB-INF/jsp/"/><property name="suffix" value=".jsp"/>

</bean><bean name="greetingController" class="spring.mvc.ejemplos.GreetController"/>

</beans>


Spring MVC: HolaMundo (IV)package spring.mvc.ejemplos;

import java.util.HashMap;import java.util.Map;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 GreetController extends AbstractController {

protected ModelAndView handleRequestInternal(HttpServletRequest req, HttpServletResponse res)throws Exception {

String param = req.getParameter("name");if ((param == null) || (param.trim().equals(""))) {

param = "Anonimous User";}

Map model = new HashMap();model.put("usrName", param);

return new ModelAndView("greet", model);}

}

23


Spring MVC: HolaMundo (y V)

/WEB-INF/jsp/greet.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%><%@taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>

<!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>JSP Page</title>

</head><body>

<h1>Hello <c:out value="${usrName}"></c:out>!</h1></body>

</html>

Spring Remoting

Acceso a componentes remotos

24


Spring Remoting: Introducción

• Objetivo: facilitar el desarrollo de aplicaciones distribuidaso Reducir el código que se necesita para exponer un bean como servicio o

para acceder desde un bean a un servicio remoto• Spring proporciona mecanismos para:

o Definir service exporter (convertir bean en servicio)o Definir proxies (acceder a beans remotos como locales)

• En la práctica Spring 2.5 soporta cinco tipos distintos de arquitecturas distribuidas:o RMIo Servicios Web (sólo proxy, no exporter)o HTTP Invoker (específico de Spring)o Hessian (Caucho.com, protocolo binario, poco utilizado)o Burlap (Caucho.com, protocolo XML, poco utilizado)


Spring Remoting: HolaMundo (I)

• Se ha convertido el HolaMundo en un servicio Web que atiende peticiones remotas

• Se pretende integrar ese servicio como un componente más dentro de una aplicación Spring

• Fragmento del WSDL del servicio:

<wsdl:definitionstargetNamespace="http://platino:8181/axis/services/HolaMundo">...

<wsdl:service name="HelloWorldServiceImplService"><wsdl:port binding="impl:HolaMundoSoapBinding" name="HolaMundo"><wsdlsoap:address

location="http://platino:8181/axis/services/HolaMundo"/></wsdl:port>

</wsdl:service></wsdl:definitions>

25


Spring Remoting: HolaMundo (II)Fichero de configuración de Spring:


<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


<bean id="remoteHelloSrv" class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean">

<property name="wsdlDocumentUrl"value="http://platino:8181/axis/services/HolaMundo?wsdl" />

<property name="serviceInterface"value="spring.remote.ejemplos.HelloWorldService"/>

<property name="portName" value="HolaMundo" /><property name="serviceName" value="HelloWorldServiceImplService" /><property name="namespaceUri"

value="http://platino:8181/axis/services/HolaMundo" /></bean>

</beans>


Spring Remoting: HolaMundo (III)

Main de la aplicación:

package spring.remote.ejemplos;


public class Main {


ApplicationContext context = new FileSystemXmlApplicationContext("src/spring/core/ejemplos/spring-beans.xml");

HelloWorldService remoteHello = (HelloWorldService)context.getBean("remoteHelloSrv");

System.out.println(remoteHello.sayHello(args[0]));}

}

26


Gestión de transacciones• Spring ofrece gestión de transacciones programática o

declarativa• Cuando se trabaja con una fuente de datos Spring permite

utilizar el soporte de transacciones de la fuente (BD relacional JDBC, Hibernate, ...)

• Spring es compatible con JTA (Java Transaction API)o Permite ofrecer soporte a transacciones distribuidas

• Spring no gestiona directamente las transacciones, sino que hace uso de un gestor de transacciones (TransactionManager) del que se ofrecen varias implementaciones:o org.springframework.jdbc.datasource.DataSourceTransactionManager (JDBC)o org.springframework.orm.hibernate3.HibernateTransactionManager (Hibernate)o org.springframework.transaction.jta.JtaTransactionManager (JTA)o ...

Gestión de transaccionesEjemplo de (parte de) fichero de configuración de Spring:<bean id="fooService" class="x.y.service.DefaultFooService"/><tx:advice id="txAdvice" transaction-manager="txManager">

<tx:attributes><tx:method name="get*" read-only="true"/><tx:method name="*"/>

</tx:attributes></tx:advice>

<aop:config><aop:pointcut id="fooServiceOperation" expression="execution(* x.y.service.FooService.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>

</aop:config>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"><property name="url" value="jdbc:mysql://localhost/Productos"/><property name="username" value="user"/><property name="password" value="*******"/>

</bean>

<bean id="txManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource"/></bean>

27

53

Referencias• Rod Johnson; Expert One-to-One J2EE

Design and Development. Ed Wrox, ISBN: 9780764543852, 2002.

• Rod Johnson; J2EE development without EJB. Ed Wrox, ISBN: 9780764558313, 2004.

• J. Machacek, A. Vukotic, A. Chakraborty, J.Ditt; Pro Spring 2.5. Ed. Apress, ISBN: 9781590599211, 2008.

• C. Walls, R. Breidenbac; Spring in action (2nd Ed.). Ed. Manning, ISBN: 9781933988139, 2007.

introducción a spring - uc3m · • el propio framework utiliza aspectos para implementar otras...

Documents