Spring Dao Ejemplo(primera parte)

HOLA!!, pues vamos a continuar escribiendo un post sobre Spring DAO, que es uno de los módulos del framework de Spring.

y bueno cabe destacar que Spring DAO no es un ORM como lo es Hibernate, iBatis o JPA, simplemente es una solución más optimizada para la capa de datos que ofrece Spring en lugar de JDBC, sin embargo Spring también ofrece integración con los ya mencionados Frameworks de la capa de datos para tener una solución más robusta al momento de construir la arquitectura de un proyecto, pero eso sera en otros posts, por ahora vamos a concentrarnos en Spring DAO.


Vamos a construir un proyecto con maven utilizando el IDE STS(Spring tool Suite) como ya lo hemos estado haciendo en otros posts, la diferencia es que vamos agregar unas nuevas librerías que son las que dan soporte a Spring DAO.

Si no estan familiarizados con este ide, o tiene dudas al descargarlo chequen los anteriores posts, ahí se explica toda esa parte :)


bien ahora vamos a crear el proyecto. en el siguiente paso seleccionamos "Create a simple project" y en el siguiente lo dejamos con la siguiente imagen.

y le damos en finalizar :)



















Ahora vamos a crear un archivo de definición de Spring, es decir un applicationContext.xml, para eso le damos clic derecho sobre el proyecto recién creado, New y Spring Bean Configuration File

nota:si no aparece, le damos en Others y tecleamos Spirng, y elegimos  Spring Bean Configuration File.

lo guardamos en la ruta indicada, y le ponemos un nombre, en mi caso le puse applicationContext.




le damos finalizar.


nota: la siguiente pantalla se configuraban los namespace de Spring, pero nuestro proyecto aun no tiene agregadas las librerías de Spring, asi que primero vamos a agregar en el archivo pom.xml y luego regresaremos a trabajar con este archivo de applicationContext.


bien vamos a nuestro archivo pom.xml en el modo de vista de dependencias.

agregamos la siguiente librería que es el soporte para spring-jdbc

















nuestro pom.xml se tendría que ver de la siguiente manera:

<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>spring-dao</artifactId>

  <version>0.0.1-SNAPSHOT</version>

  <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>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>3.1.1.RELEASE</version>

</dependency>

  </dependencies>

</project>

bien, ahora vamos agregar otras librerías más para la conexión a la base de datos.

<!-- DataSource -->

<dependency>

<groupId>commons-dbcp</groupId>

<artifactId>commons-dbcp</artifactId>

<version>1.4</version>

</dependency>

<!-- driver para conexión a una base virtual -->

<dependency>

<groupId>com.h2database</groupId>

<artifactId>h2</artifactId>

<version>1.0.20070304</version>

</dependency>

Con esto tenemos listas nuestras dependencias, ahora regresemos a nuestro archivo applicationContext


vamos a la opción de namespaces y seleccionamos las dos siguientes.

ahora vamos agregar un bean a nuestro archivo applicationContext, se vería de la siguiente manera

El objeto es el dataSource o fuente de datos, nos sirve para definir la conexión a la base de datos que en este caso es una virtual, y requiere del archivo script.sql donde se guarda la creación e inserción de datos.

Ahora vamos a crear un clase llamada Alumno, que será el modelo de nuestra aplicación y la vamos a depositar en la carpeta de mx.com.nombreempresa.dto. la cual tendrá los siguientes atributos (id,nombre,apellidoPaterno,apellidoMaterno).

package mx.com.nombreempresa.dto;

public class Alumno {

 private int id;
 private String nombre;
 private String apellidoPaterno;
 private String apellidoMaterno;
 
 public Alumno() {
 
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getNombre() {
  return nombre;
 }

 public void setNombre(String nombre) {
  this.nombre = nombre;
 }

 public String getApellidoPaterno() {
  return apellidoPaterno;
 }

 public void setApellidoPaterno(String apellidoPaterno) {
  this.apellidoPaterno = apellidoPaterno;
 }

 public String getApellidoMaterno() {
  return apellidoMaterno;
 }

 public void setApellidoMaterno(String apellidoMaterno) {
  this.apellidoMaterno = apellidoMaterno;
 }
 
 
 

}

nota: dto-->Data Transfer Object, son los objetos de transferencia y constituyen a un patrón de diseño.

Ahora vamos a crear una clase de tipo DAO (Data Access Object), que es una clase normal pero cuyo funcionamiento consiste en la conexión a la base de datos, forma parte de los patrones de diseño que estaremos mencionando a lo largo de este blog. por ahora solo comprende que una clase DAO, es una simple clase cuya función es conectarse con el repositorio de información ( base de datos, archiuvos, XML, etc.)


Pero... en Spring se promueve la programación orientada a interfaces, permitiendo una alta cohesión y un bajo acoplamiento. por lo tanto, vamos a crear una interface llamada AlumnoDao, ojo, chequen el paquete.

package mx.com.nombreempresa.dao;

import java.util.List;

import mx.com.nombreempresa.dto.Alumno;

public interface AlumnoDao {

 
 void save(Alumno alumno );
 void delete(Alumno alumno);
 void updateById(Alumno alumno);
 List getAlumnos();
 Alumno getAlumnoById(int idAlumno);
 
 
}

como podemos ver, la interface tienes los métodos más comunes conforme a operaciones a la base de datos. vamos a continuar en la siguiente entrada con este post.

Spring DAO

Spring DAO??

Bueno pues en esta entrada vamos a ver sobre Spring DAO, que son clases de Spring cuya implementación  nos ayuda a la conexión de base de datos.

pero antes de que empecemos a codificar vamos a platicar un poco de que es Spring DAO y pues el porque elegirlo en lugar de conexiones directas con JDBC.

Uno de los objetivos de Spring es la simplificación de tareas al crear aplicaciones Java. La mayoría de los sistemas empresariales persisten su información en Bases de Datos.

Por ello Spring, en busca de esta simplificación agregó el paquete Spring JDBC, el cual aplica el concepto de Template (plantilla) para simplificar procesos como Abrir y Cerrar conexiones de Bases de Datos, mejor manejo de Excepciones, entre muchas características más.

Si ya tienes cierta experiencia utilizando JDBC, habrás notado que es complejo realizar una consulta a la base de datos, por muy básica que esta sea, además muchos de los pasos a seguir son repetitivos e innecesarios desde el punto de vista en nuestro código Java.

Además de la simplificación del manejo de JDBC, Spring ofrece una integración transparente con frameworks de persistencia.

Sin embargo, cabe mencionar que Spring JDBC no es un framework ORM (Object Relational Mapping) más, sino su intención es únicamente simplificar el uso del API JDBC en nuestras aplicaciones Java.

Spring JDBC promueve el uso de Interfaces con el objetivo de crear sistemas con un bajo acoplamiento y una alta cohesión.

las clases de servicio NO necesitan saber qué tecnología se está utilizando para conectarse a la base de datos, es decir, podríamos utilizar JDBC puro, JPA, Hibernate, iBatis, entre otras tecnologías, y la clase de servicio de manera agnóstica utiliza estas interfaces sin necesidad de saber qué tecnología se está empleado para leer y escribir a la base de datos.

Esta configuración permite hacer pruebas unitarias más  fácilmente, ya que en cualquier momento podemos cambiar la implementación de la clase DAO (Data Access Object).

El patrón de diseño Template se utiliza con el objetivo de encargarse de las tareas tediosas o repetitivas, y dejar lo realmente importante a nosotros.

Las tareas que este realiza son:

• Abrir la conexión a base de datos (open connection)

• Comenzar una transacción (beggin transaction)

• Terminar la transacción (haciendo commit o rollback)

• Cerrar la conexión de base de datos

• Convertir y Manejar las excepciones de tipo SQLException

Por otro lado, el único trabajo del que nos debemos encargar es:

• Preparar nuestra sentencia SQL a ser ejecutada

• Recuperar los datos y retornarlos

Plantillas de acceso a datos

Configuración general de Spring JDBC

Estaremos aclarando más sobre los patrones de diseño en los post de "patrones de diseño", por ahora esta es la teoría de spring DAO.

El famoso ApplicationContext?

Todo mundo se pregunta que es el applicationContext, y no es nada más y nada menos que la fábrica de Spring, un vil archivo XML.

En palabras más formales y para aquellos que usen el blog para entregar alguna tarea sobre el tema, jaja, esto no lo enseñan en las universidades, bueno en la mayoría no. :), aquí  lo ponemos más formal.

Es el fichero de configuración básico de Spring (application context). Consiste en un fichero XML donde se añadirán todos los objetos que deberán existir en la aplicación al inicializarse la misma.

bueno, sigamos..

para poder llamar al archivo descriptor de Spring (applicationContext) existen 3 maneras:

1.-ClassPathXmlApplicationContext

Carga el Application Context localizado en el classpath de la aplicación, este es el más usado por su portabilidad.

ApplicationContext context= new ClassPathXmlApplicationContext("spring.xml");

Podemos ver que también se esta haciendo un downcasting. así que los que no entienda sobre esta terminología los invito a ver este link

http://tutorialesjavamx.blogspot.mx/2013/08/programacion-orientada-interfaces.html

2.-FileSystemXmlApplicationContext

Carga el archivo de Spring del file system ( sistema de archivos) de nuestro sistema operativo.

ApplicationContext context= new FileSystemXmlApplicationContext("c:/spring.xml");

Esta forma no es muy portable, ya que depende completamente del sistema de archivos como podemos ver en el ejemplo utilizando Windows. :)

y por último.

3.-XmlWebApplicationContext:

Carga el archivo de Spring a partir del contenedor web. Comúnmente el archivo web.xml

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/Spring.xml</param-value>

</context-param>

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class

</listener>

El listener que tenemos configurado nos va permitir detectar el momento en que carga la aplicación web y también va ayudar a levantar el archivo de configuración de spring, este ejemplo ya lo abordaremos cuando desarrollemos aplicaciones Web.

Bueno ahora veremos un ejemplo de como se llama nuestro archivo descriptor utilizando la primera forma :)

Spring Framework Ejemplo Annotation

Vamos a retomar el mismo ejemplo que tenemos en el post de
http://tutorialesjavamx.blogspot.mx/search/label/Spring%20Framework


así que antes de seguir con este, chequen el anterior, solo que se le harán algunas modificaciones para que en lugar de utilizar XML para jalar los beans de spring, vamos a utilizar annotations.


bueno se supone que hasta aquí ya leíste el post mencionado con anterioridad, así que vamos a proceder a realizar los cambios.

primero vamos a realizar el siguiente cambio a nuestra fábrica de spring, es decir a nuestro applicationContext.xml

la imagen se explica sola, ya que quitamos la  creación de los beans y ahora los vamos a leer por medio de annotations que son configuraciones que deben tener las clases que se encuentran en el paquete base-package.

bien ahora vamos a decirle a spring que esas clases van a ser beans de spring por medio de annotations, primero vamos a a la clase Martillo y ponemos la siguiente annotations arriba del nombre de la clase

@Component(value="beanMartillo")

quedaría así.




Como podemos ver, se agrego la annotation @Component con la propiedad value="beanMartillo", esto es como si en xml hubieramos puesto lo siguiente:

  <bean  id="beanMartillo" class="mx.com.nombreempresa.impl.Martillo"/>

y  bueno en la clase  FabricaSpringTest.java hacemos la modificación correspondiente:

les queda de tarea poner la annotation a las otras dos implementaciones (Jeringa y Computadora).

bien, ahora vamos hacer otra pequeña modificación.

vamos a quitar la propiedad value en la annotation component.

si nosotros quitamos la propiedad value, cuando llamemos nuestro bean en el archivo FabricaSpringTest.java por default spring le pone el mismo nombre de la clase pero con la primera letra en minúscula, es decir en el caso de Martillo, el nombre de manera implícita sería martillo. y se llamaría así.

hasta ahora hemos visto como crear objetos mediante xml y annotations en spring; sabemos que spring usa por default en patrón de diseño singleton para la creación de sus objetos, cuyo tema se abordará en las siguientes entradas.

saludos a todos :)

Spring Framework Ejemplo

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.

http://tutorialesjavamx.blogspot.mx/2013/08/introduccion-spring-framework.html

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.

ok, ahora vamos a proceder a crear las siguientes clases en nuestro 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  

http://tutorialesjavamx.blogspot.mx/2013/08/programacion-orientada-interfaces.html

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.

clase Martillo

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.

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 ..

Introducción a Spring Framework

Bueno como ya me han estado pediendo que publique sobre JEE, pues voy  a seguirle con el tutorial de Spring Framework, que es uno de mis frameworks favoritos :)

y bueno antes de leer esta entrada, y si eres nuevo en esta tenologia te invito a que primero cheques la teoría de Spring y que herramientas de desarrollo vamos a utilizar para el tutorial que estaré desarrollando en estas semanas.

primero checate este:
http://tutorialesjavamx.blogspot.mx/2013/08/spring-framework.html

Luego este:
http://tutorialesjavamx.blogspot.mx/2013/08/instalacion-y-configuracion-de-sts.html


Con esto ya tienes para seguir aquí.

bien, ahora se supone ya tienes abierto tu STS y ya tienes tus repositorios de Maven listos.


MAVEN?????    y eso que es??.. no te preocupes, en la siguiente entrada hablaré a detalle sobre que es Maven, por ahora solo te diré que es una herramienta para gestión y creación de proyectos Java y bueno, STS que tiene una sencilla integración con el, por eso es que lo vamos a utilizar.



ok, bueno como todos sabemos para poder utilizar dependencias en nuestros proyectos Java necesitamos agregarlas a nuestro proyecto de manera manual, es decir, ir por ellas a la web y luego copiarlas y por último referenciarlas a nuestro proyecto.


que tedioso es eso, jumm..

pero para eso esta nuestra herramienta Maven.


gracias Maven por existir :)
y  bueno la siguiente comparativa lo ejemplifica todo.

esto es lo que tendrías que hacer si no usaras maven, agregar todas tus librerías de manera manual a tu proyecto, ahora imaginate cuando se trabaja en equipo o con un repositorio donde, no son 2 o 10 librerías, sino muchas más.

incluso cuando se trabajo con subversion es demasiado molesto que alguien suba sus respectivos cambios pero no la librería que esta utilizando, ende cuando tu actualizas tu copia de trabajo ya no funciona, total se soluciona, te pasa en una usb la librería que tienes que agregar o aunque la suba en el proyecto tienes que referenciarla de esta manera, que pesado es eso de verdad y lo digo por experiencia.
quizás muchos se esten preguntando que es subversion, también en la siguiente de la siguiente entrada vamos aprender a usarlo, no se preocupen :)

en fin, regresando a maven, donde todo las dependencias de tu proyecto se concentran en un archivo xml llamado pom.xml y pues los detalles de maven se los mencionaré en la siguiente entrada, quedaría así.

todas las dependencias de tu proyecto se declaran aquí, también puedes especificar que versión del Jar requieres, con esta declaración a través de maven busca las librerías en Internet, las descarga de manera local y las utiliza en cualquiera de tus proyectos que las necesite.  :)

pero bueno ya dije que hablaré a detalle de maven en la otra entrada.


seguimos..


ahora que al menos sabemos que maven existe, vamos al menú file de nuestro IDE y le damos

File - New -Other.

escribimos maven en el input box.


de la categoría que aparece(Maven) escogemos Maven Proyect.,  activamos la casilla de abajo y le damos siguiente.

en la siguiente pantalla vamos a configurar de la siguiente manera

yo creo que se explica sola :).


bien ahora le damos finalizar y listo ya tenemos creado un proyecto java basado en Maven, el cual nos da una arquitectura standard y muy sencilla para ubicar nuestros archivos en el proyecto.

ya hablaremos sobre esta arquitectura más tarde, por ahora solo vamos a concentrarnos en un simple hola mundo con Spring .








bien, lo único que si tenemos que destacar es que existe un archivo xml llamado pom.xml, asi que vamos abrirlo.

como podemos ver tenemos varias vistas, ya que nuestro IDE tiene soporte nativo para Maven, nos ayuda con estas interfaces visuales, sin embargo vamos a ver la vista de pom.xml.

que es muy parecida a la que mostramos con anterioridad, bueno ahora vamos agregar dos librerías para que podamos realizar nuestro ejemplo.
vallamos a la vista de Dependencies y precionemos el boton de Add.

ahora teclemos spring-core

podemos ver que nos arroja muchos resultados, pero la que queremos es de org.springframework, también podemos observar que tienen una especie de menús desplegables, que lo que nos muestran son las versiones de cada jar que ha tenido.

hacemos lo mismo con spring-context y le damos ok

con estas dos librerías es suficiente para que nuestro ide la descarge y las podamos usar en nuestro proyecto.
nota: el tiempo de descarga depende si es la primera vez tardará al bajarlas en tu repositorio local :O

una vez agregadas nuestras librerías regresemos a la vista de pom.xml

ahora ya esta como en la imagen de arriba,.. :), pero que creeen pudimos a verlas agregado en el archivo pom.xml directamente, y eso es muy usuado en la realidad :)




una vez listas, vamos a crear una clase con un main llamado-> HolaSpring.java en src/main/java creando un paquete con la siguiente nomenclatura mx.com.nombreproyecto.beans y activando la casilla para que nos cree el método main

listo, ahora vamos a crear un archivo de configuración de Spring el famoso ApplicationContext del cual también hablaremos en otra entrada. Por ahora solo nos limitaremos a crearlo con ayuda de nuestro IDE.

File -New-Other-- tecleamos Spring -- elegimos Spring Bean Configuration File.

en el nombre del archivo le ponemos spring o como ustedes quieran ponerle, al momento de grabarlo tenemos cuidado de hacerlo en la carpeta de resources, que esta destinada para los archivos no java en este caso XML, le damos siguiente.

en este paso seleccionamos los namespaces de beans y context que son como los imports para java.

ahora simplemente le damos finish.

Ahora creamos un bean de tipo String en nuestra fábrica de beans (archivo xml).

la propiedad id es su identificador, la propiedad class es el tipo de clase que este bean.


en <constructor-arg value="hola mundo" /> significa que por medio de su constructor le estamos pasando un valor que en este caso es hola mundo.
es como si fuera así.   :)

String cadenaSpring =new String("Hola mundo");



bien ahora vallamos a  la clase Java otra vez y creemos nuestra fábrica de beans de la siguiente manera y corramos el ejemplo.

en la línea 13 creamos nuestra fábrica de spring la cual va leer todos los beans contenido en ella, en este caso nuestro archivo spring.xml.

si tienen dudas sobre esta asignación, no es nada más que downcasting, el cual se explica en este link.
http://tutorialesjavamx.blogspot.mx/2013/08/programacion-orientada-interfaces.html



en la línea 14 obtenemos nuestro bean por medio de su id y se lo asignamos a una variable del mismo tipo.

en la línea 15 imprimos su valor.

listo, con esto tenemos un hola mundo sencillo con spring, estaremos subiendo ejemplos poco a poco más complejos, saludos.

Programación orientada a Interfaces

Uno de los temas más importante y quizás que muchos desarrolladores no toman en cuenta, es la programación basada en interfaces o programación orientada a interfaces, y este tema es uno de los más importantes para tener buenas prácticas de programación y tener códigos escalables.

 Y bueno.

¿Qué es la Programación orientada a Interfaces?

Bueno, la programación orientada a interface esta basada en la creación de una interface a la cual se le generan n implementaciones para así disminuir el código intrusivo en nuestro sistema, creando atributos de tipo interface en lugar de clases concretas. 

veamoslo con ejemplo:

Supongamos que tenemos la interface Herramienta.

public interface Herramienta {

String getNombre();
String getHabilidad();


}

Esta interface contiene dos métodos, bueno sabemos que en una interface todos sus métodos no tienen implementación y por dafult son públicos.  solo se definen los métodos pero no se implementan a diferencia de las clases concretas.

¡¡¿¿¿???!!! What do that fuck?? que es una interface y que es una clase concreta.

ok.

bueno les presento a la interface. :)

public interface Interface{

void nombreMetodo();
String nombreMetodo();


}

Ahora les presento a la clase concreta :)

public class ClaseConcreta{

String nombreMetodo(){

         }
String getHanombreMetodobilidad(){
     
        }


}

ok, bien, entonces en resumen, una interface no tiene implementación de sus métodos, mientras que una clase concreta tiene implementación en todos sus métodos, esto nos lleva a recordar otro tipo de clase llamada clase Abstracta, que se encuentra entre las interfaces y las clases concretas. ya que puede ser un híbrido, algunos de sus métodos pueden ser abstractos y otros no. veamoslo como sería una clase abstracta.

public abstract class ClaseAbstracta {

/**

* @param args

*/

public void metodoConcreto(){

}

abstract void metodoAbstracto();

}

como podemos ver, para definir una clase abstracta, debemos anteponer la palabra reservada abstract antes de la palabra reservada class, y si queremos que un método sea abstracto debemos anteponer la palabra abstract antes del tipo de retorno del método.

entonces visto esto, vemos que tenemos 3 niveles de abstracción.

1.- primero las interfaces --> 100% abstractas

2.- segundo las clases abstractas --> no se sabe, depende como lo decida el programador.

3.- tercero las clases concretas  --> 100 % concretas .

ya aclarado esto, vamos a continuar.

ok, regresemos a la interface Herramienta.

public interface Herramienta {

String getNombre();
String getHabilidad();


}

upss, apenas voy a empezar con el tema :S  ,  ok, pues como ya tenemos la interface, ahora vamos a crear una implementación de la misma, es decir una clase que implemente sus dos métodos en este caso.

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";

}

}

una clase para poder implementar una interface debe hacerlo con el operador implements seguido del nombre de la interface a implementar, de hecho puedes implementar más de una interface en una misma clase, a diferencia de la herencia que solo puedes heredad de una.

podemos ver que si no ponemos los métodos de getNombre y getHabilidad nos marcaría error en tiempo de compilación diciendo o que la clase no es abstracta o que no hemos implementado los métodos de la interface, en este caso es la segunda opción.

bien, yo creo que todos vamos bien hasta aquí, así que seguiré para crear otra implementación llamada Jeringa:

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 "hacer sufrir";

}

}

cae bajo las mismas reglas que martillo.

ahora que ya tenemos dos clases concretas ( Martillo y Jeringa) que implementan de la interface Herramienta, vamos a crear otra clase concreta llamada Trabajador.

la cual quedaría de la siguiente forma.

public class Trabajador {

private Herramienta herramienta;

public Herramienta getHerramienta(){

       return herramienta;

}

public void setHerramienta(Herramienta herramienta){

   this.herramienta=herramienta;

 }

}

podemos ver que tiene un atributo de tipo Herramienta, el cual es un tipo interface.

Ya que estamos hablando de manera muy abstracta, al trabajador no le importa el tipo de Herramienta que utilice, pero si le damos vida a ese trabajador, por así decirlo, es decir que ese trabajador fuera un chofer, un che, un ingeniero, un vendedor, etc, etc, etc. su herramienta podría variar, en términos de programación estamos dejando de ser tan intrusivos en la clase Trabajador, ya que el puede implementar su Herramienta sin alterar el código de Trabajador, bueno veámoslo como podemos cambiar dicha implementación de su herramienta.

para eso vamos a crear una clase con un método Main.

Como podemos ver en la imagen, en la linea 21, tenemos el proceso de downcasting, que no es más que implementar una interface con alguna de sus implementaciones.

Se llama downcasting, porque si lo vemos de una forma jerárquica, sería de la siguiente manera.

 entonces como martillo o Jeringa esta abajo de Herramienta, por eso se llama downcasting , anyway ....


bien, ahora vamos a implementar la misma  herramienta pero como Jeringa, así que veamos la imagen.

Como podemos ver con tal solo cambiar una palabra, nuestra implementacion del método getNombre() de la herramienta cambio, pero bueno estamos hablando de una insignificante salida en un método print(), sin embargo si lo trasladamos a un sistema real, esto nos ahorraría mucho tiempo de programación y nuestro sistema sería altamente escalable y no intrusivo, que quiero decir con no intrusivo, bueno a la clase Trabajador no se le tubo que hacer ningún cambio al tener un tipo interface en lugar de clase concreta como atributo.

Herramienta herramienta;


pero como se vería si fuera código intrusivo?..,
a pues así.

Martillo martillo;
o
Jeringa jeringa;


y pues esto nos hubiera llevado a cambiar también los constructores y setters y getters de nuestro atributo, que feo :(

pero al usar la programación orientada a interfaces nos ahorramos eso.

bueno espero les sirva y saludos.