En una aplicación existen diversas clases organizadas en paquetes y estos en sus respectivos módulos.
Si vamos a la base, nuestro elemento mínimo es la clase. Ésta clase está destinada a muchos objetivos, entre ellos, la creación de de Beans.
Los Beans en si mismos no son nada más que POJOs(Plain Old Java Objects) los cuales son clases que no dependen de ningún framework para su funcionamiento.
Un Bean además de ser un POJO tiene unos elementos base que debe poseer:
-El boilerplate code: secciones de código que son incluidas en múltiples lugares con pocas o incluso sin ninguna alteración.
Bien, para nosotros, como programadores java, sabemos el incontable número de veces que tenemos que instanciar una y otra vez nuestros beans. Si vemos un ejemplo tradicional,usamos la clase Persona:
public class Direccion{
private String calle;
private int número;
private String CPdireccion;
//hay que recordar que el constructor por defecto es un fenómeno del compilador.
//Lo crea en usencia de otro Constructor. Se incluye en el ejemplo para conciliar
//con la definición de Bean
public Direccion(){
}
//métodos getter y setter de los campos
//llave fin de clase
}
public class Persona{
private String nombre;
private String apellido;
private Direccion direccion=new Direccion();
//hay que recordar que el constructor por defecto es un fenómeno del compilador.
//Lo crea en usencia de otro Constructor. Se incluye en el ejemplo para conciliar
//con la definición de Bean
public Persona(){
}
//métodos getter y setter de los campos
//llave fin de clase
}
public class Principal{
public static void main(String[] args){
//esto es recurrente en nuestros programas
Persona persona=new Persona(); }
}
Además, nos podemos encontrar con las clásicas dependencias entre clases, por ejemplo nuestra persona tiene una Dirección con sus propios campos, constructores y todo tipo de métodos.
En muchos casos nos vemos con la necesidad de realizar la instanciación dentro de nuestra propia clase Persona para evitar por ejemplo los temidos NullPointerException.
Esto nos lleva a un código similar al siguiente:
public class Direccion{
private String calle;
private int número;
private String CPdireccion;
//hay que recordar que el constructor por defecto es un fenómeno del compilador.
//Lo crea en usencia de otro Constructor. Se incluye en el ejemplo para conciliar
//con la definición de Bean
public Direccion(){
}
//métodos getter y setter de los campos
//llave fin de clase
}
public class Persona{
private String nombre;
private String apellido;
private Direccion direccion=new Direccion();//linea nueva
//ETC...
public class Principal{
public static void main(String[] args){
//esto es recurrente en nuestros programas
Persona persona=new Persona(); }
}
Pues bien, uno de los objetivos base de Spring Framework es la Inversión de Control(IoC) y lo realiza a través de la Inyección de Dependencias(DI).
Básicamente esto es la supresión de la necesidad de crear objetos en nuestra aplicación ya que es Spring el que cubrirá este desempeño con la Fabrica de Spring.
Esto de la fábrica de Spring no es más que un objeto(un contexto de aplicación) en el que se crean todas las instancias que necesitamos y estas a su vez con todas sus dependencias.
Esta simplificación en nuestro código se va a realizar además de forma poco intrusiva ya que no hay necesidad de implementar interfaces ni cosas similares.
Se va a poder realizar de tres formas a elegir por el programador, sin ser ninguna de ellas excluyente:
Hoy en día, es recomendado evitar configuraciones explicitas pero, tradicionalmente el programador Spring convive con gran cantidad de configuración XML.
Es de destacar que, la detección implícita no es más que la habilidad que posee el framework para inyectar objetos desde la fabrica del contexto de aplicación y la conexión ( ya sea automática o no) es la capacidad del Spring framework de satisfacer la relaciones de nuestros Beans (por supuesto estos deben vivir en el contexto de aplicación).
En el contexto de aplicación existen más elementos que los meros Beans pero, en un principio, vamos a identificarlo con la fabrica de Spring por simplicidad.
Esto sobre lo que estamos escribiendo forma parte la expecificacion core de Spring
Si vamos a la base, nuestro elemento mínimo es la clase. Ésta clase está destinada a muchos objetivos, entre ellos, la creación de de Beans.
Los Beans en si mismos no son nada más que POJOs(Plain Old Java Objects) los cuales son clases que no dependen de ningún framework para su funcionamiento.
Un Bean además de ser un POJO tiene unos elementos base que debe poseer:
- constructor por defecto(además otros que pueda poseer)
- campos para guardar la información
- métodos de establecimiento(getter y setter)
-El boilerplate code: secciones de código que son incluidas en múltiples lugares con pocas o incluso sin ninguna alteración.
Bien, para nosotros, como programadores java, sabemos el incontable número de veces que tenemos que instanciar una y otra vez nuestros beans. Si vemos un ejemplo tradicional,usamos la clase Persona:
public class Direccion{
private String calle;
private int número;
private String CPdireccion;
//hay que recordar que el constructor por defecto es un fenómeno del compilador.
//Lo crea en usencia de otro Constructor. Se incluye en el ejemplo para conciliar
//con la definición de Bean
public Direccion(){
}
//métodos getter y setter de los campos
//llave fin de clase
}
public class Persona{
private String nombre;
private String apellido;
private Direccion direccion=new Direccion();
//hay que recordar que el constructor por defecto es un fenómeno del compilador.
//Lo crea en usencia de otro Constructor. Se incluye en el ejemplo para conciliar
//con la definición de Bean
public Persona(){
}
//métodos getter y setter de los campos
//llave fin de clase
}
public class Principal{
public static void main(String[] args){
//esto es recurrente en nuestros programas
Persona persona=new Persona(); }
}
Además, nos podemos encontrar con las clásicas dependencias entre clases, por ejemplo nuestra persona tiene una Dirección con sus propios campos, constructores y todo tipo de métodos.
En muchos casos nos vemos con la necesidad de realizar la instanciación dentro de nuestra propia clase Persona para evitar por ejemplo los temidos NullPointerException.
Esto nos lleva a un código similar al siguiente:
public class Direccion{
private String calle;
private int número;
private String CPdireccion;
//hay que recordar que el constructor por defecto es un fenómeno del compilador.
//Lo crea en usencia de otro Constructor. Se incluye en el ejemplo para conciliar
//con la definición de Bean
public Direccion(){
}
//métodos getter y setter de los campos
//llave fin de clase
}
public class Persona{
private String nombre;
private String apellido;
private Direccion direccion=new Direccion();//linea nueva
//ETC...
public class Principal{
public static void main(String[] args){
//esto es recurrente en nuestros programas
Persona persona=new Persona(); }
}
Pues bien, uno de los objetivos base de Spring Framework es la Inversión de Control(IoC) y lo realiza a través de la Inyección de Dependencias(DI).
Básicamente esto es la supresión de la necesidad de crear objetos en nuestra aplicación ya que es Spring el que cubrirá este desempeño con la Fabrica de Spring.
Esto de la fábrica de Spring no es más que un objeto(un contexto de aplicación) en el que se crean todas las instancias que necesitamos y estas a su vez con todas sus dependencias.
Esta simplificación en nuestro código se va a realizar además de forma poco intrusiva ya que no hay necesidad de implementar interfaces ni cosas similares.
Se va a poder realizar de tres formas a elegir por el programador, sin ser ninguna de ellas excluyente:
- Configuración XML explícita.
- Configuración Java explícita.
- Detección implícita y conexión automática.
Hoy en día, es recomendado evitar configuraciones explicitas pero, tradicionalmente el programador Spring convive con gran cantidad de configuración XML.
Es de destacar que, la detección implícita no es más que la habilidad que posee el framework para inyectar objetos desde la fabrica del contexto de aplicación y la conexión ( ya sea automática o no) es la capacidad del Spring framework de satisfacer la relaciones de nuestros Beans (por supuesto estos deben vivir en el contexto de aplicación).
En el contexto de aplicación existen más elementos que los meros Beans pero, en un principio, vamos a identificarlo con la fabrica de Spring por simplicidad.
Esto sobre lo que estamos escribiendo forma parte la expecificacion core de Spring
Comentarios
Publicar un comentario