Introducción a Spring Framework

¿Que es Spring?

Es un contenedor ligero para la construcción de aplicaciones empresariales que proporciona un soporte comprensivo para el desarrollo de sistemas. Spring framework es modular, por lo cual te permite utilizar solo lo que necesitas, además no es intrusivo, es decir se integra facilmente en los proyectos y promueve el desarrollo con una alta cohesion (Especialización de clases) y bajo acoplamiento (Codigo menos dependiente).

Te permite generar código que no es dependiente incluso del mismo Spring (solo para el Core), por lo que facilmente puedes remover el framework si así lo deseas y por si fuera poco, se integra perfectamente con otros frameworks (¬¬ honestamente yo no lo cambiaría por nada!!!)

En resumen, yo me quedo con esta maravillosa frase que viene su documentación oficial:

“Spring handles the infrastructure so you can focus on your application.”

Spanish:

“Spring maneja la infraestructura así que TU puedes enfocarte en tu aplicación”

Y asi es!!, este maravilloso framework te ayuda concentrar el esfuerzo en la funcionalidad de tu aplicación, y no en la infraestructura del sistema. (Que es algo por lo que muchos desarrolladores nos preocupamos). Promueve un mejor análisis y diseño, además perimte estabelecer un desarrollo agil y escalable para tus aplicaciones.

¿Como funciona?

El framework de Spring esta compuesto de varias características y se encuentra organizado en 20 modulos, que van desde el núcleo hasta las diferentes capas de desarrollo:

Sin embargo, el principal es el núcleo (Core Container), el cual se encarga de administrar el ciclo de vida de los objetos en la aplicación y es la pieza fundamental y necesaria para cualquiera de los módulos del framework. Por ahora solo nos enfocaremos en el núcleo.

Como su nombre lo dice es un contenedor, que almacena y administra los objetos de nuestra aplicación desde que se crean hasta que se mueren, ¿pero en donde se almacenan las instancias? en algo llamado Fabrica de Beans (Beans Factory).

Existen múltiples contenedores (Fabricas) que en Spring pueden ser categorizadas en dos tipos :

  1. Las fabricas definidas por org.springframework.beans.factory.BeanFactory, que proporcionan un soporte simple para administrar los objetos mediante la inyección de dependecias (DI) y la inversión de control (IoC).
  2. Las fabricas definidas por org.springframework.context.ApplicationContext, que al igual que el BeanFactory proporciona soporte para DI, y IoC, y otorga funcionalidades adicionales, como resolver mensajes de archivos properties, publicar eventos y listeners, internacionalización, entre otros.

¿Cual debo de utilizar?

La que mejor te convenga!! asi de fácil = ), para aplicaciones sencillas recomiendan la fabrica que implementa el BeanFactory, pero si tu aplicación es algo grande (como las aplicaciones web) y necesitas manejar properties, publicar listeners para eventos, realizar transacciones a bases de datos, o manejar AOP, declarar internacionalización, etc… entonces la fabrica del ApplicacionContext es para ti.

Nota: Por lo general recomiendan utilizar el ApplicationContext sobre el BeanFactory, ya que el primero otorga muchisimas opciones y funcionalidades de soporte, y no solo como un simple contenedor. En lo personal yo recomendaria el ApplicationContext ya que realíza la misma función que el BeanFactory y además ofrece una mayor escalabilidad.

Inversión de control (IoC) y la Inyección de dependencias (DI)

El contenedor maneja dos conceptos muy importantes para adminstrar las instancias de los objetos, la Inversión de Control (IoC: Inversion of Control) y la Inyección de Dependencias (DI: Dependency Injection), que son dos técnicas que utiliza Spring para otorgar los elementos necesarios a los objetos de la aplicación. (La primera vez que escuche esto no entendí nada =P, pero vamos a ver cada uno de ellos)

Inversión de control (IoC: Inversion of Control)

Spring se basa en el principo de Hollywood “No nos llames!!, Nosotros te llamamos”, esta frase se refiere a la forma en como se están creando los objetos (instancias), recuerda que estamos hablando del contenedor que se encarga de administrar el ciclo de vida de tus objetos ¿ok?

Este es el ejemplo más absurdo que he visto en internet, pero es sin duda el que me ayudo a aterrizar el concepto de la mejor forma:

Imagina que tenemos una Clase Ninja, que tiene como atributos un arma y una mision (necesarios para hacer cosas de ninja =P), ahora en el modo tradicional de programación nuestra clase se veria más o menos así:

public class Ninja {

    private Arma arma= new Shuriken();
    private String mision= "kill enemy";

}

Como se puede ver de esta forma nuestro ninja TIENE una mision y su arma (un Shuriken), pero que pasaría si quisieramos cambiar la misión o el arma?? tendriamos que modificar el código y recompilar la clase =S (lo cual es poco práctico), ademaś el código de nuestro ninja sigue dependiendo de su arma y de su misión especifica para poder operar, entonces tenemos un ninja tonto que solo puede manejar un arma y una misión.

Aquí entra la inversión de control =), vamos a ver como se ve si invertimos nuestro escenario:

public class Ninja {

    private Arma arma;
    private String mision;

    public void setArma(Arma arma) {
        this.arma = arma;
    }

    public void setMision(String mision) {
        this.mision = mision;
    }
}

Ahora, en lugar de que el ninja tenga un arma y una misión definida, nosotros se lo estamos PROPORCIONANDO a través del método setArma y setMision, con esto se corrigen las deficiencias del caso anterior ya que ahora le podemos dar cualquier misión y cualquier arma a nuestro ninja, entonces deja de ser tonto y se vuele un especialista en armas (es más cohesivo) y ahora puede incluso defenderse con un lapiz, además ya no depende solo del shuriken (tiene menor acoplamiento). (Ahora si como mi cuate kakashi puede utilizar su sharingan como arma😄 jaja).

¿Ves la diferencia? eso es la inversión de control, en lugar de que tu clase tenga que instanciar sus atributos, alguien o algo se los pasas de forma externa y los coloca en la clase para que pueda operar.

Inyeccion de Dependencias (DI: Dependency Injection)

La inyección se refiere a la forma o el mecanismo en como se colocan las instancias a los atributos de una clase  y esto en java se puede realizar de dos formas, mediante:

  • Inyección de Setters: Como vimos en el ejemplo del ninja, a sus atributos les pasamos las instancias que necesitaban a través de metodos (Setters).
  • Inyección de Constructores: Al igual que los setters permite colocar las instancias a los atributos de una clase, la diferencia es que lo realiza a través de constructores.
public class Ninja {

    private Arma arma;
    private String mision;

    public Ninja(Arma arma, String mision) {
        this.arma = arma;
        this.mision = mision;
    }
}

Como mencionamos anteriormente la base de Spring es el núcleo (Core Container), todos los módulos de Spring se basan en él y por lo tanto en la Ioc y la DI.

Hasta aquí unicamente hemos visto la teoría en relación a Spring y su núcleo, en el siguiente tema veremos la creación de la fabrica y como se usa el IoC y la DI.

Saludos

3 comentarios en “Introducción a Spring Framework

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s