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
