Introduccion a Spring con Netbeans y Maven

Vamos a ver que es Spring, este Framework tan solicitado en puestos de Trabajo y que simplifica mucho el desarrollo de proyectos grandes en las empresas, como funciona, porque debes de aprenderlo y utilizarlo. Para este Articulo tambien veremos que es Maven, resolveremos dependencias de Spring a traves de el, veremos como descargarlo, instalarlo y configurarlo. Todo esto en la plataforma Netbeans, donde realizaremos nuestro primer proyecto incluyendo estos 3 elementos: Netbeans, Maven y Spring, asi que vamos ya a la informacion..

Enlaces

Que es Spring Framework?

Para comenzar con esta introduccion a spring tenemos que saber primero que es, Spring es un Framework que nos da una infraestructura base para nuestros proyectos en Java. Tu te centras en programar los distintos componentes de tu aplicacion sin importarte la estructura y spring funcionara como un enlace o pegamento que le dara la estructura correcta a tu proyecto. Spring te permite crear, ademas de proyectos normales de escritorio, crear aplicaciones web utlizando un servidor contenedor de servlets como apache tomcat.

Spring tambien es un framework contenedor de Inversion de Control o de Inyeccion de Dependencias.

Que es la Inyeccion de Dependencias?

Inversion of Control (IoC) o Dependency Injector (DI) en Ingles, se trata de una nueva forma de relacionar los objetos dentro de tu aplicacion. Anteriormente tu injectabas la instancia de un objeto dentro de otro, pero ahora con esta nueva forma de inyectar dependencias quien las inyecta es el framework spring a traves de un archivo XML de configuracion donde especificas los componentes de tu aplicacion y sus respectivas dependencias, despues spring busca estas dependencias y el se encarga de crear sus componentes y relaciones entre ellos ( incluso las ultimas versiones de Spring buscan automaticamente las dependencias con @Autowired ).

Porque Utilizar Spring?

Porque simplifica enormemente el desarrollo de aplicaciones Java. ( se que ya lo has leido mucho :yum: )
Se acopla a tu aplicacion ( no tienes que modificar ni un pelo en tu codigo )
No es necesario implementar alguna interfaz de Spring o heredar alguna clase de Spring ( es como si no estuviera alli :heart_eyes:)
Nuestro codigo sera limpio, elegante y completamente reutilizable ( si o si :yum:)
Inyeccion de Dependencias.
Programacion Orientada a Aspectos( hare un articulo mas adelante exclusivamente de esto porque vale mucho la pena )
Nos Ahorra codigo con Plantillas de Codigo para eliminar codigo boilerplate.

Resolviendo Dependencias con Maven

Al ir al enlace de Spring que te deje arriba en la seccion de enlaces veras que te aparece en QuickStart un Codigo xml en lugar de un enlace tradicional para descargar Spring, esto es porque las nuevas versiones de spring recomiendan resolver sus dependencias con un sistema manejador de dependencias como Maven o Gradle. Aqui utlizaremos maven pero puedes utilizar el que quieras, para instalar maven vamos al enlace de arriba y descarga la version estable al dia que lees esto, en mi caso es la 3.2.1.

Despues de descargar descomprime el archivo en una ruta de tu preferencia en tu PC, luego tienes que agregar el directorio bin de maven a la variable Path del sistema, una vez agregada abre una consola de windows ( Windows+R -> CMD ) y escribe:

mvn -v

para confirmar su correcta instalacion.

Mas adelante una vez creado el proyecto agregaremos las lineas que econtramos en Spring Quick Start a un archivo xml de nuestro proyecto llamado pom, este archivo satisfacera nuestras dependencias y las descargara.

Creando nuestro primer Proyecto con Spring, Netbeans y Maven.

Vamos a Netbeans ( sino lo tienes instalado el enlace esta arriba :yum: ) y vamos a crear un nuevo proyecto. File -> New Project -> Maven -> Java Application ( si en categories no tienes la opcion de maven es porque necesitas instalar la extension de maven para netbeans aqui las instrucciones ) escribimos un nombre y terminamos.

Antes de seguir con java vamos a hacer dos cosas primero, abre la carpeta raiz de tu proyecto y mira que se creo un archivo pom.xml, este es un archivo de maven para resolver dependencias y aqui sera donde pegaremos las lineas que encontramos en la pagina de spring quick start. Agregalas dentro del tag <dependencies> quedara asi:

<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>com.jmr.spring4.web.tutorial1</groupid>
  <artifactid>Cableado_de_Beans_con_Spring</artifactid>
  <version>1.0</version>
  <packaging>jar</packaging>

  <name>Cableado_de_Beans_con_Spring</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project .build.sourceEncoding>UTF-8</project>
  </properties>

  <dependencies>
    <dependency>
      <groupid>junit</groupid>
      <artifactid>junit</artifactid>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
	
	<dependency>
        <groupid>org.springframework</groupid>
        <artifactid>spring-context</artifactid>
        <version>4.0.2.RELEASE</version>
	    <type>jar</type>
	</dependency>
	
  </dependencies>
</project>

Tambien create un archivo en ~TuProyecto~/src/main/resources/context.xml este archivo sera el encargado de crear las relaciones entre los beans ( objetos ) de nuestra aplicacion por Spring. Mas adelante lo modificaremos, por ahora solo crealo.

Volviendo a java tienes que tener las siguiente estructura de clases:

En el Main.java vamos a crear nuestro ApplicationContext que sera nuestro contenedor de beans u objetos y al que le pasaremos la ruta de el archivo xml donde estableceremos nuestros componentes y sus relaciones en nuestra aplicacion. Esta clase quedaria asi:

public class Main 
{
    public static void main( String[] args )
    {
        ApplicationContext ctx = new 
            ClassPathXmlApplicationContext("context.xml");
        Carta carta = (Carta) ctx.getBean("carta");
        System.out.println(carta.getContenido());
    }
}

Aqui seguro si es la primera vez que utizas spring te marcara error de que no encuentra ApplicationContext y ClassPathXmlApplicationContext no te preocupes, intenta importar las dependencias y te dira una opcion que dira que si quieres que busque en las dependencias de maven, dile que si. La primera vez que ejecutes spring tardara algo ya que descargara las librerias de maven no te preocupes es normal y solo es la primera vez.

Ahora la clase Footer es sencilla:

public class Footer implements IFooter {
    String nombre;
    String lugar;
    
    @Override
    public void setNombre(String nombre){
        this.nombre = nombre;
    }
    
    @Override
    public void setLugar(String lugar){
        this.lugar = lugar;
    }
    
    @Override
    public String getFooter(){
        return "A "+new Date()+" Escribe "+nombre+" desde "+lugar;
    }
    
}

Con su Interface IFooter:

public interface IFooter {

    String getFooter();

    void setLugar(String lugar);

    void setNombre(String nombre);
    
}

La clase Carta es como sigue:

public class Carta {
    List< String > body;
    IFooter footer;
    
    public void setBody(List< String > body){
        this.body = body;
    }
    
    public void setFooter(Footer footer){
        this.footer = footer;
    }
    
    public String getContenido(){
        String contenido = "";
        for(String linea : body){
            contenido = contenido + linea + "n";
        }
        contenido = contenido + "n" + footer.getFooter();
        return contenido;
    }
}

y ahora solo falta establecer los beans en el archivo context.xml que creamos antes, como te dije este archivo es lo principal ya que spring leera de ahi nuestro componentes y dependencias que tienen. Este Archivo quedara asi:

< ?xml version="1.0" encoding="UTF-8"?>
< !DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
	<bean id="footer" class="com.jmr.spring4.web.tutorial1.cableado_de_beans_con_spring.Footer">
		<property name="nombre" value="Jonathan Melgoza"></property>
		<property name="lugar" value="Queretaro, Mexico"></property>
	</bean>

	<bean id="carta" class="com.jmr.spring4.web.tutorial1.cableado_de_beans_con_spring.Carta">
		<property name="body">
			<list>
				<value>Querido Lector,</value>
				<value>Espero que te encuentres muy bien aprendiendo Spring con este Articulo,</value>
				<value>si tienes alguna duda ya sabes que puedes dejarte un comentario, Saludos!</value>
			</list>
		</property>
		<property name="footer" ref="footer"></property>
	</bean>
</beans>

Como puedes ver hay una seccion de beans () donde puedes establer tantos beans como quieras, cada bean lleva un id para identificarlo y otro atributo llamado class que es donde esta la clase del bean. Tambien dentro de cada bean hay propiedades con name y value, estos corresponden a los nombres de variables dentro de esas clases. En el bean carta agregamos valores en forma de lista ya que el tipo de valor en el metodo setBody es un List, esta es la forma de agregarlos a una lista. Tambien vez que en el bean carta hay una propiedad llamada footer que hace referencia mediante el atributo «ref» al otro bean, esto se conoce como cableado de beans o wiring.

Concluyendo

Ya hemos visto bastante hoy para introduccion a spring ahora solo a ponernos a pensar un rato asi que hasta aqui lo dejamos por el momento, recuerda que puedes preguntar cualquier cosa y no olvides de regarlarme un +1, like o tweet, espero te haya servido esta informacion, Saludos!