Curso de AngularJS y REST

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== 10.3 Spring ======
En este tema vamos a ver como poner en marcha una aplicación web que haga uso del framework Spring. Spring es un framework que al día de hoy es muy amplio y dispone de muchas funcionalidades. Nosotros en este curso solo vamos a ver la funcionalidad de:
  * [[patrones:di|Inyección de dependencias]]
  * Spring MVC


===== Instalacion =====
Para usar Spring es necesario:
  * [[#libreria_de_spring|Las librerias de Spring]]
  * [[#libreria_de_apache_commons_loggin|Las librerias de Apache Commons Loggin]]

==== Libreria de Spring ====
Descargar un fichero zip llamado ''spring-framework-4.x.y.RELEASE-dist.zip'' ((Siendo ''x'' y ''y'' la versión a descargar)) de la siguiente página:
  * [[http://maven.springframework.org/release/org/springframework/spring/]]


Los ejemplos de este curso han sido hechos con la versión 4.0.6 y el enlace directo es:
  * [[http://maven.springframework.org/release/org/springframework/spring/4.0.6.RELEASE/spring-framework-4.0.6.RELEASE-dist.zip|spring-framework-4.0.6.RELEASE-dist.zip]]


Una vez descargado hay que:
  * Crear una nueva carpeta llamada ''lib'' en la raiz del proyecto donde lo vayamos a utilizar Spring.
  * Descomprime el fichero ''spring-framework-4.0.6.RELEASE-dist.zip''
  * Dentro de la carpeta que acabamos de descomprimir ir a la carpeta ''libs'' y copiar los siguientes jars en la nueva carpeta ''lib'' de nuestro proyecto:
    * ''spring-aop-4.0.6.RELEASE.jar''
    * ''spring-beans-4.0.6.RELEASE.jar''
    * ''spring-context-4.0.6.RELEASE.jar''
    * ''spring-context-support-4.0.6.RELEASE.jar''
    * ''spring-core-4.0.6.RELEASE.jar''
    * ''spring-expression-4.0.6.RELEASE.jar''
    * ''spring-web-4.0.6.RELEASE.jar''
    * ''spring-webmvc-4.0.6.RELEASE.jar''
  * Añadir los jars de la carpeta ''lib'' al proyecto usando rutas relativas.


==== Libreria de Apache Commons Loggin ====
Spring necesita de la librería [[http://commons.apache.org/logging/|Apache Commons Loggin]], así que deberemos descargala y añadir también ciertos JARs a nuestros proyectos.

Descargar el fichero zip llamado ''commons-logging-1.x-bin.zip'' ((Siendo ''x''  la versión a descargar)) de la siguiente página:
  * [[http://commons.apache.org/proper/commons-logging/download_logging.cgi]]

Los ejemplos de este curso han sido hechos con la versión 1.2 y el enlace directo es:
  * [[http://apache.rediris.es//commons/logging/binaries/commons-logging-1.2-bin.zip|commons-logging-1.2-bin.zip]]

Una vez descargado hay que:
  * Descomprime el fichero ''commons-logging-1.2-bin.zip''
  * Dentro de la carpeta ( o subcarpetas) que acabamos de descomprimir  copiar los siguientes jars en la carpeta ''lib'' de nuestro proyecto:
    * ''commons-logging-1.2.jar''
  * Añadir el jar de la carpeta ''lib'' al proyecto usando rutas relativas.

===== Configurando Spring =====
Una vez tenemos los jars que necesitamos para que funcione la aplicación en necesario configurar nuestra aplicación web para que funcione Spring. Para ello es necesario crear y configurar 3 ficheros:
  * [[#webxml|web.xml]]
  * [[#dispatcher-servletxml|dispatcher-servlet.xml]]
  * [[#applicationContextxml|applicationContext.xml]]

==== web.xml ====
El fichero ''web.xml'' debe estar en la carpeta ''WEB-INF'' en las carpetas web.  Es un fichero estándar de aplicaciones web en Java 

Su contenido es el siguiente:
<sxh xml;highlight: [18,28]>
<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener> 
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>    

    <servlet>
        <servlet-name>dispatcher</servlet-name> 
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup> 
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name> 
        <url-pattern>/api/*</url-pattern>
    </servlet-mapping>
</web-app>
</sxh>
  * Línea 14: Indicamos que al iniciar la aplicación se ejecute la siguiente clase de Spring ''org.springframework.web.context.ContextLoaderListener''. Esta clase es la que inicializará todo el framework.
  * Línea 18: Le indicamos que en el paquete raiz de Java ''classpath'', se encuentra el fichero de configuración de Spring llamado ''applicationContext.xml''.
  * Línea 23: Definimos un servlet desarrollado por Spring llamado ''org.springframework.web.servlet.DispatcherServlet''. Este servlet será el encargado de procesar todas nuestras peticiones REST.
  * Línea 28: Le indicamos la URI que debe procesar el servlet de Spring y a partir de la cual estarán todas las URI de nuestros servicios REST, que es ''/api/*''

Este fichero para cualquier proyecto lo podemos siempre pegar tal y como está ya que siguiendo nuestra arquitectura, la URI de nuestros servicios RST siempre empezará por ''/api'' y el fichero de configuración de Spring siempre lo llamamos ''applicationContext.xml'' y estará en el paquete raíz de las clases Java.


==== dispatcher-servlet.xml ====
El fichero ''dispatcher-servlet.xml'' debe estar en la carpeta WEB-INF en las carpetas web. El fichero ''dispatcher-servlet.xml'' es el fichero de configuración de la parte web de Spring, por lo tanto solo es necesario si estamos haciendo una aplicación web.

Su contenido es el siguiente:
<sxh xml;highlight: [12]>
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:mvc="http://www.springframework.org/schema/mvc" 
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd 
">

    <context:component-scan base-package="NOMBRE_DEL_PAQUETE_DE_LOS_CONTROLADORES_DE_SPRING" />
    
</beans>
</sxh>
  * Linea 12: Le debemos indicar el paquete Java donde se encuentran los controladores web que usaremos. Además permite que usemos anotaciones de Spring en nuestros controladores.

<note warning>
Recuerda modificar la línea ''<context:component-scan base-package="NOMBRE_DEL_PAQUETE_DE_LOS_CONTROLADORES_DE_SPRING" />'' para poner el nombre del paquete Java donde se encuentran los controladores web de tu aplicación.
</note>
==== applicationContext.xml ====
El fichero ''applicationContext.xml'' se encuentra en la carpeta raíz de las clases Java. Su nombre y su ubicación la hemos definido en el fichero ''web.xml'' aunque lo normal es que en todos los proyectos se llame  así y esté en esa carpeta. 

Su utilidad es configurar Spring en toda la parte que no tiene nada que ver con la web. Lo normal es poner aquí las clases que queremos que se puedan inyectar desde Spring. Lo podemos ver como nuestro //configurador// de inyección de dependencias. Aqui podremos las FQCN ((Fully-Qualified Class Name. Es decir el nombre completo de una clase Java incluyendo el paquete al que pertenece.)) de las clases que queremos que se puedan inyectar.

<sxh xml;title:applicationContext.xml;highlight: [10,12]>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
">
 
    <context:annotation-config/>
 
    <bean class="FQCN_DE_UNA_CLASE_JAVA_QUE_QUEREMOS_PODER_INYECTAR" />


</beans>
</sxh>
  * Linea 10: Permite que usemos anotaciones de Spring en nuestras clases Java como por ejemplo ''@Autowired''
  * Línea 12: Esta línea indica que tenemos una clase Java que podrá ser inyectada por Spring.Hay que poner en el atributo ''class'' la FQCN ((Fully-Qualified Class Name. Es decir el nombre completo de una clase Java incluyendo el paquete al que pertenece.)) de la clase Java. Esta línea se puede repetir tantas veces como queramos para cada una de las clases que queramos que se puedan inyectar. O borrarla si no hay ninguna.

<note warning>
Recuerda borrar la línea ''<bean class="FQCN_DE_UNA_CLASE_JAVA_QUE_QUEREMOS_PODER_INYECTAR" />'' si no hay nada que inyectar o repetirla tantas veces como clases tengas para ser inyectadas por Spring.
</note>
===== Ejemplo =====
El ejemplo consiste en crear un sencillo controlador para probar que está bien configurado Spring.

Para crear el ejemplo deberemos hacer primeramente lo siguiente:
  * Desde NetBeans crear un nuevo **projecto Web**
  * Añadir las librerías de Spring
  * Añadir las librerías de Apache Commons Loggin
  * Añadir el fichero ''web.xml''
  * Añadir el fichero ''dispatcher-servlet.xml''
  * Añadir el fichero ''applicationContext.xml''

Una vez hecho esto vamos a crear una clase Java llamada ''UsuarioController'' que actuará como controlador web. La clase debe estar en el paquete ''es.cursohibernate.spring.controller''.

Su código es el siguiente:
<sxh java;title:UsuarioController.java;highlight: [16]>
package es.cursohibernate.spring.controller;

import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
public class UsuarioController {
    
    
    @RequestMapping(value = {"/Usuario"})
    public void prueba(HttpServletRequest httpRequest, HttpServletResponse httpServletResponse) throws IOException {
        httpServletResponse.getWriter().println("Hola Mundo");
    }
}
</sxh>
  * Línea 16: Lo que se pase al método ''println'' es lo que se mostrará por pantalla al navegar a la URL [[http://localhost:8084/spring/api/Usuario]].

Y por ahora no voy a explicar casi nada de esta clase ya que en siguientes temas hablaremos de los controladores y el objeto de este ejemplo es ver si Spring estaba bien configurado.

Una vez tenemos ésto hay que personalizar los ficheros ''dispatcher-servlet.xml'' y ''applicationContext.xml'' para ello deberemos:
  * Modificar el fichero ''dispatcher-servlet.xml'' para indicar que el paquete de los controladores es ''es.cursohibernate.spring.controller''
  * Modificar el fichero ''applicationContext.xml'' y eliminar todas las líneas con ''<bean class="FQCN_DE_UNA_CLASE_JAVA_QUE_QUEREMOS_PODER_INYECTAR" />'' ya que no hay ninguna clase a inyectar.

Ahora ya podemos ejecutar la aplicación. Aparecerá el siguiente mensaje en la pantalla "TODO write content" . Esto significa que la aplicación ha arrancado , pero lo importan es navegar a [[http://localhost:8084/spring/api/Usuario]] y ver que aparece el texto "Hola Mundo".

Si has visto el texto "Hola Mundo", ¡Felicidades! Ya has conseguido hacer tu primera aplicación con Spring. 

<note>
Este ejemplo se encuentra en  git en [[https://github.com/logongas/cursoangularjs/tree/master/spring]]
</note>

===== Referencias =====
  * [[http://projects.spring.io/spring-framework/|Spring Framework]]