Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Spring Framework 3.0 CORE - El Contenedor de Spring

Spring Framework 3.0 CORE - El Contenedor de Spring
by

Antonio Brindiz

on 24 October 2012

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Spring Framework 3.0 CORE - El Contenedor de Spring

Spring Framework 3.0 CORE
El Contenedor de Spring Conocer los tópicos esenciales del contenedor de Spring
Conocer el Ciclo de Vida de los Beans
Conocer los Scopes de los Beans
Manejar los recursos de mensajes y el i18n
Manejo de Spring con Anotaciones. Objetivos Carga de múltiples contextos Tópicos avanzados del contenedor de Spring Para construir nuestra aplicación, Spring necesita dos cosas:
las clases de la aplicación (Beans)
una configuración que podremos proporcionarle mediante ficheros XML, anotaciones o código Java

Con estas dos entradas, Spring levantará un contexto de aplicación (ApplicationContext).

Este contexto es una interfaz cuya implementación se encargará de instanciar a los Beans, configurarlos y conectarlos. El contenedor de Spring Existen diferentes implementaciones del interfaz ApplicationContext, como ClassPathXmlApplicationContext, FileSystemXmlApplicationContext, XmlWebApplicationContext, etc.

Todas pueden cargar la configuración desde varios archivos y es recomendable dividirla en módulos.

ApplicationContext context = new ClassPathXmlApplicationContext("application-config.xml""test-config.xml", "vista-config.xml", "modelo-config.xml"); Por defecto Spring instancia todos los Beans definidos en la configuración y los carga en el contenedor de Spring desde que se genera el ApplicationContext.

A este tipo de carga se le conoce como Eagear Loading. Eager Loading Por defecto Spring crea exactamente una instancia por cada Bean que se declara en el contenedor.

Si un Bean es llamado múltiples veces desde el código a través del método getBean(), Spring siempre regresara la misma instancia.

A esto se le llama patrón Singleton, el cual es el scope por defecto de todos los Beans de Spring. Scope de los Beans Cuando un Bean es instanciado y cargado en el contendor al momento de que se solicita y no cuando se genera el ApplicationContext, entonces ese Bean esta utilizando la modalidad de Lazy Loading.

Para esto se utiliza el atributo "lazy-init" con un valor igual a "true". Lazy Loading <bean id="miClase" class="mx.paquete.MiClase" lazy-init="true" /> Singleton: Crea una instancia del Bean por configuración
Prototype: Crea una instancia del Bean cada vez que es solicitado al contenedor.
Request: Crea un único Bean por cada petición HTTP.
Session: Crea un único Bean por cada sesión HTTP.
GlobalSession: Crea un único Bean por cada sesión global HTTP. Diferentes Scopes de Spring Los últimos 3 solo están disponibles para ambientes WEB Para configurar el Scope de un Bean se utiliza el atributo scope con el valor del alcance que se desea.

<bean id="singleton" class="mx.paquete.MiClase" scope="singleton" />

<bean id="prototype" class="mx.paquete.MiClase" scope="prototype" />

<bean id="request" class="mx.paquete.MiClase" scope="request" />

<bean id="session" class="mx.paquete.MiClase" scope="session" />

<bean id="globalSession" class="mx.paquete.MiClase" scope="globalSesion" /> Configuración del Scope En Spring se pueden crear definiciones de Bean dentro de los tags <property> y/o <constructor-arg>.
Este tipo de Beans son conciderados como anónimos por lo cual no necesitan de id o alias.
Siempre tienen un scope del tipo prototype.
El Bean interno también es capaz de tener la definición de Beans internos. Definición de Beans Internos <bean id="futbolista" class="mx.paquete.Futbolista">
<property name="equipoDeportivo">
<bean class="mx.paquete.Balon"/>
</property>
</bean> Configuración de un Bean Interno Dentro de Spring se puede acceder a las propiedades de un Bean definido como una propiedad del otro Bean. Configuración de Propiedades Compuestas class InfoContacto {
private String email; // con su respectivo get y sett
private String telefono; // con su respectivo get y sett
}

class Futbolista implements Deportista {
private InfoContacto infoContacto; // con su respectivo get y sett
}

<bean id="futbolista" class="mx.paquete.Futbolista">
<property name="infoContacto">
<bean class="mx.paquete.InfoContacto">
</property>
<property name="infoContacto.email" value="usuario@dominio.com"/>
<property name="infoContacto.telefono" value="5555555555"/>
</bean> Ciclo de Vida 1. Instancia El contenedor de Spring crea la instancia del Bean definido en la configuración usando el API Reflection. 2. Inicialización de Propiedades Si las propiedades fueron configuradas son resueltas e inicializadas. El contenedor inyecta las propiedades del Bean. 3. BeanNameAware Si la clase del Bean implementa la interfaz BeanNameAware, entonces el método setBeanName() es llamado, enviando como parámetro el nombre del Bean. 4. BeanClassLoaderAware Si la clase del Bean implementa la interfaz BeanClassLoaderAware, entonces el método setBeanClassLoader() es llamado, enviando como parámetro la instancia de un objeto ClassLoader del Bean que ha sido cargado. 5. BeanFactoryAware Si la clase del Bean implementa la interfaz BeanFactoryAware, entonces el método setBeanFactory() es llamado, enviando como parámetro una instancia del objeto
BeanFactory. 6.ApplicationContextAware Si la clase del Bean implementa la interfaz ApplicationContextAware, entonces el método setApplicationContext() es llamado enviando como parámetro una instancia del objeto ApplicationContext. 7.BeanPostProcessor (pre-inicialización) Si alguna clase Bean implementa la interfaz BeanPostProcessor, entonces el método setProcessBeforeInitialization() es llamado 8. InitializingBean Si la clase del Bean implementa la interfaz InitializingBean, entonces el método afterPropertiesSet() es llamado. 9. Init-method Si el Bean tiene configurado un atributo llamado init-method, el valor sera usado para resolver la existencia de un método en la clase Bean y este método sera llamado. 10. BeanPostProcessor (post-inicializacion) Si alguna clase Bean implementa la interfaz BeanPostProcessor, entonces el método setProcessAfterInitialization() es llamado. 11. DisposableBean Si la clase del Bean implementa la interfaz DisposableBean, entonces el método destroy() es llamado cuando el contenedor no necesite más de la referencia del Bean. 12. Destroy-method Si el Bean tiene configurado un atributo llamado destroy-method, el valor sera usado para resolver la existencia de un método en la clase Bean y este método sera llamado. class MiClase{
public void inicializar(){
//inicializar los recursos utilizados por la clase.
}
}

<bean id="miClase" class="mx.paquete.MiClase" init-method="inicializar" /> Configuración de init-method class MiClase{
public void limpiar(){
//limpiar los recursos utilizados por la clase.
}
}

<bean id="miClase" class="mx.paquete.MiClase"
destroy-method="limpiar" /> Configuración de destroy-method El ApplicationContext puede notificar a los Beans de eventos que ocurran en la aplicación, para esto un Bean debe de implementar la interfaz ApplicationListener con lo cual seria capaz de recibir los eventos publicados en el contexto.

Los Beans pueden publicar eventos personalizados si extienden de la implementación de la interfaz ApplicationEventPublisherAware con el método publisEvent(). Manejo de Eventos en el Contenedor class MiListener implemets ApplicationListener<ApplicationEvent> {
@Override
public void onApplicationEvent(ApplicationEvent evento) {
System.out.println(evento);
}
}

class MiEvento extends ApplicationEvent {
private Deportista deportista;
public MiEvento(Deportista deportista){
super(deportista);
this.deportista = deportista;
}
}

class Futbolista implemets Deportista, ApplicationEventPublisherAware {
private ApplicationEventPublisher aep;

@Override
public void set ApplicationEventPublisher( ApplicationEventPublisher aep ) {
this.aep = aep;
}

public void jugar() {
aep.publishEvent(new MiEvento(this));
System.out.println("El Futbolista Esta Jugando");
}
} En una aplicación es necesario mostrar mensajes de algún tipo ya sean mensajes de error, éxito, etiquetas.

Spring soporta esto con el objeto ResourceBoundleMessageSource, y esta basado en las capacidades de Java por lo cual se debe de usar los estandares de Java para almacenar los mensajes.

Los dos principales estándares son:
guardar los mensajes de la forma llave-valor.
Archivo con extensión .properties y guardado en el classpath. Recursos de Mensajes - Resource Boundle <bean name="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basename">
<value>mensajes</value>
</property>
</bean>


mensajes.properties

titulo.pagina=Bienvenido
version.aplicacion=4.1.1




AppilcationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
String mensaje = ctx.getMessage("titulo.pagina", null, null); Configuración de Resource Boundle Aparecen desde la versión 2.0 de Spring y requieren tener un JSE 1.5 o superior.

Las anotaciones son capaces de agregar o reemplazar la configuración del contenedor de Spring por archivos XML.

La mayoría de las anotaciones están deshabilitadas por lo cual la configuración por defecto es por XML, por lo tanto, hay que habilitar las anotaciones cada vez que se quieran usar. Configuración basada en Anotaciones Para habilitar las anotaciones se puede hacer de 2 formas:

Registrando en el contenedor un post-processor

Agregando al archivo de configuración el elemento <context:annotation-config> Habilitando las Anotaciones Los Beans pueden ser de 4 tipos:

@Component("nombre_opcional"): Bean común de Spring.
@Controller("nombre_opcional"): Controlador de Spring MVC
@Service("nombre_opcional"): Servicio de Spring
@Repository("nombre_opcional"): Repositorio de accesso a datos (similar a DAOs) Tipos de Beans Aplica a métodos setter
Verifica que las propiedades sean inicializadas a la hora de configurarlas dentro del contenedor.
RequiredAnnotationBeanPostProcessor

class MiClase {
private String usuario;

@Required
public void serUsuario(String usuario){
this.usuario = usuario;
}
}

<bean id="campoRequerido" class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" > @Required Aplica a nivel de clase
Indica que se puede generar una instancia de esa clase y registrarla como Bean administrado por el contenedor de Spring
Se necesita configurar <context:component-scan>

@Component("miClase")
class MiClase {
private String usuario;

@Required
public void serUsuario(String usuario){
this.usuario = usuario;
}
} @Component("nombre") RequiredAnnotationBeanPostProcessor para @Required

PersistenceAnnotationBeanPostProcessor para @PersistenceContext

AutowiredAnnotationBeanPostProcessor para @Autowired

CommonAnnotationBeanPostProcessor para @PostConstruct y @PreDestroy Post Processor de Anotaciones <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"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="mx.paquete"/>
<context:annotation-config/>

</beans> Configuración para anotaciones automáticas Aplica al nombre de una propiedad o método setter
Forma parte de javax.annotation.Resource
Se utiliza para especificar inyección de dependencias

class MiClase
@Resource(name="usuario")
private String usuario;
public void serUsuario(String usuario){
this.usuario = usuario;
}
} @Resource(name="nombre") Se usa para determinar el alcance del bean
Por defecto es Singleton
Se utilizan las constantes de la interfaz BeanDefinition
SCOPE_SINGLETON
SCOPE_PROTOTYPE @Scope() Aplica a propiedades, métodos setter, métodos personalizados, constructores.
Se utiliza para hacer un auto-enlace
Se requiere en el contenedor que el bean sea de la clase AutowiredAnnotationBeanPostProcessor o dar de alta el elemento <context:annotation-config />
Por defecto utiliza la estrategia byType
Se lanza una excepción si encuentra mas de un Bean del mismo tipo de dato de la propiedad que se quiere auto-enlazar.
Por defecto todas las propiedades a ser auto-enlazadas son requeridas
Se lanza una excepción si el contenedor no encuentra ninguna coincidencia-
Si necesitamos que no se lance ninguna excepción se agrega el atributo required con valor igual a false, esto hará que las propiedades no encontradas sean inicializadas como null.

class MiClase
@Autowired(required=false)
private String usuario;
public void serUsuario(String usuario){
this.usuario = usuario;
}
} @Autowired Aplica a propiedades, métodos, métodos personalizados, constructores, argumentos de métodos o argumentos de constructores.
Se usa para especificar un Bean candidato en el proceso de auto-enlace, esto es, cambiar la estrategia de @Autowired a byName.

class MiClase
@Autowired
@Qualifier("usuarioRegistrado")
private String usuario;
public void serUsuario(String usuario){
this.usuario = usuario;
}
} @Qualifier Aplica a métodos
Requiere del Bean CommonAnnotationBeanPostProcessor o de <context:annotation-config />
Son usados para especificar los métodos de inicialización y destrucción que serán llamados por el contenedor en el ciclo de vida del Bean.


class MiClase
@PostConstrunct
public void init(){
...
}

@PreDestroy
public void destroy(){
...
}
} @PostConstruct y @PreDestroy
Full transcript