Creando una aplicacion con JSF RichFaces parte III

En esta ocacion haremos la integracion de nuestro proyecto con el framework de spring, que nos ayudara a hacer inyeccion de dependencias he integrar funcionalidades me una manera mas facil y transparente.

En la anterior entrada olvide comentar 2 puntos, donde poner el log4j y como invocarlo

     

     log4jConfigLocation     /WEB-INF/log4j.xml

     
          org.springframework.web.util.Log4jConfigListener
     

Ahora si para agregar spring a nuestro proyecto: 

1.- Agregando las librerias

/**
* En mi Caso utilizo las varsiones 3.0.5 de estos jar
* org.springframework.asm.jar
* org.springframework.beans.jar
* org.springframework.context.jar
* org.springframework.core.jar
* org.springframework.expression.jar
* org.springframework.web.jar
*/

2.- Creando el application-context.xml

3.- Modificando el web.xml

     contextConfigLocation               /WEB-INF/applicationContext-faces.xml
     
	


     
          org.springframework.web.context.ContextLoaderListener
     


     
          org.springframework.web.util.IntrospectorCleanupListener
     


     
          org.springframework.web.context.request.RequestContextListener
     

4.- Modificando el faces-config.xml

     org.springframework.web.jsf.DelegatingVariableResolver

5.- Creando los bean

/**
* lo hare estilo struts, un form que llamo bean y un action que llamo "cont"
* el bean lo coloco en com.tutorial.rich.faces.bean
* el contenedor lo coloco en com.tutorial.rich.faces.content
*/

public class Login {
private String usuario;
private String password;

public String getUsuario() {
	return usuario;
}
public void setUsuario(String usuario) {
	this.usuario = usuario;
}
public String getPassword() {
	return password;
}
public void setPassword(String password) {
	this.password = password;
}
}

/**
* agrego una llamada a mi log4j
*/
public class LoginCont {
	private static Logger log = Logger.getLogger(LoginCont.class);
	
private Login loginBean;

public Login getLoginBean() {
	return loginBean;
}
public void setLoginBean(Login loginBean) {
	this.loginBean = loginBean;
}

public String cmdLogin(){
	if(getLoginBean().getUsuario().equals("") 
|| getLoginBean().getPassword().equals("")){
		log.info("usuario invalido");
	}else{
		log.info("usuario valido");		
	}
	return null;
}
}

6.- Invocando al bean desde el jsp

NOTAS, HASTA AQUI TENEMOS CONFIGURADO SPRING Y UN EJEMPLO DE COMO ACCESAREMOS A LOS BEANS,
PERO AUN NO EXPLICO EL FUNCIONAMIENTO DE JSF, LO HARE AL MOMENTO QUE TENGAMOS HIBERNATE INTEGRADO CON NUESTRO PROYECTO..., RECUERDA SI TIENES DUDAS U OBSERVACIONES AGRADECERE TUS COMENTARIOS

Primeros Pasos Con Spring II

La entrada anterior vimos como inyectar una clase a otra de una forma sensilla, ahora veamos que pasa si utilizamos Interfaces

1.- Hay que crear una interfaz


public interface Impresora{
           public void imprimirTexto(String elTexto);
 }

2.- Hagamos dos implementaciones de Impresora


public class ImpresoraPorPalabras implements Impresora{
          public void imprimirTexto(String elTexto){
                    String [ ] separadoEnPalabras = elTexto.split(" ");
                    int pal=1;

                    for(String palabra: separadoEnPalabras){
                              System.out.println(pal + " " + palabra); 
                               pal++;
                    }
          } 
}

public class ImpresoraPorLetras implements Impresora{

           public void imprimirTexto(String elTexto){

                     char [ ] letras = elTexto.toCharArray();

                     int let=1;

                     for(char letra: letras){

                               System.out.println( let + " " + letra );

                               let++;

                     }

           }

}

3.-  Creamos nuestra clase que llamara a alguna implementacion de Impresora

public class EnviaTextos{
           public Impresora miImpresora;
           public void setMiImpresora(Impresora miImpresora){
                     this.miImpresora = miImpresora;
           }
          public Impresora getMiImpresora(){
                     return miImpresora;

          }
          public void mandarTextos(){
                     getMiImpresora().imprimirTexto("Interfaces con Spring, solo en Java-Limos");
           }

}
 
4.-  En nuestro applicationContext.xml mapearemos las 3 clases


< bean class="ejemplos.spring.basico.interfaces.ImpresoraPorLetras" id="porLetras" / >


< bean class="ejemplos.spring.basico.interfaces.ImpresoraPorPalabras" id="porPalabras" / > 


< bean class="ejemplos.spring.basico.interfaces.EnviaTextos" id="enviaTextos" >
          <property name="miImpresora" ref="porPalabras"/>
< / bean >


5.- En nuestra clase Test hagamos instancia a EnviaTextos


public class Test{          public static void main( String[ ] args ) {                    BeanFactory fabricaDeBeans= new XmlBeanFactory(new ClassPathResource("/applicationContext.xml"));

                    EnviaTextos textos = (EnviaTextos)fabricaDeBeans.getBean(EnviaTextos.class);

                    textos.mandarTextos();       
    }
}

NOTA: En este caso si ejecutamos la aplicacion saldria un resultado :

Interfaces 
con 
Spring, 
solo 
en 
Java-Limos
 

pero si en el applicationContext cambiamos


< bean class="ejemplos.spring.basico.interfaces.EnviaTextos" id="enviaTextos" >
          <property name="miImpresora" ref="porLetras"/>
< / bean >

sin necesidad de recompilar, el resultado seria

I
n
t
e
r
f
a
c
e
s 
...


esta es una ventaja mas de Spring, que sin necesidad de recompilar una aplicacion, podemos cambiar la implementacion de una interfaz simplemente modificando el applicationContext...

Primeros Pasos Con Spring I

Cuantas veces nos ha pasado que estamos realizando bien guerreros algun programita, lo ejecutamos y hoooo sale un tremendo "NullPointerException" revisamos y es que no inicializamos una variable.

Cuantas veces estamos trabajando con interfaces y se nos ocurre utilizar una implementacion distinta, pues no hay mas remedio que recompilar nuestra aplicacion...

Esto es muy molesto, mas cuando lo que se requiere es velocidad a programar (no cuenta que sea molesto por que apenas estamos aprendiendo, si ese es el caso, este post no es para ti o te haras simplemente mañoso ...)

Una de las bendiciones más basicas que nos proporciona Spring, es que nos olvidamos de las instancias, ya que todo o casi todo lo inyectamos,  no tenemos que recompilar una aplicacion para utilizar una nueva implementacion de una interfaz en nuestro sistema.

Bueno empesemos :)

Si utilidamos un IDE como NetBeans, MyEclipce, Eclipce ... basta con crear un proyecto con caracteristicas de Spring. a lo cual nos creara un archivito casi siempre en la carpeta src casi siempre se llama applicationContext.xml que tiene las siguientes caracteristicas:

1.- La version y codificacion del archivo: casi siempre 

< ?xml version="1.0" encoding="UTF-8"? > casi siempre lo que cambia es la codificacion.


2.- Los esquemas para utilizar los beans de spring que van dentro de un bloque beans


< 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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" >

< /beans >

Dentro de ese bloque mapearemos nuestras clases para que se inyecten al momento de ser utilizadas, esto reemplazaara a las instancias de clases que normalmente realizamos

Supongamos que tenemos dos clases, la primera imprime en pantalla un hola mundo mas un texto y la segunda llama a la primera agregandole el texto deceado

public class Impresora{
          public void imprimirTexto(String texto){
                    System.out.println("hola mundo desde: " + texto);
          }
}

public class Textos{
          public Impresora miImpresora;

          public void setMiImpresora(Impresora miImpresora){
                     this.miImpresora = miImpresora;

          }  
          public Impresora getMiImpresora(){
                     return miImpresora;

          }
          public void mandaAImprimir(){
                     getMiImpresora().imprimirTexto("Java-Limos.blogger");
          }
} 

NOTA: Para utilizar a miImpresora, cuando lo haciamos de la manera tradicional, muchos acostumbrabamos no encapsular la clase, para el caso de la inyeccion con spring tenemos que utilizarlo, aparte es una buena practica :)

Asumamos que tenemos nuestras dos clases en un paquete llamado "ejemplo.spring.basico", entonces procedamos a mapear nuestras clases en nuestro archivo applicationContext.xml

Dentro de nuesto bloque beans mapearemos nuestras dos clases


< bean
          class="ejemplo.spring.basico.Impresora" id="laImpresora"
/ >


Si observas dentro del bloque bean, mapeamos nuestra clase y le agregamos un identificador, esto es para ayudarnos a encontrarlo, es como si volviedamos a declarar una variable, pero esta ves en el xml


A continuacion mapearemos el segundo bean


< bean class="ejemplo.spring.basico.Textos" id="losTextos" >
          <property name="miImpresora" ref="laImpresora"/>
< / bean >

Si observas este nuevo bean, tiene una propiedad llamada "miImpresora" que no es mas que la variable miImpresora que contiene la clase Textos, y tambien tiene una referencia a "laImpresora" que es como identificamos en nuestro xml a la clase Impresora.


Ahora para que se vea aun mas, hay que crear una tercera clase con la cual inicializaremos nuestro applicationContext.xml


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

                    BeanFactory fabricaDeBeans = new XmlBeanFactory ( new ClassPathResource( "/applicationContext.xml" ) );


                    Textos misTextos = (Textos)fabricaDeBeans.getBean(Textos.class); 

                    misTextos.mandaAImprimir();
          }        
}

Ahora si ejecutan su aplicacion en pantalla veran reflejado: hola mundo desde Java-Limos.blogger

QUE DIFERENCIA HAY ?

En la clase Textos nunca hicimos una instancia hacia Impresora, solo nos dedicamos a llamarla y en el caso de Impresora a darle funcionalidad

QUIEN HISO LA INSTANCIA?

La instancia se hiso desde el applicationContext, y fue responsabilidad de Spring realizar la tarea. 

QUE GANAMOS AL REALIZAR ESTO?

Tal ves escribimos mas, pero la ventaja es que spring se encarga de cargar todos los objetos mapeados antes de realizar cualquier otra cosa, por lo tanto las instancias no se realizan en tiempo de ejecucion.

Los objetos mapeados los podemos manipular para que un solo bean pueda comportarse como instancias diferentes ( en el caso de que se utilize ese bean en diferentes clases)  o podemos modificar su ambiente para que se comporte como un solo bean para todas las instancias que utilizemos.

Da mas velocidad a nuestras aplicaciones al ser Spring el que se encargue de la gestion de nuestros objetos

En el siguiente post veremos la parte de las interfaces. que es mas interesate