Vamos a ver la creación de un sencillo "hola mundo" con el framework Spring, pero antes vamos a ver, un poco por encima de que trata esto de Spring.
Spring es un framework open source que tiene como objetivo facilitar el desarrollo de aplicaciones Java, está formado por diversos módulos que se pueden agregar a las aplicaciones. El único obligatorio es Spring Core (para la inyección de dependencias), a partir de aquí se pueden agregar mas módulos según las necesidades del programador, algunos ejemplos típicos son MVC (modelo vista controlador), AOP (trabajo con aspectos), DAO (data acces object)...
Sus características, a grandes rasgos, son:
- Simplicidad y acoplamiento débil basándose en el concepto de inyección de dependencias.
- Es un contenedor que gestiona el ciclo de vida de los objetos y su relación entre ellos facilitando que nos centremos en la lógica de la aplicación
- Es ligero y poco intrusivo
- Soporta la programación orientada a aspectos. Mas información
Inyección de dependencias
También conocido como inversión del control, es el mecanismo en que se basa Spring y lo que nos proporciona un acoplamiento débil entre sus clases.
Básicamente se trata de que un objeto conozca sus dependencias a partir de una interficie y no por su implementación, lo que desemboca en que la implementación puede variar sin que el objeto dependiente se de cuenta, algo que será de extrema utilidad a la hora de mantener aplicaciones muy grandes.
Ejemplo
Vamos a ver un ejemplo muy básico, en primer lugar necesitaremos bajarnos las librerías para agregarlas a nuestro proyecto. Aquí podemos encontrarnos con el primer problema.
Inexplicablemente, des de la pagina de Spring no existe ningún link de descarga, tenemos que dirigirnos directamente al repositorio para descargarlo:
http://maven.springframework.org/release/org/springframework/spring/
Una vez agregados a nuestro classpath del proyecto, también deberemos agregar los jars de Apache Commons. Los podremos descargar de este enlace.
Para este ejemplo no hará falta descargarlos todos, a continuación listo los que yo tengo añadidos a mi classpath para este ejemplo, con el link a su página de descarga:
Primero vamos a crear el proyecto, lo haremos funcionar, y al final explicaré que es lo que está pasando.
La estructura final con el proyecto de ejemplo terminado tendrá este aspecto :
Crearemos un archivo que llamaremos spring.xml que tendrá el siguiente contenido :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<bean id="saludoImpl" class="com.repocodigo.SaludoImpl">
<property name="val" value="Hola repocódigo!!!!!"/>
</bean>
<bean id="persona" class="com.repocodigo.Persona" >
<property name="saludo" ref="saludoImpl"/>
</bean>
</beans>
Creamos una clase encargada de cargar nuestro archivo spring.xml, la llamaremos ContextFactory.java
package com.repocodigo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class ContextFactory {
private static ApplicationContext respuesta;
public static ApplicationContext getInstance(){
if (respuesta != null) {
return respuesta;
}
respuesta = new FileSystemXmlApplicationContext("C:/wrkspcPruebas/SPRING_1/spring.xml"); //Ruta de nuestro xml
return respuesta;
}
}
Listo, ahora creamos una clase llamada Persona, esta clase tendrá un atributo que será una interfície llamada Saludo, este es el código para Persona.java
package com.repocodigo;
import com.repocodigo.interfaces.Saludo;
public class Persona {
private Saludo saludo;
public Saludo getSaludo(){
return saludo;
}
public void setSaludo(Saludo saludo){
this.saludo = saludo;
}
}
Ahora vamos con la interficie Saludo.java
package com.repocodigo.interfaces;
public interface Saludo {
public String saluda();
}
A continuación realizaremos una implementación de la clase saludo llamada SaludoImpl.java
package com.repocodigo;
import com.repocodigo.interfaces.Saludo;
public class SaludoImpl implements Saludo{
private String val;
public String saluda() {
return val;
}
public String getVal(){
return val;
}
public void setVal(String val){
this.val = val;
}
}
Una vez ya lo tenemos todo, yo creo una clase llamada Principal.java que lo único que contendrá será un metodo main que tendrá el aspecto siguiente :
package com.repocodigo;
import org.springframework.context.ApplicationContext;
public class Principal {
public static void main(String[] args) {
ApplicationContext factory = ContextFactory.getInstance();
Persona persona = (Persona) factory.getBean("persona");
System.out.println(persona.getSaludo().saluda());
}
}
Ejecutamos y vemos el resultado siguiente :
El funcionamiento lo marca el archivo de configuración spring.xml.
Todo lo que se encuentre dentro de la etiqueta
El tag
Dentro de este tag hemos definido dos atributos en nuestro ejemplo:
id = que es obligatorio, se trata de un identificador único para cada bean
class = indica la clase a la cual pertenece el bean
Cada bean puede tener subelementos
Los atributos para properties son :
name = nombre del atributo que tenga la clase
value = valor que le damos a la variable
ref = indicamos que el atributo es un objeto, de manera que configuraremos este objeto de manera independiente, siento el valor de ref el id de este objeto
Como se traduce esto a la práctica?
Tradicionalmente cada objeto es el responsable de obtener sus propias dependencias, como consecuencia nos encontraremos con un código muy acoplado porque cada objeto debe conocer como se construyen otros.
Al aplicar la inyección de dependencias un objeto conoce sus dependencias mediante su interfaz, esto se traduce en un acoplamiento débil ya que podemos variar la implementación ese objeto sin que el objeto dependiente se entere.
