Core Networks

Desarrollo de aplicaciones JavaEE con Spring 5

Desarrollo con Spring 5

Temario
Objetivos:

• Conocer Spring y SpringBoot, y entender cómo nos permiten estructurar

la arquitectura de nuestra aplicaciones.

• Conocer SpringDataJPA y SpringMVC y entender cómo nos pueden

permitir construir un backend para aplicaciones web con APIs REST.

• Spring Core y AOP • Conocer y aplicar de manera práctica el framework JUnit, SpringTest
• Spring boot y RestAssured para probar las APIs REST de nuestro backend.

• Persistencia con Spring Data Requisitos:

• Desarrollo web y API REST • Conocimientos básicos de Java en su versión 11 y la API de Java
• Spring AMQP (especialmente el uso de colecciones y streams).

• Spring integration
• Spring social
Spring Core
y AOP
 Spring
• Inicialmente las aplicaciones web de
Java se desarrollaban utilizando
Servlets, aunque este modelo
rápidamente cayó en desuso,
debido a que era difícil de mantener
y no se reutilizan componentes
entre otras limitaciones.

• El segundo paso fue utilizar las JSP,

usando lo que Sun denominó Model 1.

• Este tipo de desarrollo, que incluía el

código y las etiquetas HTML en la
misma página condujo a ser
sustituido por el patrón MVC o lo que
Sun llamó Model 2 y que Spring aplica.
 Spring

• Podemos utilizar Spring sin utilizar ningún

contenedor Java EE, por ejemplo con una
aplicación creada con Swing ya que se aísla de la
capa de presentación usada.

• Spring acoge sin dificultades desde un fat-

client hasta una aplicación desarrollada con
tecnología RIA (Rich Internet Applications) como
framework para el desarrollo de aplicaciones
para Android.

• Aunque inicialmente se posicionó como

alternativa a los EJB’s, puede integrarse sin
dificultades con ellos, así como con API’s de
Java EE como JNDI o RMI o JMX, JAAS.
Spring

• La arquitectura de Spring
es modular, de tal forma
que es posible decidir que
componentes de Spring
queremos utilizar.

• El módulo Core container es el

único estrictamente necesario.

• La arquitectura modular
de Spring utiliza OSGi.

• Actualmente el módulo MVC,

utiliza REST.
 Spring

• Spring Core, proporciona las funciones

esenciales del framework, el
componente primario del “core” es
BeanFactory: una implementación de
patrón de diseño Factory.

• Spring Context, es un fichero de

configuración que proporciona
información del contexto al framework. El
contexto de Spring incluye servicios
enterprise tales como JNDI, EJB, email,
i18N, validación o programación de tareas.

• Spring AOP, la implementación AOP de

Spring integra la funcionalidad AOP en
el framework, como resultado de esto,
puede fácilmente gestionar cualquier
objeto.
 Spring

• Spring DAO, la capa de abstracción DAO

es la encargada de gestionar y envolver
las excepciones producidas por otros
frameworks como Hibernate o mensajes
de error producidos por los motores de
BBDD.

• Spring ORM, esta capa permite conectar

distintos sistemas ORM como Hibernate,
iBatis, JDO o SQL Maps. Todos estos
frameworks cumplen con los requisitos
necesarios para trabajar con el sistema
de transacciones de Spring.

• Instrumentation, este módulo permite

utilizar JMX como API para la monitorización
y gestión de los MBeans de Spring.
 Spring

• Spring Web Module, el módulo web está

construido por encima del contexto de la
aplicación, proporcionando un contexto
para otros frameworks web.

• El módulo MVC permite ser configurado de

una manera muy potente, permitiendo
añadir frameworks como JSF.

• Spring MVC framework, es una

implementación avanzada del patrón MVC y
contiene los mecanismos necesarios para
desarrollar una aplicación completa, como
los view-resolvers y controladores así
como las librerías de etiquetas de Spring.
 Spring STS

Basado en eclipse, es posible

descargarlo completo desde:

www.springsource.org/sts

Permite:

• Crear proyectos Spring, con asistentes para beans.

•
Soporte para Spring 5, perfiles de beans y
anotaciones.
•
Completado de código, asistentes de contexto
y validación.
•
Refactoring para Spring XML y el estilo @Configuration.
•
Herramientas visuales para Spring WF, Integration y
Batch.
•
Soporta la creación de proyectos Spring Roo.
•
Validación de blueprints y best practices.
•
Incorpora VMware vFabric tc Server.
Spring
Inyección de dependencia

La inyección de dependencia que implementa

Spring, permite el efectivo desacoplamiento de las
clases entre sí.

Las dependencias directas perjudican la

flexibilidad de una aplicación:

Fragilidad, la introducción de cambios en la

aplicación, produce comportamientos inesperados.

Rigidez, es difícil hacer cambios, afectan a

muchas partes de la aplicación.

Inamovilidad, es difícil de llevar a cabo la

reutilización de software, existe una
escaza amortización del trabajo realizado.
Inyección de dependencia: core container

El core container es mucho más que la inyección de

dependencia, es capaz de aportar funcionalidad
AOP (otro mecanismo de desacoplamiento),
abstracción de la carga de recursos, i18n,
publicación de eventos, para todo esto utiliza la
clase ApplicationContext.

ApplicationContext implementa el interface

BeanFactory, y de esta forma de aísla de todas
estas características utilizando sólo aquellas que
necesita, para las aplicaciones web existe un
WebApplicationContext.

Spring se entrega con un listener que lanza

ApplicacionContext y que se encarga de parsear los
archivos de configuración declarados en el «web.xml».
 Core container: bean factories

El core container también llamado ligthweigth

container es el núcleo de Spring y trabaja alrededor
de un concepto denominado Inyección de
dependencia.

La inyección de dependencia es uno de los

mecanismos que permite fomentar el desacoplamiento
entre las clases de una aplicación.

El concepto es simple, en lugar de que la clase sea la

encargada de buscar (estrategia JNDI) o estar
asociada directamente a la clase o servicio, Spring:

• Libera a la clase de la necesidad de localizar el servicio

• Utilizando un interface para abstraerla del servicio
Core container: bean factories

El contenedor ligero está gestionado por el interface BeanFactory.

El core container es el responsable de parsear los archivos de configuración o anotaciones para crear
los beans:

Spring
Beans

Bean 1
Configuración XML
Bean 2
BeanFactory

@nnotations

Bean …n
 Bean factories: ciclo de vida

• Spring incorpora un mecanismo denominado component-scanning que permite

identificar aquellos beans que usan anotaciones y están situados en el classpath.

• Para habilitar este mecanismo, podemos hacerlo a través de una clase de configuración
Java:

@Configuration
@ComponentScan(basePackages = {
"com.pruebas.service",
"com.pruebas.repositorio" })
@ComponentScan(basePackageClasses = AppConfig.class)
public class ApplicationContextConfiguration { … }

• Hay que limitar adecuadamente el rango de “escaneo” de Spring.

 Bean factories: ciclo de vida

• Por defecto en Spring todos los beans

declarados en el ApplicationContext son de
tipo singleton, lo cual, significa que existe una Alcance/scope Descripción
única instancia del bean para todas las singleton
The default scope. A single instance of a bean is created and shared
throughout the application.
peticiones.
Each time a certain bean is needed, a fresh instance of the bean is
• En aquellos casos donde es necesario prototype
returned.
mantener el estado de nuestros beans, puede The bean is created when needed and bound to the current executing
thread
representar un problema disponer de un bean thread. If the thread dies, the bean is destroyed.
singleton, ya que varios usuarios pueden The bean is created when needed and bound to the lifetime of the
request incoming javax.servlet.ServletRequest. If the request is over, the bean
modificar concurrentemente su estado. instance is destroyed.

The bean is created when needed and stored in javax.servlet.HttpSession.

• Spring permite definir otros alcances o scopes, session
When the session is destroyed, so is the bean instance
que podemos utilizar, según las necesidades The bean is created when needed and stored in the globally available
de la aplicación. globalSession session (which is available in Portlet environments). If no such session is
available, the scope reverts to the session scope functionality.

• Es posible definir un vean con scope prototype, application

This scope is very similar to the singleton scope; however, beans with this
scope are also registered in javax.servlet.ServletContext.
desde el archivo XML o usando anotaciones.
Primeros pasos
con Spring
Configuración: ApplicationContext

El interface ApplicationContext puede ser configurado de diferentes formas, la más habitual

es utilizar archivos XML, pero también es posible hacerlo a través de archivos de
propiedades y clases Java, incluso mezclando varias formas.

Spring contiene varias implementaciones de este interface, cada una de ellas proporciona
las mismas características, pero se diferencian en el modo de cargar la configuración.

Implementación Tipo
ClassPathXmlApplicationContext Classpath(XML)
FileSystemXmlApplicationContext File System(XML)
AnnotationConfigApplicationContext Classpath (Java)
XmlWebApplicationContext Web Application Root(XML)
AnnotationConfigWebApplicationContext Web Application Classpath
Inyección de dependencia: configuración

Ejemplo de uso de una implementación de Resource como ClassPathResource para declarar

un bean y recuperarlo:
<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="prop"class="propiedades.Propiedades">
<property
name=“empresa"value=“tecnostash"/>
</bean>
</beans>

Para acceder al bean inicializado con los valores anteriores usaremos este codigo:

ApplicationContext bf = new ClassPathXmlApplicationContext("demo-context.xml"));

IPropiedades prp = (IPropiedades) bf.getBean("prop");
Tipos de inyección
Tipos de inyección: por constructor

Otra posibilidad de inyección es haciendo uso de los constructores:

public class EjemploConstructor
{ private Pedido pedido;
private String lema;

public EjemploConstructor(Pedido pedido, String lema)

{ this.pedido = pedido;
this,lema = lema;
} ...

Un ejemplo de este tipo de inyección es la siguiente:

<bean id="ejemploCons" class="com.pruebas.EjemploConstructor">

<constructor-arg ref=“pedido"/>
<constructor-arg value=“Mas vale pajaro en mano…">
</bean>
Tipos de inyección: por constructor

• Continuando con la clase anterior, el contenedor de Spring intenta resolver el tipo de cada
argumento para inyectarlo adecuadamente, es decir, el siguiente ejemplo funcionaría
correctamente:

<bean id="ejemploCons" class="com.pruebas.EjemploConstructor">

<constructor-arg value=“Mas vale pajaro en mano…">
<constructor-arg ref=“pedido"/>
</bean>

• Observa como hemos intercambiado la posición de los argumentos del ejemplo anterior, en
este caso el contenedor de Spring resuelve el orden correcto, atendiendo a los tipos de
cada argumento.
 Tipos de inyección: por constructor

private Pedido pedido;

private String lema;
private Double edad;
public UsandoConstructores(Pedido pedido, String lema, Double edad){
¿Pero q u e o c u r r e s i t e n e m o s this.pedido = pedido;
varias propiedades de diferentes this.lema = lema;
tipos de dato y que Spring no tiene this.edad = edad;

forma de resolver?: }

• La forma correcta es
identificando las propiedades <bean id="ejemploCons"class="com.pruebas.UsandoConstructores">
con el atributo «type»: <constructor-arg type="java.lang.String"value="Mas vale pajaro en mano…"/>
<constructor-arg ref="pedido"/>
<constructor-arg type="java.lang.Double"value="35"/>
</bean>
Tipos de inyección: por constructor

<bean id="coleccion"
class=“com.pruebas.InyectarCollection">
<property name="ciudades">
<!--list>

Podemos inyectar valores para ser <value>Tarragona</value>

manejados por alguna estructura del <value>Madrid</value>
framework collections, como List, <value>Valencia</value>
Set o Map: </list-->
<set>
<value>Badajoz</value>
<value>Tarragona</value>
<value>Madrid</value>
<value>Valencia</value>
</set>
</property>
</bean>
 Ejemplos de inyección

• Al crear una declaración de un bean podemos utilizar varios alias, separados por comas para
la misma clase, usando el atributo «name», en lugar de «id»:
<!--Hacemos uso de los alias -->
<bean name="coleccion, cols" class=“com.pruebas.InyectarCollection">
<property name="ciudades">
<!--list>…

• Podemos usar uno u otro para hacer referencia a él:

//Hacemos uso de los dos alias

//InyectarCollection ic = (InyectarCollection) factory.getBean("coleccion");
//Es posible hacerlo así
InyectarCollection ic = (InyectarCollection) factory.getBean("cols");
Collection<String> lista = ic.getCiudades();
 Internacionalizacion con Spring

• La internacionalización de aplicaciones con Spring, se basa en los mecanismos estándar

Java EE adaptados a la configuración del framework. En primer lugar crearemos los
archivos de properties para cada Locale.

• A continuación declararemos su situación y nombre en el archivo de configuración de Spring:

<!-- Definimos el archivo i18n -->

<bean id="messageSource"

class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list><value>com.pruebas.recursos.mensajes</value></list>
</property>
</bean>
 Internacionalizacion con Spring

• Spring trabaja la internacionalización, utilizando en el interface MessageSource y

LocaleResolver, que le ayudan en el proceso de resolución de las etiquetas basándose en
las claves y en el Locale.

• Existen dos implementaciones de MessageSource, son estas:

Implementación Descripción
Uses the ResourceBundle facility available on the JVM. It can
ResourceBundleMessageSource
only load resources from the classpath.
Works in a similar way as the ResourceBundleMessageSource
but adds reloading and caching capabilities. It allows for the
ReloadableResourceBundleMessageSource resources to be anywhere on the file system it uses the resource
loading mechanism in Spring.
 Internacionalizacion con Spring

• La internacionalización está basada en archivos de tipo properties, que incluyen las claves
de las etiquetas i18n de la capa de presentación. Podemos configurarla haciendo uso de
las anotaciones.
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = { "com.pruebas.web" })
public class PruebasWebConfiguration extends WebMvcConfigurerAdapter {
@Bean
public MessageSource messageSource()
{ ReloadableResourceBundleMessageSource messageSource;
messageSource = new ReloadableResourceBundleMessageSource();
messageSource.setBasename("classpath:/traducciones");
messageSource.setUseCodeAsDefaultMessage(true);
return messageSource;
}
}
 Internacionalizacion con Spring: LocaleResolver

• Para que este mecanismo de i18n, realice su trabajo es necesario configurar el interface
LocaleResolver, el cual dispone de varias implementaciones que se ajustan a las
necesidades de diferentes tipos de aplicación.

Implementación Descripción

Always resolves to a fixed locale. All the users of our website use the same locale, so
FixedLocaleResolver
changing the locale isn’t supported.
Resolves (and stores) the locale in the user’s HttpSession. The attribute used to store the
locale can be configured, as well as the default locale to use if no locale is present. The
SessionLocaleResolver
drawback to this is that the locale isn’t stored between visits, so it must be set at least
once on the user’s session.
Uses the http accept header to resolve the locale to use. In general, this is the locale of
AcceptHeaderLocaleResolver the operating system of the user, so changing the locale isn’t supported. It is also the
default LocalResolver used by the DispatcherServlet.
Uses a cookie to store the user’s locale. The advantage of this resolver is
CookieLocaleResolver that the locale is kept on the client’s machine, so it will be available on
subsequent visits to the website
 AOP con Spring

• La programación orientada a aspectos permite interceptar acciones o invocaciones,

para llevar a cabo alguna tarea adicional.
• Podemos considerar AOP como un mecanismo de interceptación de peticiones, que nos permite
reutilizar código y desacoplar aún más nuestra aplicación:

Comprobamos
que no hay errores
Iniciamos un al procesar el Detenemos el
servicio método - around servicio

Invocación al Interceptamos la Interceptamos la

método Método original
petición - before petición - after
 AOP: patrón proxy

• Se basa en la implementación de un interface por parte de dos clases, una de ellas

intercepta las peticiones de la segunda.
 AOP con Spring

• AOP utiliza un conjuntos de conceptos clave para crear

una arquitectura que permita utilizar esta tecnología.
Los conceptos clave son los siguientes:

• Advice, La acción realizada por un aspect.

• Joinpoint, Un punto determinado en la ejecución de
un programa, como la invocación de un método,
donde se ejecuta un advice.
• Pointcut, La especificación que coincide con un
joinpoint. Un advice se ejecuta en un joinpoint
que coincide con el pointcut.
• Weaving, es el proceso de combinar los aspects
con el resto de la aplicación.
 AOP con Spring

• Spring desde la versión 2.0 implementa AOP

de dos formas, utilizando annotations o
declaraciones XML.

• Podemos usar las annotations de @AspectJ,

que son parecidas al estilo seguido a partir del
utilizado en el JDK 5.

• AspectJ es un framework AOP open source

para usar con Java.

• Spring usa la librería CGILIB (cgilib- xxx.jar), para

la generación de proxies dinámicos. A partir de
la versión 3.2, esta librería no es una
dependencia necesaria.
 AOP con Spring: implementación

• Para trabajar con AOP en Spring es necesario, añadir el soporte para AOP en el archivo
de configuración, en primer lugar comprobaremos los esquemas:

aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

<aop:aspectj-autoproxy/>

• A continuación habilitamos AspectJ/AOP en el archivo de configuración:

• De esta forma, Spring comprueba, si el bean tiene declarado un Aspect,

y automáticamente genera un proxy dinámico para el.
 AOP con Spring: anotaciones

• Spring incluye un potente conjunto de anotaciones para trabajar con AOP aunque no usan
las características avanzadas de AspectJ, las anotaciones son:
Anotación Descripción
@Aspect Declares a class to be an aspect.
@After Declares a method to be called after a pointcut completes.
@AfterReturning Declares a method to be called after a pointcut returns successfully
@AfterThrowing Declares a method to be called after a pointcut throws an exception.
@Around Declares a method that will wrap the pointcut.
@Before Declares a method to be called before proceeding to the pointcut.
Declares that matching types should be given new parents—that is, it introduces new
@DeclareParents
functionality into matching types
@Pointcut Declares an empty method as a pointcut placeholder method.

EJB annotations @PostConstruct...

• Es posible crear una única clase, con múltiples interceptores.

 AOP con Spring: expresiones

• Para crear un aspect, comprobaremos la declaración de los esquemas y la declaración

que habilita AOP en el archivo de configuración.

• Declaramos el aspect con la anotación: @Aspect:

import org.aspectj.lang.annotation.Aspect;

@Aspect
public class SATSupport { //
@Pointcut("execution(* incidencia(..))") // Este pointcut define la
coincidencia con los
public void incidencia() { //metodos llamados incidencia*
}
}
 AOP con Spring: expresiones

• A continuación definimos el advice para el aspect anteriormente creado, usando una

etiqueta dependiendo del tipo de advice que deseamos usar como @Before:

@Aspect
public class SATSupport { // Declarada con @Aspect
@Pointcut("execution(* incidencia(..))")
public void incidencia() {
@Before("incidencia()")
public void setupLog() {
System.out.println(“Metodo incidencia ha sido invocado");
}
}

• El advice define que antes de invocar el método setupLog() se deberá invocar

incidencia().
 AOP con Spring: expresiones

• Las expresiones pointcut nos permiten definir máscaras que serán usadas para interceptar
aquellos métodos que coincidan con la expresión. La forma general de una expresión
pointcut es ésta:

execution( modifiers-pattern? ret-type-pattern

declaring-type-pattern?
name-pattern(param-pattern)
throws-pattern?)

• Los modificadores ret-type-pattern, name-pattern y param-pattern son obligatorios, el

resto es opcional. Podemos utilizar comodines como el símbolo «*».
 AOP con Spring: expresiones

• En la siguiente tabla se muestran algunos ejemplos de posibles expresiones

pointcut:

Expresión Descripción
execution(public * *(..)) Coincide con cualquier método public

public: el patrón modificador

primer *: el tipo de retorno puede ser cualquiera

segundo *: el nombre del método puede ser cualquiera

(..): coincide con cualquier número de parámetros (cero o más)

execution(* pruebas.Interface.*(..)) Coincide con cualquier modificador de acceso de método

primer *: el retorno de datos puede ser de cualquier tipo

pruebas.Interface.*: cualquier método del interface

(..): coincide con cualquier número de parámetros (cero o más)

 AOP con Spring: expresiones

• Podemos crear expresiones con los siguientes designadores:

Expresión Descripción

within(com.pruebasClase+) Cualquier objeto de tipo Clase, el uso de «- +» indica subclases

within(com.pruebas.*) Cualquier tipo dentro del paquete

witin(com.pruebas..*) Cualquier tipo dentro del paquete o subpaquete

target(com.pruebass.ClaseTarget) Cualquier tipo que sea el target no el proxy

args(String) Cualquier método con argumento de tipo String

args(*) Cualquier método con argumento de cualquier tipo

args(*, String) Cualquier método con un argumento de cualquier tipo y otro de tipo String
 AOP con Spring: forma declarativa

• Desde las primeras versiones de Spring y como forma más clásica, es posible aplicar AOP
de forma declarativa vía XML:

<bean id=“proxy" class="ejemplo.aop.LogBeforeAdvice" />

<!– Clase con la implementación -->
<bean id="adderImpl" class="ejemplo.aop.SumarImpl" />
<!– Clase con la implementación del proxy -->
<bean id="adder" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>ejemplo.aop.Sumar</value>
</property>
<property name="interceptorNames">
<list>
<value>before</value>
</list>
</property>
<property name="target"><ref bean="adderImpl"/></property>
</bean>
Desarrollo web MVC
y API REST
 Spring

• ¿Pero que características tiene el patrón

MVC, que se ha extendido tanto?

• La más importante: desacoplamiento, ya

que creamos tres elementos cada uno con
una responsabilidad diferente:

• La vista, el controlador y el modelo

• Reutilización, nos permite compartir código

en nuestra aplicación o crear librerías.

• Coordinación del flujo d e la a p l i c a c i ó n ,

como controlar las vistas, invocar
operaciones de negocio e interactuar con
el usuario.
 Spring

• Una aplicación web de Java, dispone de una

estructura muy concreta, y se detalla a
continuación:

• Carpeta opcional a nivel raíz como «/META-INF/».

• Archivo opcional:
• «/META-INF/context.xml»
• Carpeta obligatoria a nivel raíz como «/WEB-
Uso exclusivo del
INF»: contenedor
• Archivo obligatorio de despliegue
«/WEB-INF/web.xml»
• Opcional a partir de JavaEE6
• Carpeta obligatoria «/WEB-
INF/classes»
• Carpeta obligatoria «/WEB-INF/lib»
Spring

• El DispatcherServlet es el encargado de poner en marcha el motor de Spring, al capturar

una máscara definida en el archivo «/WEB-INF/web.xml»:

<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>*.htm</url-pattern>
</servlet-mapping>

• El elemento <url-pattern> define la máscara que usará Spring para aceptar la

petición dirigida al framework, que puede definirse como prefijo o sufijo.
 Spring MVC

• Spring MVC está desarrollado entorno al

RequestDispatcher, que dirige las peticiones usando
handlers mapping, es decir, una etiqueta está asociada
a una vista que conoce y gestiona un controlador.

• Los handlers mappings están basados en anotaciones,

así como la declaración de los controladores, con
estas anotaciones:

• @Controller
• @RequestMapping

• En el módulo MVC de Spring es posible utilizar cualquier

objeto como command o form-backing (POJO asociado
al formulario) sin necesidad de que implemente ningún
interface de Spring.
 Spring MVC: controladores

• Un ejemplo de controlador con un mapeo declarado sobre un método, se puede ver a

continuación:

@Controller
public class AsistenteController
{
@RequestMapping("/asistente")
public ModelAndView control() {
ModelAndView mav = new ModelAndView();
mav.setViewName("ejemplo");
mav.addObject("message", "Ejemplo de controlador");
return mav;
}
}

• Además existen otras anotaciones como @RequestParam, @ModelAttribute que son útiles
tanto para Servlets MVC o Portlets.
 Spring MVC: configuracion controladores

• Para conseguir que Spring realice una auto detección de las anotaciones en los
controladores, debemos indicarlo en el archivo de configuración:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package="org.pruebas.ejemplos.controladores"/>

</beans>
Front controller: DispatcherServlet
Por sufijo: http://dominio/index.htm
Por prefijo: http://dominio/spring/index.htm

DispatcherServlet
1
Petición

2
/WEB-INF/web.xml Modelo

Máscara: *.htm

3
/WEB-INF/xxx-servlet.xml
CTRL
¿A dónde se dirige la peticion?: index 4
ViewResolver prefix: /WEB-INF/jsp/ MVC
ViewResolver suffix: .jsp
 Spring MVC: controladores

• Podemos usar la anotación @RequestMapping para mapear URL’s contra una clase concreta o
contra un método determinado. además podemos definir el método HTTP necesario para invocar
el método:

@Controller
@RequestMapping("/cita")
public class CitaControlador {
private final CitaLibro citaLibro;
@Autowired
public CitaControlador(CitaLibro citaLibro)
{ this.citaLibro =citaLibro;
}
@RequestMapping(method = RequestMethod.GET)
public Map<String,Cita> get() {
returnCitaLibro.getCitaForToday();
}…
 REST

• La tecnología REST (Representation State Transfer), usa

como principal abstracción el concepto de recurso
declarado en la URI.

• Un recurso es un elemento de información que tiene

enlaces asociados. La URI representa un enlace a un
recurso. Cada recurso tiene un tipo de representación.

• Las representaciones de los recursos en la web vienen

determinados por los tipos MIME, de esta forma “text/html”
representa una página en lenguaje HTML, mientras que
“text/xml” representa un recurso en XML.

• La forma de cumplir este propósito es utilizando la API HTTP

y sus verbos o métodos, para satisfacer las peticiones
sobre los recursos o nombres que corresponden con la URI.
 REST: métodos HTTP

GET

POST
• El protocolo HTTP dispone de siete
métodos, que son utilizados por la PUT
tecnología de tipo REST y que
cada uno tiene un significado, en TRACE
la plataforma.
DELETE

HEAD

OPTIONS
 REST: verbos

• Los verbos HTTP corresponden con los métodos que tiene.

• Cada uno de ellos, tiene un significado y su correspondencia con las típicas operaciones
CRUD.

HTTP verbos Equivalencia con operaciones CRUD

POST Crea un nuevo recurso a partir de los datos de la petición
GET Lee un recurso
PUT Actualiza un recurso a partir de los datos de la petición
DELETE Elimina un recurso

HTTP verbos/URI Operación CRUD

POST clients Crea un nuevo cliente a partir de los datos de la petición
GET clients Obtiene una lectura de los empleados
GET clients?id=124 Lee los datos del empleado con ese id
DELETE clients?id=124 Elimina un empleado con ese id
REST: verbos
 REST: implementación

• La comunicación se establece de la forma habitual a través de las cabeceras de petición y

respuesta
del protocolo HTTP.
Petición GET /music/artists/magnum/recordings HTTP/1.1
Host: media.example.com
Accept: application/xml
Verbo Nombre

Respuesta HTTP/1.1 200 OK

Date: Tue, 08 May 2007 16:41:58 GMT
Server: Apache/1.3.6
Content-Type: application/xml; charset=UTF-8

<?xml version="1.0"?>
<recordings xmlns="…"> Representación en
<recording>…</recording> Tipo MIME
…
</recordings>
 REST: implementación

• La comunicación se establece de la forma habitual a través de las cabeceras de petición y

respuesta
del protocolo HTTP.
Identificado por la URL: http://www.biblio.com/lorca

Servidor Recurso: Biografía García Lorca

Peticiones HTTP Respuestas HTTP

GET: lectura MIME-TYPE: Representación del recurso
POST: Insertar GET: Página HTML con biografía Lorca
PUT: Actualizar GET: video de una obra suya
DELETE: Eliminar PUT: actualizar la biografía
POST: añadir nuevo contenido

Cliente REST
 Spring MVC: configuración

• La anotación @Configuration define a

nuestra clase como un estereotipo de
configuración e indica que se trata de una
clase contiene elementos que deben ser
construidos.

• La anotación @Bean, indica que el retorno

del método debe ser utilizado como factoría
para crear un bean.

• El nombre del bean se obtiene por defecto a

partir del nombre del método, y es que le
será asignado, cuando sea creado por la
factoría.

• Las clases de configuración pueden ser

abstractas, pero no pueden ser declaradas final.
 Spring MVC: anotaciones @Named, @Inject
• Las anotaciones representan la alternativa a los archivos XML

• Desde Spring 3.0, se da soporte a las anotaciones de JSR-330 (Dependency Injection for Java),
como por ejemplo @Named y @Inject.

• La inyección de anotaciones se procesa antes, por esta razón, prevalece, la configuración en XML,
que pueda existir en caso de conflicto con lo que definan las anotaciones.

• La configuración por anotaciones, se habilita de esta forma:

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd.”>
<context:annotation-config />
</beans>
 Spring MVC: anotaciones
• Podemos dividir las anotaciones en varias familias, las genéricas o core, las que se usan con
Spring MVC, las de seguridad, las core son:

Anotación Descripción

@Autowired Declares a constructor, field, setter method, or configuration method to be autowired

by type. Items annotated with @Autowired do not have to be public.

@Configurable Used with <context:springconfigured> to declare types whose properties should be

injected, even if they are not instantiated by Spring. Typically used to inject the
properties of domain objects

@Order Defines ordering, as an alternative to implementing the

org.springframework.core.Ordered interface.

@Qualifier Guides autowiring to be performed by means other than by type.

@Required Specifies that a particular property must be injected or else the configuration will fail.

@Scope Specifies the scope of a bean, either singleton, prototype, request, session, or some
custom scope.
 Spring MVC: anotaciones stereotype
• Estas anotaciones identifican el tipo de clase, si es un controlador, un servicio, se
diferencian semánticamente:

Anotación Descripción
@Component Generic stereotype annotation for any Spring-managed component

@Controller Stereotypes a component as a Spring MVC controller.

@Repository Stereotypes a component as a repository. Also indicates that SQLExceptions thrown from the
component’s methods should be translated into Spring DataAccessExceptions.
@Service Stereotypes a component as a service.
 Anotaciones usadas en Spring MVC
• Desde la versión 2.5 de Spring, aparecen las anotaciones para Spring MVC, que facilitan el
desarrollo, minimizando las necesidades de declaraciones en archivos XML. Estas anotaciones son:

Anotación Descripción
@Controller Stereotypes a component as a Spring MVC controller.

@InitBinder Annotates a method that customizes data binding.

When applied to a method, used to preload the model with the value returned from the
@ModelAttribute
method. When applied to a parameter, binds a model attribute to the parameter
@RequestMapping Maps a URL pattern and/or HTTP method to a method or controller type.

@RequestParam Binds a request parameter to a method parameter

@SessionAttributes Specifies that a model attribute should be stored in the session

@Transactional Declares transactional boundaries and rules on a bean and/or its methods

• La última anotación no pertenece a Spring MVC, aunque es muy utilizada en la capa de

servicio.
 Anotaciones usadas con Spring instrumentation
• Spring se ha integrado de una manera muy interesante con JMX, y dispone de anotaciones
específicas para trabajar con esta API, es necesario declarar su uso con “<context:mbean-
export/>”:

Anotación Descripción

Used on a setter or getter method to indicate that the bean’s property should
@ManagedAttribute be exposed as a MBean attribute.

@ManagedNotification Indicates a JMX notification emitted by a bean.

Indicates the JMX notifications emitted by a bean.

@ManagedNotifications

@ManagedOperation Specifies that a method should be exposed as a MBean operation.

@ManagedOperationParameter Used to provide a description for an operation parameter

@ManagedOperationParameters Provides descriptions for one or more operation parameters.

@ManagedResource Specifies that all instances of a class should be exposed a MBeans

 Spring AOP: anotaciones
• Spring incluye un potente conjunto de anotaciones para trabajar con AOP aunque no usan
las características avanzadas de AspectJ, las anotaciones son

Anotación Descripción

@Aspect Declares a class to be an aspect.

@After Declares a method to be called after a pointcut completes.

@AfterReturning Declares a method to be called after a pointcut returns successfully

@AfterThrowing Declares a method to be called after a pointcut throws an exception.

@Around Declares a method that will wrap the pointcut.

@Before Declares a method to be called before proceeding to the pointcut.

Declares that matching types should be given new parents—that is, it introduces new
@DeclareParents functionality into matching types

@Pointcut Declares an empty method as a pointcut placeholder method.

 Spring MVC: librería de anotaciones <form>
• Para obtener el máximo partido del enlazado de datos (data binding), será necesario utilizar la librería
de etiquetas form de Spring. Spring contiene dos librerías de etiquetas, form y spring.

• La primera nos facilita el desarrollo de páginas que contienen formularios, mientras que la segunda
es de carácter general.

• La librería form “arropa” los componentes html estándar, añadiéndoles más funcionalidad,
como campos de entrada o botones .

• Reduce el ciclo de desarrollo de este tipo de páginas

 Spring MVC: librería de anotaciones <form>
• Las etiquetas que están disponibles en la librería de etiquetas form
son:
Etiqueta Descripción
Renders an HTML form tag and exposes the binding path to the other form tags.
form
Renders an input element with the default type of text. The type of the input element can be
input can be (optionally) specified (like email, date etc.) .
Renders an input element of type password or hidden .
password - hidden
Renders an HTML select element. The option and/or options tag are used to specify the
select options to render.

option (s) Renders a single HTML option element inside a select element or inside a select element
Renders an HTML input element (or multiples) of the type radio button
radiobutton(s)
Renders an HTML input element (or multiples) of the type checkbox.
checkbox(es)
Renders an HTML Textarea element.
textarea
Displays binding and/or validation errors to the user. It can be used to either specify the
errors path for field-specific error messages or to specify an * to display all error messages.
Renders a HTML Label and associate it with an input element.
label
Renders an HTML Button element.
button
 Spring MVC: librería de anotaciones <form>
• Cada etiqueta dispone a su vez, de atributos propios que permiten personalizar su funcionamiento.
Un ejemplo de formulario, se muestra a continuación:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<form:form method="GET" modelAttribute=“busquedaLibros">
<fieldset>
<table>
<tr>
<td><form:label path="title">Titulo</form:label></td>
<td><form:input path="title" /></td>
</tr>
</table>
</fieldset>
<button id="search">Buscar</button>
</form:form>
 Spring MVC: librería de anotaciones <form>
• Cada etiqueta dispone a su vez, de atributos propios que permiten personalizar su funcionamiento.
Un ejemplo de formulario, se muestra a continuación:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<form:form method="GET" modelAttribute=“busquedaLibros">
<fieldset>
<table>
<tr>
<td><form:label path="title">Titulo</form:label></td>
<td><form:input path="title" /></td>
</tr>
</table>
</fieldset>
<button id="search">Buscar</button>
</form:form>
 Spring MVC: librería de anotaciones <spring>
• Las etiquetas que podemos utilizar y que están disponibles en la librería de etiquetas spring
son:
Etiqueta Descripción
Sets the default HTML escape value for the current page. If set, this tag overrides the value set in the
htmlEscape defaultHtmlEscape context-parameter.

escapeBody Escapes the enclosed body.

message Displays a message with the given code and for the selected locale.

theme Uses the variable from the currently selected theme.

hasBindErrors Shows or hides part of the page (or element) based on whether an model attribute has bind errors.
Selects a nested path to be used by the bind tag’s path. For example, it can be used to bind
nestedPath customer.address to street instead of to customer.address.street.

bind Binds an attribute of the model (attribute) to the enclosed input element.

transform Transforms the bound attribute using Spring’s type-conversion system.

url Similar to the jstl core URL tag. It is enhanced so the URL can contain URL template

param Specifies a parameter and value to be assigned to the URL.

eval Evaluates a SpEL expression and prints the result or assigns it to a variable.
 Spring MVC: soporte para HTML5
• Desde la versión 3.1 de Spring se proporciona soporte para la introducción de atributos dinámicos,
de esta forma podemos especificar atributos de HTML5.

• La etiqueta input soporta otras definiciones para el atributo type además del valor “text”, como
email, range, date y otros.
 Renderizado y conversión de datos

• Cuando se trabaja con el enlazado de datos (data

binding) es importante la conversión de datos, ya
que cuando recibimos una petición los datos son
todos de tipo String.

• En una aplicación, es necesario convertir esta

información que recibimos en los tipos de
datos adecuados.

• Con Spring MVC, podemos llevar a cabo

estas conversiones de tres formas
diferentes:

• Conversores
• Formateadores
• Editores de propiedades
 Renderizado y conversión de datos

• Los editores de propiedades son clásicos en Spring para llevar a cabo las
conversiones.

• Sin embargo, los conversores y formateadores son más flexibles y potentes.

Editor de Propiedades Editor de Propiedades
ByteArrayPropertyEditor CharsetEditor
ClassEditor ClassArrayEditor
CurrencyEditor CustomBooleanEditor
CustomCollectionEditor CustomMapEditor
CustomDateEditor CustomNumberEditor
FileEditor InputStreamEditor
LocaleEditor PatternEditor
PropertiesEditor StringTrimmerEditor
TimeZoneEditor URIEditor
URLEditor
 Editores de propiedades: implementación

• Los editores de propiedades son clásicos en Spring para llevar a cabo las
conversiones.

• Sin embargo, los conversores y formateadores son más flexibles y potentes.

public class Ejemplos {

public void setFecha(Date d);
public Date getFecha();
}
public void metodo1{
SimpleDateFormat d = new SimpleDateFormat("dd-MM-yyyy");
CustomDateEditor e = new CustomDateEditor(d, false);
Ejemplos m = new Ejemplos();
BeanWrapper bw = new BeanWrapper(m);
bw.registerCustomEditor(e);
bw.setPropertyValue("Nacimiento", "12-12-1985");
}
 Conversores

• Los conversores aparecen en la versión 3 de

Spring, y son una alternativa a los editores de
propiedades.

• Disponemos de cuatro interfaces para

implementar un conversores, estos son:

• ConverterFactory
• Converter
• GenericConverter
• ConditionalGenericConverter

• El interface Converter es sumamente simple y

dispone de un único método, donde aparecen
los argumentos definen el fuente (S) y el
objetivo (T).
 Conversores: implementacion y uso

• Spring dispone de implementación más potentes que permiten realizar conversiones más
especializadas, como las del interface ConversionService.
•

Un ejemplo:

private static void convertirAArray(GenericConversionService conversionService){

String[] stringArray =
conversionService.convert("Enero,Febrero,Marzo",String[].class);
for (String element : stringArray){
System.out.println("Mes: " + element);
}
}
 Formateadores

• Los formateadores de Spring son una API de propósito general, y pueden convertir de un tipo a otro
de objeto, aplicando incluso internacionalización.

• La API dispone del interface Formateer, a partir del cual incluso podemos crear nuestros
formateadores personalizados.

private String format;

@Override
public String print(Date object, Locale locale)
{ return getDateFormat(locale).format(object);
}
@Override
public Date parse(String text, Locale locale) throws ParseException
{ return getDateFormat(locale).parse(text);
}
 Enlazado de datos (data binding)

• Spring incorpora mecanismos de conversión para “enlazar” datos entre las propiedades de un bean
y por ejemplo los campos de un formulario, pero además, se usa en la inyección de dependencia.

• Por ejemplo:

public class Pelicula {

String nombre;
int precio;
}

<bean id="movie" class="com.pruebas.Pelicula">

<property name="nombre" value="Doce en el patibulo"/>
<property name="precio" value="18"/>
</bean>
 Enlazado de datos (data binding) con Spring MVC

• Otro caso donde se usa la conversión de datos es, cuando se reciben datos en parámetros HTTP,
que normalmente son asociados a un objeto Model, al cual son convertidos:

@RequestMapping("/pelicula/nuevo", method=RequestMethod.POST)
public String crear(@ModelAttribute Pelicula movie,
BindingResult results)
{ this.movieService.create(movie);
status.setComplete();
return "redirect:/peliculas";
}

• En estos casos los valores de tipo String son convertidos al del objeto definido como
argumento.
 Validación de datos: JSR303

public class Cliente

{ private String
nombre; private int
• Desde la versión 3 de Spring s e i n tr o d u ce el
soporte para la API de validación JSR-303, si la } edad;
usamos en el código la clase DataBinder de Spring.
public class ClienteForm {
• Podemos usar una validación declarativa que @NotNull
es aplicada en tiempo de ejecución. @Max(55)
private String nombre;
@Min(18)
private int edad;
}
 Validación de datos: JSR303

• Para poder aplicación la validación de la API JSR-303, debemos configurarlo en los archivos XML, con
la siguiente declaración:

<bean id="validator"
class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean" />

• Esto inicializa la API a sus valores por defecto, a continuación se espera que esté instalado un
proveedor JSR303 como Hibernate en el classpath, el cual será detectado automáticamente. También
podemos inyectar un validador así:

@Service
public class EjemploValidador {
@Autowired
private Validator validator;
}
 Spring MVC: internacionalización de las vistas

• Spring trabaja la internacionalización, utilizando en el interface MessageSource y LocaleResolver, que

le ayudan en el proceso de resolución de las etiquetas basándose en las claves y en el Locale.

• Existen dos implementaciones de MessageSource, estas son:

Implementación Descripción
Uses the ResourceBundle facility available on the JVM. It
can only load resources from the classpath.
ResourceBundleMessageSource

Works in a similar way as the

ResourceBundleMessageSource but adds reloading and
caching capabilities. It allows for the resources to be
ReloadableResourceBundleMessageSource anywhere on the file system it uses the resource loading
mechanism in Spring.
 Spring MVC: internacionalización de las vistas

• La internacionalización está basada en archivos de tipo properties, que incluyen las claves de
las etiquetas i18n de la capa de presentación.

Configuración i18n
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = { "com.pruebas.web" })
public class PruebasWebConfiguration extends WebMvcConfigurerAdapter {
@Bean
public MessageSource messageSource()
{ ReloadableResourceBundleMessageSource messageSource;
messageSource = new ReloadableResourceBundleMessageSource();
messageSource.setBasename("classpath:/traducciones");
messageSource.setUseCodeAsDefaultMessage(true);
return messageSource;
}
}
 Spring MVC: internacionalización de las vistas

• Para que este mecanismo de i18n, realice su trabajo correctamente es necesario configurar el
interface LocaleResolver, el cual dispone de varias implementaciones que se ajustan a las
necesidades de diferentes tipos de aplicación.

Implementación Descripción
Always resolves to a fixed locale. All the users of our website use the same
FixedLocaleResolver locale, so changing the locale isn’t supported.
Resolves (and stores) the locale in the user’s HttpSession. The attribute used
to store the locale can be configured, as well as the default locale to use if no
SessionLocaleResolver locale is present. The drawback to this is that the locale isn’t stored between
visits, so it must be set at least once on the user’s session.
Uses the http accept header to resolve the locale to use. In general, this is the
locale of the operating system of the user, so changing the locale isn’t
AcceptHeaderLocaleResolver
supported. It is also the default LocalResolver used by the DispatcherServlet.
Uses a cookie to store the user’s locale. The advantage of this resolver is
that the locale is kept on the client’s machine, so it will be available on
CookieLocaleResolver
subsequent visits to the website
Persitencia con
Spring Data
 Spring data

• Spring data utiliza el mdulo ORM (Object Relational Mapping)

• En esencia una herramienta ORM permite transformar una

representación de objetos en una representación relacional
y también en sentido inverso.

• Una herramienta ORM está compuesta por los siguientes

elementos:

• Una API que permite realizar las operaciones CRUD sobre

los objetos de la aplicación.
• Un mecanismo para realizar el mapping entre tablas y objetos.
• Una tecnología transaccional para realizar tareas de
carga dinámica, perezosa, de asociación sobre objetos y
tablas.
 Spring data

• La gestión de excepciones por parte de Spring es más

sencilla, ya que todas son encapsuladas en tipo
RuntimeException, nosotros somos los responsables
de decidir que excepciones necesitamos capturar.

• Spring contiene un notable conjunto de DAO’s que se

encargan de controlar y gestionar los detalles del
acceso a datos usando o no una capa de persistencia
como Hibernate o simple JDBC.

• La API de Spring para trabajar con bases de datos

está concentrada básicamente en dos paquetes:

• org.springframework.jdbc

• org.springframework.dao
 Spring data: módulo jdbc/dao

• La API de Spring para trabajar con bases de datos consta de los siguientes paquetes
importantes:

Package Descripción
org.springframework.jdbc Define las clases básicas, como excepciones para trabajar con BBDD
org.springframework.jdbc.core Contiene las clases fundamentales como JdbcTemplate para acceso a datos
org.springframework.jdbc.core.simple Contiene versiones simplificadas de JdbcTemplate para trabajar con JDK5
org.springframework.jdbc.datasource Proporciona soporte para trabajar con datasources
org.springframework.jdbc.support Contiene clases de soporte simplificado como JdbcDaoSupport
org.springframework.dao Define una jerarquía sofisticada de excepciones sobre las de JDBC
org.springframework.dao.support Clases de soporte para trabajar con DAO

• Spring encapsula las excepciones JDBC/ORM a tipo RuntimeException, de esta forma, no son
necesarias capturarlas todas, pero si decidir cuales serán gestionadas.
 Spring data: templates

• Spring contiene un conjunto de clases XXXTemplate,

para la mayoría de soluciones estables de acceso
a datos, como por ejemplo:

• JdbcTemplate
• HibernateTemplate
• JdoTemplate…

• Las clases Template son las clases centrales en

el package core de Spring para acceso a datos
como JdbcTemplate.

• Necesitan la inyección de una referencia de

tipo DataSource, para gestionar las
conexiones y excepciones JDBC.
 Spring data: templates

• También es posible optar por usar las Templates de Spring en lugar de las clases XXXDaoSupport.

• Para realizar esta configuración, escribiremos la siguiente declaración:

public class JdbcEmpleadoDAO implements EmpleadoDAO {

private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate JdbcTemplate templateIn) {
this.jdbcTemplate = templateIn;
}
}

//Declaración en el archivo de configuración XML

<bean id="jdbcTemplate“ class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg ref="personalDataSource "/>
</bean>
<bean id="empleadoDAO" class="com.pruebas.JdbcEmpleadoDAO">
<property name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>
 Spring data: templates

• Spring contiene un conjunto de clases DaoSupport,

para la mayoría de soluciones estables de acceso
a datos, como por ejemplo:

• JdbcDaoSupport
• HibernateDaoSupport
• JdoDaoSupport…

• Contiene métodos get/set para la inyección de

un java.sql.DataSource o XADataSource desde
un archivo de configuración.

• Simplifican radicalmente el uso de la tecnología

de acceso a datos seleccionada.
 Spring data: implementacion JDBC

• Para utilizar Spring con JDBC, lo primero que es necesario hacer es configurar el acceso a la BBDD
en el archivo de configuración XML.

<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"
p:driverClassName="com.mysql.jdbc.Driver"
p:url="jdbc:mysql://localhost:3306/test"
p:username="root"
p:password="password"/>

<bean id="clienteDao" class="com.gc.modelos.ClienteDaoJdbc">

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

• En este mismo archivo podemos declarar un bean que hereda de JdbcDaoSupport y al que
le inyectamos una propiedad «dataSource».

• Es una premisa que la propiedad reciba este nombre.

 Spring data: implementacion JDBC vía JNDI

• Para utilizar Spring con JDBC, usando un pool de conexiones que ha sido configurado en
JNDI, podemos hacer uso de el con esta configuración:

<?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:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee.xsd">
<jee:jndi-lookup id="oracle11DataSource" jndi-name="/jdbc/oracleDS" resource-ref="true">
</beans>

• Es necesario añadir los esquemas resaltados en la imagen.

 Spring data: configuracion JPA

• JPA utiliza un archivo XML para su configuracin, aunque es posible hacerlo por cdigo.

• El archivo «persistence.xml» contiene el elemento <persistence-unit> con una cadena de

caracteres que identifica un DataSource, como subelementos puede contener los siguientes:

Sublementos

description

provider

properties

jta-data-source o non-jta-data-source

class, jar-file, mapping-file

exclude-unlisted-classes

shared-cache-mode

validation-mode
 Spring data: configuracion JPA

• En el archivo «persistence.xml» se define la configuración de acceso a la BBDD o la etiqueta JNDI

así como propiedades del persistence provider usado:

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">

<persistence-unit name="web-jpaPU" transaction-type="JTA">

<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
<jta-data-source>jdbc/mysql_desarrollo</jta-data-source>
<properties>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables"/>
</properties>
</persistence-unit>

</persistence>
 Spring data: implementacion JPA

• El interface EntityManagerFactory podemos compararlo con el interface SessionFactory de

Hibernate
y debe ser tratado de la misma forma.

• Por su parte la clase EntityManager se obtiene a partir de la factoría y es parecida a la clase Session
de Hibernate, cada instancia representa una conexión con la BBDD.

• Los métodos de la clase EntityManager son:

Operación CRUD Mètodo EntityManager

Insertar persist(entidad)

Recuperar find(entidad, primary key)

Actualizar No es necesario, es automático en las entidades

Eliminar remove(entidad)
 Spring data: implementacion JPA

• Podemos crear una instancia de la clase EntityManager de varias formas, por ejemplo, usando
un POJO o un EJB.

public class Client eJPA{

private static EntityManagerFactory emf; POJO creando

private static EntityManager em; un objeto
EntityManager
public static void main(String[] args) {
emf = Persistence.createEntityManagerFactory("pu1");

…………………………………………………………………………………………
@Stateless
public class EjemploServiceBean implements EjemploService
{ @PersistenceContext(unitName="EmpleadoService")
EntityManager em; EJB 3 creando
un objeto
public void ainsertarEmpleado(int empId, int proyectoId) EntityManager
{ Proyecto proyecto = em.find(Proyecto.class, proyectoId); por inyección
Empleado empleado = em.find(Empleado.class, empId);
de dependencia
 JPA: operaciones

• Las operaciones más importantes, que podemos realizar sobre la entidad(es) con las que
trabajamos son las siguientes:

Método usado Descripción

persist Convierte una entidad en Managed y la hace persistente

flush Fuerza la sincronización de la BBDD con los entidades del PersistentContext

refresh Refresca las instancias de entidad en el PersistentContext contra la BBDD

find Busca una entidad ejecutando una consulta por PK sobre la BBDD

contains Devuelve true si la entidad está en el PersistentContext

merge Consolida el estado de la entidad actual contra el PersistentContext

remove Elimina la instancia de la entidad

• Todas ellas influyen sobre el PersistentContext y tienen un impacto importante sobre el estado de
la instancia con la que trabajamos.
 Otros persistence providers: Eclipselink

• EclipseLink ORM, forma parte de un proyecto

de arquitectura de capa de acceso a datos
más ambicioso de Eclipse, denominado
Persistence Services Project.

• Está basado en TopLink de Oracle.

• EclipseLink ORM, proporciona una capa extensible

ORM (Object- Relational Model) con soporte e
implementación de JPA. Proporciona la posibilidad
de interactuar con un amplio abanico de fuentes de
datos.

• Hibernate es probablemente el persistence

provider ms popular y con ms experiencia
actualmente en el mercado.
 JPA: mapeo de entidades

• Un ejemplo de una clase de entidad, declarada

utilizando annotations, se muestra a
continuación: import javax.persistence.*;
• La anotación @Table puede ser redundante, si
la clase tiene el mismo nombre que la tabla, @Entity
aunque siempre es recomendable colocarla. @Table(name = "CLIENTE")
public class Cliente {
• Son estrictamente necesarias las @Id
anotaciones: @Column(name = "ID")
private String id;
• @Entity @Column(name = "Nombre")
• @Id private String nombre;
}
• El resto son opcionales y deben ser usadas …
cuando los valores por omisión no se cumplen,
como el nombre de la tabla no coincide con el de
la entidad.
 JPA: mapeo de entidades

• Podemos usar el plugin JBoss Tools

@Entity
de Eclipse para hacer ingeniería
@Table(name = "clientes", catalog = "test")
inversa de las tablas del esquema de
public class Clientes implements java.io.Serializable
BBDD y generar automáticamente { private Integer idcliente;
las entidades. private String nombre;
private String apellido;
• No es necesario escribir una línea
de código. @Id
@GeneratedValue(strategy = IDENTITY)
• El mapeo podemos decidir hacerlo @Column(name = "idcliente", unique = true, nullable =
con anotaciones o XML, incluso false)

es posible generar los DAO’s de public Integer getIdcliente()

{ return this.idcliente;
la misma forma.
}…
 JPA: pool de conexiones
• En las aplicaciones de producción se usan los pooling de conexiones, que sirven para
agrupar conexiones y evitan los frecuentes tiempos de conexión y desconexión.

• En su lugar se configura un pool de conexiones que están abiertas y que una vez ha utilizado la
aplicación, se devuelven al pool sin necesidad de cerrarlas físicamente, de esta forma se
incrementa sustancialmente el rendimiento.

Thread 1
Thread 2
Thread 3
Pooling 1
Thread 4
Thread 5
Thread 6
Thread 7
Thread n…
JPA: el objeto EntityManager
• Internamente consta de una caché de primer nivel o L1 a la que puede añadirse otra de segundo
nivel o L2.

JPA

Entity Caché
Aplicación Primer nivel
Manager

Caché
Segundo nivel
opcional
 JPA: ciclo de vida de una entidad
• Estados por los que pasa una entidad usada en JPA.
merge
persist
remove

Managed

persist
merge

final de transacción
Serialización o
persist
Removed

merge
New
remove

merge
remove

Detached remove
Fails
 JPA: ciclo de vida de una entidad
• Los cambios de estado de la entidad según la operación que se realiza sobre ella, son los
siguientes:
Estado antiguo Operación realizada Estado actual
No existe aún Creamos una nueva instancia con el operador new New

New Usamos el método persist sobre la entidad Managed

Managed Usamos el método remove sobre la entidad Removed

El PersistenceContext ha finalizado.
Managed Las instancias generadas por la serialización o cloneado de Detached
instancias Managed son siempre de tipo Detached
Removed Usamos el método persist sobre la entidad Managed

Removed Eliminamos la referencia de la instancia eliminada No existe

• Los estados que va adquiriendo la instancia al ser afectada por cada operación tiene un
impacto importante sobre el código que escribimos.
 Hibernate: ciclo de vida de una entidad
• Estados por los que pasa una entidad usada en Hibernate.

flush
get
find
load Persistent
persist
saveOrUpdate
save

close
update clear
new Transient lock evist
saveOrUpdate delete
replicate
merge

Detached
JpaRepository

• JpaRepository es una extensión

específica de JPA (API de persistencia
de Java) Repository.

• Contiene la API completa de

CrudRepository y
PagingAndSortingRepository .

• Por lo tanto, contiene API para

operaciones CRUD básicas y también
API para paginación y clasificación.
JpaRepository
JQL y HQL

• Hibernate dispone de su propio lenguaje de consulta que se comporta como una capa más
de aislamiento. En este caso, quiere aislarse de las implementaciones propias que cada motor de
base de datos hace del estándar SQL-92.

• JPQL/HQL es un lenguaje de consulta orientado a objetos, al igual que SQL es case-insensitive,

excepto al hacer referencia a un objeto Java. La sentencia JPQL/HQL más simple podría ser esta:

from usr.Usuario
from Usuario

• Esta sentencia, devolverá todas las instancias de la clase Usuario, podemos calificarla o no,
es opcional.
JQL y HQL

• Podemos hacer referencia a más de una clase, creando una unión cartesiana,
como:

from usr.Usuario, Pedido

from Usuario as usr, Pedido as pd

• Se considera una best-practices, hacer referencia al alias de la clase.

• Podemos crear uniones de varios tipos usando las clausulas de tipo

join:
from Usuario as usr
join usr.edad as edad
left join usr.nif as nif
JQL y HQL

• El uso de la clausula Select permite recuperar propiedades de los objetos

consultados:

Select nombre, nif

from Usuario usr
where usr.idusuario = 123

• Un Select puede devolver múltiples objetos y/o propiedades en un array de tipo

Object[ ]:

select mother, offspr, mate.name

from DomesticCat as mother
inner join mother.mate as mate
left outer join mother.kittens as offspr
JQL y HQL

• Podemos hacer uso de las funciones de agregación

como:
avg(…) sum(…) min(…)
max(…) count(*) count(…)
count(distinc count(all…)
t…)

select avg(cat.weight), sum(cat.weight), max(cat.weight),

count(cat)
from Cat cat

• Además podemos utilizar los operadores convencionales de SQL en las

consultas:
select firstName||' '||initial||' '||upper(lastName) from Person
select distinct cat.name from Cat cat
select count(distinct cat.name), count(cat) from Cat cat
JQL y HQL

• Al igual que en SQL, podemos realizar agrupaciones y establecer criterios de ordenación

con la clausula group by y order by:

select cat.color, sum(cat.weight), count(cat)

from Cat cat
group by cat.color

from DomesticCat cat

order by cat.name asc, cat.weight desc, cat.birthdate

• Para realizar una consulta que contenga a otra (subquery) en JPQL/HQL, podemos
escribirla así:
from Cat as fatcat
where fatcat.weight > (
select avg(cat.weight )
from DomesticCat cat )
JQL y HQL

• Hibernate/JPA da soporte a un conjunto de operaciones para que puedan ser realizadas con
el atributo cascade, como por ejemplo:

create merge delete

save-update evict replicate

lock reverse

• Podemos propagar una de estas tareas entre una instancia y todas sus relaciones hijo,
definiendo en el archivo de mapping o usando anotaciones.
JQL y HQL

• Los valores que podemos otorgar al atributo cascade, para que Hibernate/JPA sepa
como tratar la entidad relacionada en una operación que afecte a su persistencia, son
los siguientes:

Atributo Descripción

none Es el valor por defecto de Hibernate, no tiene en consideración relaciones

Hibernate navega en la asociación/relación y guarda actualiza las instancias en

save-update
transient

delete Borra las instancias de la asociación/relación en cascada

all Sirve para indicar la suma de los atributos delete y save-update

Igual al atributo «all» pero añade el borrado de una entidad que ha sido borrada
all-delete-orphan
de la asociación

delete-orphan Hibernate borra cualquier entidad que ha sido borrada de la asociación

JPA: mapeo de relaciones entre entidades
• En el mapeo de las entidades se concentra la información que usa JPA para conocer detalles de
cada objeto Java y su correspondencia con la tabla de la BBDD, como por ejemplo:

idCliente nombre idEmail direccion idCliente

1 Ana 1 [email protected] 1
2 Luis 2 [email protected] 1
3 [email protected] 2
JPA: mapeo de relaciones entre entidades

• Al modelar asociaciones o cardinalidad con JPA,

debemos conocer los tipos soportados por el
framework:

• One-to-one
• One-to-many
• Many-to-one
• Many-to-many

• Estas asociaciones pueden declararse de

dos formas diferentes, usando el archivo
XML(orm.xml) de configuración de mapping o
usando las anotaciones.
Relaciones JPA: one-to-one
• Ejemplo de mapeo de una relacion One-to-one usando anotaciones.

• La asociación One-to-one puede mantener la relación en la propia tabla, ya que cada registro sólo
está asociado/relacionado con un único registro.
Transacciones

• Una transacción es una unidad de trabajo y que se comporta como si tuviéramos un uso
exclusivo de la base de datos. Por esta razón, el modelo transaccional que implementemos
en nuestra aplicación es de extrema importancia, decidirá realmente su rendimiento general.
Hibernate cumple con lo que se denomina el modelo ACID, que consta:

• Atomicity, sigue la regla de todo se lleva a cabo o nada se hace.

• Consistency, sólo los datos válidos son escritos en la BBDD, si por alguna razón la operación no se puede completar

se deshace a su estado inicial.

• Isolation, cada transacción se lleva a cabo en un thread separado.

• Durability, Una operación con éxito queda escrita en la BBDD de forma persistente.
Transacciones

• Podemos mostrar el ciclo de vida de una transacción en un diagrama de estados UML, con
los posibles estados:

• Como unidad atómica, el resultado debe ser consistente y sino tiene éxito las cosas
deben quedar como estaban antes de iniciar la transacción.
Transacciones

• Atributos transaccionales CMT.

Spring REST
Web Services
 Spring web services

• Los servicios REST son un método de

comunicación entre dos aplicaciones.

• Una aplicación de cliente web o una aplicación móvil

puede invocar lógica de negocio a un serrvidor
backend utilizando peticiones REST, pero incluso los
servicios backend pueden comunicarse mediante
llamadas de servicio web REST.
 Spring REST services: consideraciones de implementación
• Si la acción del controlador tarda mucho en completarse, la invocacion al endpoint HTTP podra causar un
timeout y cortar la comunicacion.

• El envío de una gran cantidad de datos en una llamada (a través de la solicitud HTTP) puede provocar el corte
de la comunicación.

• Demasiadas llamadas simultáneas a un endpoint podrían aplicar demasiada “presión” sobre la aplicación
y provocar que falle.

• La red admite las peticionesHTTP y la red nunca es 100% fiable. Siempre existe la posibilidad de que
una invocacion a un endpoint REST falle debido a la red.
 Spring REST services: implementación
En este ejemplo anotamos la clase del controlador con la anotacion @Controller. De esta forma, una
instancia de la clase se convierte en un bean en el contexto de Spring (igual que en Spring MVC) y asi
sabe que este es un controlador que asigna sus métodos a rutas HTTP específicas REST.

La anotación @GetMapping sirve para especificar la ruta de la acción y el método HTTP.

La anotación @ResponseBody le dice al DispatcherServlet que la acción del controlador no devuelve

un nombre de vista y en su lugar los datos son enviados directamente en la respuesta HTTP.
 Spring REST services: implementación
• Una buena prctica es evitar codigo duplicado, como la anotacion @ResponseBody para cada
método. Para ello usamosla anotación @RestController, podemos considerarla como una
combinación de @Controller y @ResponseBody.

• @RestController le indica a Spring que todos los controladores son endpoints REST.
 Retorno de objetos desde el controlador
• Spring crea una representación de cadena del objeto y lo formatea como JSON.

• La notación de objetos JavaScript (JSON) es una forma sencilla de formatear cadenas como
parejas
atributo-valor.
 Retorno de una lista de objetos
• El controlador nos permite devolve una lista de objetos, simplemente cambiando el tipo de
retorno de datos por una collection generica.
 Recuperar datos del cliente usando @RequestBody
• Los web services de Spring se apoyan en los mismos mecanismos del módulo MVC, por ello,
podemos utilizar las mismas anotaciones para llevar a cabo acciones similares como la
obtención de datos enviados en la petición del cliente.
Invocando un web service endpoint
Invocando un web service endpoint
Invocando un web service endpoint: implementacion
 Retorno usando status code
• Normalmente al generar una respuesta en un tipo de formato MIME, debemos aconpañarla con
un
status code de la familia 100-500, para ello, usamos la clase ResponseEntity.

Respuesta JSON Status code

 Gestión de excepciones

• La gestión de
excepciones en un
web service es
responsabilidad del
controlador y para
capturar resolver la
excepción ussaremos
un código como el
propuesto a la
derecha.
 Una pestaña por URL REST
Postman app: Metodo HTTP
peticion web
www.getpostman.com/downloads

Pestañas para agregar parametros,

etc., a la peticion REST
Boton para enviar
la peticion REST
Spring boot
 Spring boot

• Spring Boot simplifica el desarrollo porque

facilita la creación de aplicaciones Spring
ejecutables.

• Es posible crear aplicaciones independientes

con un servidor integrado como Tomcat de
forma predeterminada, o Netty. Jetty, Undertow
si está utilizando los nuevos módulos reactivos
de Spring.

• Una de las características más importantes de

Spring Boot es el runtime opinionated, que le
ayuda a seguir las best practices y asi poder
crear aplicaciones Spring robustas, extensibles
y escalables.

• Sin necesidad de generar código o requisitos

de configuración XML.
 Spring boot CLI
• Spring Boot CLI (interfaz de línea de comandos)
es una de las muchas formas de crear
aplicaciones Spring, aunque este enfoque se
utiliza normalmente para aplicaciones prototipo
(POC).

• Spring Boot CLI inspecciona el código y, según las

anotaciones de Spring MVC (@RestController y
@GetMapping), intenta ejecutar su código como
una aplicación web utilizando un servidor Tomcat
incorporado y ejecuta la aplicación web desde
dentro.

• Groovy proporciona una manera fácil de

interceptar declaraciones y crear código on the fly.
Spring Boot CLI descubre la aplicación e inyecta
las piezas que faltan para tener una aplicación
web Spring completa.
 Spring boot CLI
• Spring Boot utiliza una anotación
@SpringBootApplication utilizando el método
main(), que ejecuta la aplicación.

• El metodo run() de SpringApplication acepta

dos parámetros. El primer parámetro es la
clase con
la configuración principal que contiene la
anotación Podemos ejecutarlo con: spring run EjemploWebApp.java
@Configuration (que resulta ser el mismo nombre
• El
desegundo
la clase).parámetro corresponde con los argumentos de la aplicación, en
este ejemplo, estamos usando las anotaciones de Spring MVC:

• @RestController
• @GetMapping.
Spring boot CLI: autoconfiguracion

• La configuración automática es
una de las características mas
importantes de Spring Boot porque
permite crear una aplicación Spring
Boot de acuerdo con su classpath,
anotaciones y cualquier otro tipo
de configuracion basada en
anotaciones o declaraciones de
configuración, como clases
JavaConfig o XML.
 Spring boot CLI: autoconfiguracion

• La anotacion @SpringBootApplication anotación,

que es uno de los componentes principales de
una aplicación Spring Boot.

• Equivale a declarar las anotaciones:

• @Configuration
• @ComponentScan
• @EnableAutoConfiguration.

• Además podemos deshabilitar una

configuración automática concreta agregando
el parámetro exclude de la anotacion:

• @EnableAutoConfiguration
@SpringBootApplication.
Spring boot MVC: autoconfiguracion

• Las aplicaciones Spring MVC pueden

usar Spring boot agregando la
dependencia al pom.xml:

• spring-boot-starter-web

• Esto significa que Spring Boot usa el poder

de Spring MVC y proporciona toda la
configuración automática necesaria para
crear una aplicacion web, configurando
elementos como el DispatcherServlet, con
valores predeterminados, configurando
tambien un servidor Tomcat.
Spring boot: componentes
Spring boot: implementación

• Las aplicaciones Spring boot deben invocar

el método run() de la clase SpringApplication.

• La etiqueta @Configuration, indica que la

clase en la que se encuentra contiene la
configuración principal del proyecto.

• La anotación @EnableAutoConfiguration indica

que se aplicará la configuración automática
del starter que hemos utilizado. Solo debe
añadirse en un sitio, y es muy frecuente
situarla en la clase main.

• En tercer lugar, la etiqueta @ComponentScan,

ayuda a localizar clases etiquetadas con
otras anotaciones cuando sean necesarios.
Spring boot: implementación

• Para no llenar nuestra clase de anotaciones,

podemos sustituir las etiquetas:

• @Configuration
• @EnableAutoConfiguration
• @ComponentScan

• Po la anotacion @SpringBootApplication,
que sustituye al resto.
 Spring boot: starters
• Spring Boot proporciona una serie de iniciadores
que nos permiten agregar jar en la ruta de clases.

• Los starters (arrancadores) incorporados Spring

Boot hacen que el desarrollo sea más fácil y
rápido. Spring Boot Starters son los descriptores
de dependencia .

• En Spring Boot Framework, todos los iniciadores

siguen un patrón de nomenclatura similar:
spring-boot-starter- * , donde * denota un tipo
particular de aplicación.

• Por ejemplo, si queremos usar Spring y JPA para

el acceso a la base de datos, necesitamos incluir
la dependencia spring-boot-starter-data-jpa
en nuestro archivo pom.xml del proyecto.
Spring boot: starters
 Spring
Security
 Spring security

• Librería de seguridad aportada por Acegi

Security, desde el año 2007 se convierte
en Spring Security. Permite incorporar
mecanismos de autenticación de varios
tipos, como:

• HTTP Basic, Digets, Form y con

certificados X.509
• Integración con los contenedores web y
ejb
• Usando LDAP o API’s como JAAS.

• Se proporciona seguridad en varios

niveles: peticiones web, invocaciones de
beans y acceso a objetos del dominio.
 Características Spring security

Las características más importantes

de Spring son:

• Actualización a Java JDK 11.

•
Modelo de programación reactiva, es
totalmente asincrónico y no bloqueante.
•
Programación con anotaciones.
•
Nuevo enfoque de programación funcional.
•
Soporte para HTTP/2.
•
Soporte para Kotlin y Spring WebFlux.
•
Compatibilidad con lambdas para el registro
de beans.
•
Soporte Spring WebMVC para las últimas API.
•
Prueba de integración con Spring WebFlux.
•
Actualizaciones generales del núcleo y
del contenedor de Spring.
•
Proteccion CRSF.
 Arquitectura Spring security

Las características más importantes de Spring son:

• Actualización a Java JDK 11.

• Modelo de programación reactiva, es
totalmente asincrónico y no bloqueante.
• Programación con anotaciones.
• Nuevo enfoque de programación funcional.
• Soporte para HTTP/2.
• Soporte para Kotlin y Spring WebFlux.
• Compatibilidad con lambdas para el registro de beans.
• Soporte Spring WebMVC para las últimas API.
• Prueba de integración con Spring WebFlux.
• Actualizaciones generales del núcleo y del
contenedor de Spring.
• Proteccion CRSF.
• Soporte para OAuth 2.x
OWASP: https://owasp.org/www-project-top-ten/
Spring CORS
Spring security: autenticacion y autorizacion
 Spring security interceptors
• Uno de los componentes mas importantes de Spring security es AbstractSecurityInterceptor con
dos implementaciones concretas: FilterSecurityInterceptor y MethodSecurityInterceptor
• Estan encargados de decidir si una peticion puede ser permitida o denegada.
 Spring security interceptors
• Si el recurso solicitado esta protegido por atributos de configuracion (3) el Security Interceptor recupera el
objeto Authentication (1) desde el SecurityContextHolder y siguiendo uno de los pasos de
preprocesamiento se invoca el filtro (2), y el AccessDecisionManager (4) decide el exito(6) o fracaso (5)
de la peticion.
 Spring security interceptors

• El modelo de cadena de filtros es lo

que Spring Security usa para proteger
las aplicaciones web.

• Este modelo se basa en la funcionalidad

de filtro de servlets estándar.

• La cadena de filtro en Spring Security

está construida con unos pocos filtros
que cubren todas las diferentes
restricciones de seguridad requeridas
por la solicitud.

• La cadena de filtros en Spring Security

preprocesa y posprocesa todos las
peticiones HTTP y ademas aplica
seguridad a las URL que lo requieren.
 Spring security: implementación

• Crearemos una clase de seguridad

personalizada, para ello necesitamos usar
@EnableWebSecurity y extender la clase
con @WebSecurityConfigurerAdapter para
que podamos redefinir algunos de los
métodos de seguridad.

• Spring Security fuerza a hashear las

contraseñas para que no se guarden
en texto plano.

• Podemos usar PasswordEncoder,

aunque no debe ser una opción para
proyectos reales, una alternativa podría
ser BCryptPasswordEncoder.
 Spring security: implementación

• Debemos definir el conjunto de

recursos que deben protegerse y
cuales no.

• A continuacion hacemos uso del

método configure() que recibe la clase
HttpSecurity como parámetro.
 Spring security: implementación

• Si intentamos iniciar sesión con user2,

accederemos correctamente ya que que
hemos otorgado permisos a cualquier
usuario que tenga el rol ‘SENSEI’.

• Incluso podemos crear varios endpoints y

otorgar distintas restricciones como vemos
en el siguiente ejemplo.

• Debemos considerar que las reglas más

restrictivas deben estar en la parte superior.
 Spring security: implementación

• Podemos agregar diferentes roles para un

mismo recurso, para ello, podríamos usar
el metodo hasAnyRole().

• También podemos añadir filtros, cuyo objetivo

es interceptar las peticiones y cada uno tiene
su propia responsabilidad.
 Spring security: implementación

• Podemos configurar Spring Security para que

dependa de UserDetailsService, se trata de un
servicio que nos permitirá cargar datos
específicos del usuario.

• Para ello podemos crear nuestra propia clase

UserDetailService y UserDetails.

• En MyUserDetailService simplemente
sobrescribimos el método
loadUserByUsername() que recibe el nombre de
usuario como parámetro.
 Spring security: implementación

• Al implementar la interfaz UserDetails,

podemos sobrescribir varios métodos.

• Podemos crear un campo u

‘ sename’r para obtener
el nombre de usuario.

• El resto de los métodos tendrá valores hardcoded.

• El metodo getAuthorities() devuelve los

permisos otorgados al usuario, en este caso
solo el rol SENSEI.
Resto de metodos:

• isAccountNotLocked()
• isCredentialsNonExpired()
• isEnabled()
Spring security: flujo
Cuando se inicia la aplicación:

• Se carga la configuración de WebSecurity.

• Cuando el usuario introduce sus credenciales y éstas

se envían, el filtro de autenticación de Spring Security
intercepta la petición y se crea un objeto
UsernamePasswordAuthenticationToken con las
credenciales.

• El metodo loadUserByUsername() recibe el nombre

de usuario.

• Se crea un objeto MyUserDetails con el nombre de

usuario enviado con todos los valores hardcoded y se
compara MyUserDetails con el objeto
UsernamePasswordAuthenticationToken.

• Si todo es correcto se accede al recurso, en

caso contrario, se deniega el acceso.
Spring
AMQP
 Introducción

• Servidores de mensajería entre aplicaciones.

• Actúan como hombre en el medio (Middleware).
• Sistema seguro de envío de mensajes.
• Enrutamiento de mensajes.
• Control de la persistencía de los mensajes.
• Subscripción al broker (elemento del cluster).
• RabbitMQ, servidor de mensajera open source.
• Implementa el protocolo AMQP.
• Soporta otros protocolos como:
• HTTP, STOMP y MQTT.
Comparación entre protocolos de mensajería
Servidores de mensajería
Protocolo AMQP

• Protocolo binario que estandariza

la comuniacion.
• Sus origenes estan en la industria financiera.
• Define multiples canales en una conexion TCP.
 Protocolo AMQP
• El protocolo AMQP establece:

• exchanges, broker endpoint que recibe los mensajes.

• queues, broker endpoint bque almacena los mensajes del exchange.
• bindings, reglas entre los exchanges y queues.

• El protocolo AMQP es programable, es decir, las entidades anteriores pueden se

creadas, modificadas o eliminadas por codigo.
Protocolo AMQP
Mensajes
• Cada mensaje puede ser publicado con una “routing key”.
• Cada asociacin entre un exchange y una cola (queue) posee una “binding key”.
• El enrutamiento de mensajes se basa en la coincidencia entre ambas claves: binding &
routing keys.
Flujo de un mensaje
 Spring AMQP
AMQP se compone de intercambios, colas y enlaces:

• Exchanges (intercambios, son como oficinas o buzones de correos donde los clientes
publican mensajes en un exchange AMQP.

• Hay cuatro tipos de exchanges integrados:

• directo: enruta los mensajes a una cola haciendo coincidir una clave de enrutamiento
completa.
• fanout: enruta los mensajes a todas las colas vinculadas a él.
• temas: enruta mensajes a varias colas haciendo coincidir una clave de enrutamiento con
un patrón.
• encabezados: enruta los mensajes según los encabezados de los mensajes.

• Las colas están vinculadas a un exchange mediante una clave de enrutamiento.

• Los mensajes se envían a una centralita con una clave de enrutamiento, luego, el
exchange distribuye copias de los mensajes a las colas.
Spring AMQP
 Spring AMQP
• Spring proporciona utilidades para trabajar con RabbitMQ como la clase RabbitAdmin, que
permite declarar: colas, exchanges y bindings.
• Configuracion de listeners para procesar asincronamente mensages que llegan.
• La clase RabbitTemplate para enviar y recibir mensajes.
Usando la clase RabbitAdmin

• La clase RabbitAdmin la utilizaremos para crear colas/topics, exchanges o bindings

de RabbitMQ.
• La clase CachingConnectionFactory nos permite definir la conexion a establecer con el
broker de RabbitMQ.
Listeners de mensajes con Spring
RabbitTemplate
Spring Social
Spring social

• Spring Social es un proyecto de Spring con muchas

utilidades que facilitan la integración de nuestras
aplicaciones con las principales redes sociales como
Twitter, Facebook, LinkedIn, Flickr, Instagram, Google+...

• Con Spring Social podemos realizar de forma

mucho más sencilla la autenticación usando oAuth
con la cuenta que del usuario en cada una de las
redes sociales y también usando la API REST de
forma transparente a través de los ‘bindings’ que
nos proporciona Spring Social.
Spring social

• Los modulos cliente disponibles para las plataformas sociales actualmente

son:

• Podemos agregar Spring Social a nuestro proyecto maven con la siguiente

declaracion:
 Spring social: autenticación oAuth
OAuth es un estándar que permite un sistema de autenticación
delegada, compuesto por:

• Service Provider: es el site, web-service o servicio en general donde se localizan

los recursos restringidos.

• Usuario: es el actor principal dentro de OAUTH y dispone de recursos privados

que no quiere hacer públicos en el Service Provider, pero que quiere compartir
con otro sistema.

• Consumer: es la aplicación que está accediendo al recurso privado del usuario.

• Recursos protegidos: son de caracter privado, y para los que se le

otorgan permisos al consumer explícitamente.

• Tokens: se usan como sustitutos de las credenciales del usuario. usando

técnicas de Firma Digital para cifrar la información asociada al token y para
garantizar la identidad de la persona/sistema.
Flujo oAuth
Spring social Twitter
Una vez agregada la dependencia spring-social-twitter editamos
el archivo:

- src/main/resources/application.properties

para incluir las credenciales de twitter, como la clave appId que

corresponde al Consumer Key mientras que appSecret se refiere
al Consumer Secret.

- spring.social.twitter.appId=xxxxxxxxxxxxxxxxx
- spring.social.twitter.appSecret=xxxxxxxxxxxxxxxxxxxxxxxxx

A continuacion podemos trabajar en nuestro controlador,

necesitaremos un objeto Twitter que usaremos para acceder a cada
una de las funciones de twitter como leer ltweets, publicarlos, obtener
el perfil, etc.
Spring social Twitter
Spring social Facebook
Spring social Linkedin
¡Gracias por la atención!