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

¿Qué es Maven?, instalación y configuración

¿Qué es Maven?

Es una herramienta open source para la gestión y creación de proyectos de software.

Controla desde el ciclo de vida de un proyecto hasta la generación de un binario que se pueda distribuir con el proyecto.

Maven fue creado por Apache con el fin de complementar a Ant, la cual es la herramienta de compilación numero 1 en el mundo Java, o lo era :).  Maven puede integrar ciertas funcionalidades con Ant, y aunque no se pensó como un sustituto de dicha tecnología (Ant) y más bien como un complemento de la misma, Maven ha ido ganando territorio por su fácil uso.

Bueno procedamos  a instalarlo y configurarlo.

Instalación y configuración

para eso vallamos al siguiente link y descarguemos la versión acorde a nuestro sistema operativo.


http://maven.apache.org/download.cgi

Una vez descargado, vallamos a configurarlo.

supongamos que lo descargue en el siguiente directorio.

Lo que procede ahora es configurar las variables de entorno necesarias para su correcto funcionamiento vía consola.



bien primero tenemos que tener configurado nuestra variable

JAVA_HOME.

si tienes duda de como se configuran las variables del sistema te recomiendo cheque esta entrada.

http://tutorialesjavamx.blogspot.mx/2013/08/instalacion-y-configuracion-del-jdk.html

ok, de la misma manera de como se configura la variable JAVA_HOME, vamos a proceder a crear la variable  M2_HOME

y como último paso modificamos nuestra variable path.

si todo salio bien, entramos a consola y tecleamos mvn -version y debes obtener una salida similar a la de la imagen

bueno con esto ya tenemos listo Maven, en las demás entradas de esta herramienta platicaremos más a fondo sobre sus bondades, 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.