Algunas características que hacen interesante el framework Spring:

• La inicial motivación era facilitar el desarrollo de aplicaciones J2EE, promoviendo buenas prácticas de diseño y programación. En concreto se trata de manejar patrones de diseño como Factory, Abstract Factory, Builder, Decorator, Service Locator, etc; que son ampliamente reconocidos dentro de la industria del desarrollo de software.
• Es código abierto
• Enfoque en el manejo de objetos de negocio, dentro de una arquitectura en capas
• Una ventaja de Spring es su modularidad, pudiendo usar algunos de los módulos sin comprometerse con el uso del resto:
• El Core Container o Contenedor de Inversión de Control (Inversion of Control, IoC) es el núcleo del sistema. Responsable de la creación y configuración de los objetos.
• Aspect-Oriented Programming Framework, que trabaja con soluciones que son utilizadas en numerosos lugares de una aplicación, lo que se conoce como asuntos transversales (cross-cutting concerns).
• Data Access Framework, que facilita el trabajo de usar un API com JDBC, Hibernate, etc.
• Transaction Management Framework.
• Remote Access framework. Facilita la existencia de objetos en el servidor que son exportados para ser usados como servicios remotos.
• Spring Web MVC. Maneja la asignación de peticiones a controladores y desde estos a las vistas. Implica el manejo y validación de formularios.
• Spring Web Flow.
• Spring Web Services.
• Etc
• Una característica de Spring es que puede actuar como pegamento de integración entre diferentes APIs (JDBC, JNDI, etc.) y frameworks (por ejemplo entre Struts e iBatis).

Una aclaración previa: un bean, en el contexto de Spring, es un objeto que es creado y manejado por el contenedor Spring. Es importante destacar la diferencia con respecto al uso clásico de 'bean' en J2EE: en Spring el bean no es una clase que cumple una serie de normas o restricciones, sino que es un objeto.

Los paquetes org.springframework.beans y org.springframework.context proporcionan la base para el contenedor IoC (Spring Framework's IoC container). En el primer paquete tenemos el interfaz BeanFactory, que proporciona la capacidad de gestionar cualquier tipo de objeto. En el segundo paquete tenemos el subinterfaz ApplicationContext, construido sobre la base del anterior. Añade a BeanFactory una mejor integración con AOP, manejo de internacionalización, propagación de eventos, manejo de contextos web con WebApplicationContext, etc.

La implementación más utilizada de BeanFactory es la clase XmlBeanFactory. Esta implementación toma de un archivo XML la definición de instancias o beans, así como sus dependencias. Por ejemplo:

    <bean id="springappController" class="spring03.SpringappController">
        <property name="libreria">
            <ref bean="libs"/>
        </property>
    </bean>

    <bean id="libs" class="spring03.negocio.Libreria">
        <property name="libros">
            <list>
                <ref bean="libro1"/>
                <ref bean="libro2"/>
                <ref bean="libro3"/>
                <ref bean="libro4"/>
            </list>
        </property>
    </bean>
	...

En este ejemplo el bean springappController (de la clase spring03.SpringappController) tiene un atributo (librería) que es una referencia al bean libs, de la clase spring03.negocio.Libreria. La libreria tiene la propiedad libros, que es una lista de libros (los bean para los libros no aparecen en este resumen del ejemplo).

Un ejemplo de instancia del contenedor podría ser el siguiente, donde al constructor se le pasa como argumento el archivo XML donde se definen los beans y sus dependencias:

	XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("org/xml/application-context.xml"));

Si no se quiere tener toda la definición de beans en un único archivo XML se puede utilizar la etiqueta import. Ejemplo:

<beans>
	<import resource="services.xml"/>
	<import resource="resources/messageSource.xml"/>
	<import resource="/resources/themeSource.xml"/>

	<bean id="bean1" class="..."/>
	<bean id="bean2" class="..."/>
</beans>

El directorio de referencia de las importaciones es aquel en el que se encuentra el archivo base. Los archivos importados deben tener la etiqueta 'beans' y hacer referencia al DTD o esquema.

Dentro del modo de programación imperativa estamos acostumbrados a pensar en un flujo de control predefinido por el programador. Sin embargo hay contextos (el caso típico son los modernos interfaces gráficos de usuario) en los que la aplicación cede el control a un API o sistema externo. Es dicho sistema el que determina los eventos que incidirán en el ciclo de vida de nuestra aplicación. Un ejemplo de inversión de control se encuentra en el modelo de programación orientado a eventos de Swing o AWT. De manera informal, la IoC viene representada por la frase "No me llames, yo te llamaré". Es el sistema externo el que llama a nuestra aplicación.

Veamos diferentes tipos de IoC:

• Elevación de dependencia (Dependency Lookup)
• Inyección de dependencia (Dependency Injection)

Un ejemplo de "Dependency lookup" puede ser el que sucede en RMI

	String url = "rmi://localhost/";
	String nombreObjetoRemoto = "ob1"
	...
	ClaseRemota ob = (ClaseRemota) Naming.lookup( url + nombreObjetoRemoto);
	System.out.println( ob.getString() );	

El objeto cliente para acceder al servicio primero lo identifica y después lo localiza por medio de una referencia (en el ejemplo la referencia es "ob"); a continuación hace la llamada al procedimiento. El inconveniente es el acoplamiento entre la capa cliente (front), la capa de acceso al servicio y la implementación del servicio.

Spring se identifica con una forma de IoC denominada Inyección de Dependencia, en la que el servicio se identifica y localiza por medio de mecanismos no programáticos, externos al código, como por ejemplo un archivo XML. Las dependencias con respecto a los servicios son explicitas y no están en el código. Con ello se gana en facilidad de test y mantenimiento. Algunas formas de inyección de dependencia son:

• Inyección por medio de métodos Setter. En nuestro ejemplo anterior de Spring la clase SpringappController tiene un método setLibreria(), que es el que utiliza el framework para inyectar la propiedad "libreria".
• Inyección por medio de constructor. Por ejemplo, el bean "prod_02" tiene un constructor que admite dos argumentos:

  
      <bean id="prod_02" class="org.ejemplo.Producto">
        <constructor-arg value="AK" />
        <constructor-arg value="600" />
      </bean>
  	

La descarga del framework se puede hacer en la web de Spring.

Para utilizar Spring en nuestro proyecto simplemente tenemos que instalar la librería spring.jar, que exige además la librería de log básico: commons-logging-api.jar, normalmente incluida en la distribución de Tomcat. Si utilizamos Eclipse tenemos que hacer Project - Properties - Java Build Path - Add Jars. Además se puede señalar el "JavaDoc Location" (donde se encuentran los JavaDoc de spring.jar), estos JavaDocs se incluyen también en el archivo descargado. Ejemplo de "JavaDoc Location": file:/C:/DOC/Spring/spring-framework-2.0.7/docs/api/.