Resumen:En esta entrada del blog vamos a ver un ejemplo más práctico donde vamos a explicar ciertas características de spring, como que es la inversión de control, patrón de diseño singleton, cohesión y acoplamiento, entre otras características más del framework.
bueno primero vamos a empezar creando un proyecto con nuestro Framework STS.
Menú File--New--Other.
tecleamos Maven en el wizard y seleccionamos Maven Project.
en la siguiente pantalla seleccionamos la casilla de Create a simple project(skip archetype selection) y le damos siguiente.
en la siguiente pantalla la configuramos como en la imagen que es propia de la herramienta Maven, del cual hablamos en los temas de Maven en este mismo blog.
le damos finish y vemos que nos ha creado un proyecto con cierta estructura standard que Maven propone y que ha sido aceptada en la mayoría de los desarrollos empresariales.
primero tenemos la carpeta src/main/java en la cual deben ir todos los archivos .java de la aplicación.
segundo tenemos el paquete src/main/resources en la cual deben ir todos los archivos NO java de la aplicación, como .properties, .txt, .xml, etc. etc., que pueden ser archivos de configuración.
tercero tenemos la carpeta src/test/java donde deben ir todas las clases de java que sean de prueba llamadas pruebas unitarias , es decir Junit, la cual iremos viendo a lo largo de este curso de spring.
luego tenemos src/test/resources la cual van a ir todos los archivos NO java que pueden ser de configuración para que el entorno de test funcione, así tendremos desacoplados el ambiente de las pruebas.
luego tenemos que en mi caso mi proyecto esta utilizando la versión 1.5 de java, así que vamos a proceder a cambiar esta versión por una más reciente.
demos clic derecho sobre el proyecto--Properties--Java Compiler. y luego cambiamos la versión como en la siguiente imagen.
le damos ok guardando los cambios efectuados.
luego tenemos un archivo llamado pom.xml, que es nuestro archivo de configuración principal de nuestro proyecto. Vamos a proceder abrirlo en vista pom.xml y agregamos las dos librerías necesarias para el soporte de Spring, las cuales las podemos hacer manualmente o desde el ambiente gráfico que se encuentra en la pestaña de Dependencies.
la cual se explicó en esta entrada.
de todos modos esto es como quedaría nuestro archivo pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>mx.com.nombreempresa</groupId>
<artifactId>ejemplo-maven</artifactId>
<version>1.0</version>
<name>Ejemplo-Maven</name>
<description>Este es un ejemplo sencillo de como recuperar beans desde la fabrica de Java</description>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.2.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.2.4.RELEASE</version>
</dependency>
</dependencies>
</project>
ahora que hemos agregado las librerías nuestro IDE STS las marca en la arquitectura general del proyecto.
primero vamos a crear la interface Herramienta que hemos creado ya en otros ejemplos, pero ahora lo haremos con Spring.
Menú File--New--Interface
vemos que le puse un paquete el cual tiene la siguiente nomenclatura
mx --> pais
com--> giro
nombreempresa-->el nombre de su empresa
beans --> viene siendo el nombre del paquete; cuando entremos a programar en capas, vamos ir definiendo muchos paquetes :)
finish.
antes de seguir con este ejemplo, cualquier duda sobre la programación orientada a interfaces visita este link
el contenido de esta interface es el siguiente
package mx.com.nombreempresa.beans;
public interface Herramienta {
String getNombre();
String getHabilidad();
}
ahora vamos a crear una implementación de la misma
Menú File--New--class
lo único que cambio fue el paquete, el cual yo decidí ponerle impl, el cual de hecho es un nombre que es usado en una arquitectura multicapas, pero por ahora solo fue para separar las interfaces y las clases de nuestro proyecto que vallamos creando.
vamos a crear tres implementaciones de la misma manera para la interface Herramienta en el paquete de impl.
package mx.com.nombreempresa.impl;
import mx.com.nombreempresa.beans.Herramienta;
public class Martillo implements Herramienta {
@Override
public String getNombre() {
// TODO Auto-generated method stub
return "Martillo";
}
@Override
public String getHabilidad() {
// TODO Auto-generated method stub
return "golpear clavos";
}
}
clase Jeringa
package mx.com.nombreempresa.impl;
import mx.com.nombreempresa.beans.Herramienta;
public class Jeringa implements Herramienta {
@Override
public String getNombre() {
// TODO Auto-generated method stub
return "Jeringa";
}
@Override
public String getHabilidad() {
// TODO Auto-generated method stub
return "Injectar y hacer sufrir mucho :(";
}
}
clase Computadora
package mx.com.nombreempresa.impl;
import mx.com.nombreempresa.beans.Herramienta;
public class Computadora implements Herramienta {
@Override
public String getNombre() {
// TODO Auto-generated method stub
return "Computadora";
}
@Override
public String getHabilidad() {
// TODO Auto-generated method stub
return "programar y muchas cosas mas";
}
}
bien, hasta ahora no hemos hecho nada fuera de lo normal. ahora si vamos a crear estos beans desde nuestra fábrica de beans es decir desde el applicationContext, para eso vamos a crear nuestro applicationContext.
Menú File--New-- Spring Bean configuration File (si no esta en la lista busquenlo dandole en other)
ahora vamos a configurarlo..
en la primera pantalla podemos ver que lo guardo en resources, que es justo la carpeta destinada para archivos NO java.
Menú File--New-- Spring Bean configuration File (si no esta en la lista busquenlo dandole en other)
ahora vamos a configurarlo..
en la primera pantalla podemos ver que lo guardo en resources, que es justo la carpeta destinada para archivos NO java.
el nombre que le puse al archivo fue applicationContext, pero puedes ponerle como quieras.
bien, en la segunda parte vamos a configurar los namespace para nuestro archivo de configuración que son como import en las clases Java.
podemos ver que seleccionamos el namespace de beans y de context.
con esto listo le damos en finalizar.
ya creada nuestra fábrica de spring vamos a poner el siguiente contenido.
el cual se explica solo
Podemos ver que el IDE nos ayuda con un autocomplete e incluso si nos equivocamos por ejemplo un mal cierre, una declaración errónea de algún bean., que en este caso creamos 3.
bien ya creados es hora accederlos.
primero vamos a crear una clase Java con un Main llamada FabricaSpringTest.java
vemos en la imagen que paquete le pusimos y de igual manera pueden poner la clase donde quieran y que active la casilla para generar el método main.
ahora vamos a poner el siguiente código de la imagen, que también se explica solo
recueden que tenemos otros dos beans en la fábrica de Spring, así con solo cambiar el id, nuestro objeto herramienta cambiará su implementación sin tener que afectar el código directamente, es decir no tenemos intrucción, quizás este ejemplo sea demasiado básico para entender estos conceptos, pero una vez empecemos a programar en capas podremos entender más este concepto, por ahora les queda cambiar el id y ver que es lo que pasa y saber que es así como se obtiene un objeto de la fabrica de spring y que por defaul utiliza el patrón de diseño singleton para la creación de todos sus beans, el cual ejemplificaremos de manera más abierta en las siguientes entradas.
saludos ..
No hay comentarios.:
Publicar un comentario