Tutorial: Hola Mundo Spring - Conceptos básicos

Se creará una aplicación básica “Hola Mundo”, que permita mostrar los componentes básicos de una aplicación con spring MVC. Se creará una pantalla inicial con un enlace a una segunda pantalla que devuelva la hora y fecha del sistema.

Se muestra la configuración de Spring en XML para tratar de explicar los conceptos con claridad, más adelante se mostrará la configuración de Spring con Java que es como se trabajará finalmente.

Contenido
Crear proyecto en Eclipse
Configuración del POM
Controlador Web
Creación de JSP
Configuración de Spring
El servicio
Inyección de Dependencias
Prueba en Weblogic

Procedimiento

Crear proyecto en Eclipse

Cambiar a la perspectiva JEE en Eclipse:

Crear un nuevo proyecto: Dynamic Web Project:

Seleccionar un nombre, seleccionar el Runtime creado para Weblogic 12C en el capitulo de configuración:

Finalizar, el proyecto creado aparecerá en el Project Explorer:

Convertir  proyecto a Maven: Clic derecho sobre el proyecto creado, --> Configure --> Convert to Maven Project:

Dejar los valores por defecto. Finalizar. Se ha convertido el proyecto a Maven:

Navegar en el proyecto, que tendrá una estructura similar a:

Configuración del POM

Abrir el archivo de configuración de Maven POM.XML:

Pasar a la pestaña pom.xml para ver el archivo de configuración en XML:

Por defecto el POM se verá así:

<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>SWHelloWorld</groupId>
  <artifactId>SWHelloWorld</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.5.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>2.6</version>
        <configuration>
          <warSourceDirectory>WebContent</warSourceDirectory>
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Este archivo contiene la información de la complicación y de las dependencias de librerías que necesite el proyecto.

A groso modo: Las etiquetas iniciales son de información del proyecto, la etiqueta <packaging> indica el tipo de despliegue, y la etiqueta <build> indica el directorio y los artefactos de compilación.

La parte de configuración <configuration> <source>1.8</source> <target>1.8</target> </configuration> indica la versión de java.

Para empezar a usar Spring MVC, en éste archivo se debe indicar las dependencias a las librerías de Spring adicionándolas dentro de la etiqueta <dependencies> así:

        <dependencies>
    <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>4.3.1.RELEASE</version>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-aop</artifactId>
   <version>4.3.1.RELEASE</version>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>4.3.1.RELEASE</version>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-web</artifactId>
   <version>4.3.1.RELEASE</version>
  </dependency>  
 </dependencies>

Guardar y cerrar el POM.

Controlador Web
Todas las aplicaciones en Spring deben contar con un Controlador Web, para crear la clase del controlador, clic derecho sobre la carpeta Java Resources --> src del proyecto:

Crear un paquete.

Clic derecho sobre el paquete creado: New --> Class:

Se creará la clase HelloWorldController dentro de un paquete llamado controller:

Para hacer que ésta sea la clase ce controlador de Spring se debe adicionar las anotaciones respectivas:

• @Controller: Que indica que es el controlador web.
• @RequestMapping("/"): Para éste caso "/" indica que es para  las solicitudes root. RequestMapping puede ser usado en el nivel de clase o en el nivel de método. (Ver Anotación RequestingMapping). Cuando se usa RequestMapping en un método significa que se ejecutará en las solicitudes provenientes de esa URL, por ejemplo: @RequestMapping("/login") se ejecutará por el controlador con las solicitudes a "/login". Es importante tener en cuenta que si se define un RequestMapping de clase, actuará como padre de los RequestMapping de los métodos, ejemplo: Si en la clase se usa @RequestMapping("/paper"), y en el método de esa clase se usa: @RequestMapping("/add"), se ejecutará con las solicitudes a "/paper/add". 

La clase HelloWorldController se verá así:

package package.sw.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/")
public class HelloWorldController {

 public HelloWorldController() {
  // TODO Auto-generated constructor stub
 }

}

Dentro de la clase se crea el método viewDate con la anotación RequestMapping: @RequestMapping("/welcome"), para éste caso significa que se ejecuta con las solicitudes hacia welcome.

El Método retornará el objeto org.springframework.web.servlet.ModelAndView de Spring, que tiene varias sobrecargas de constructor y permite devolver al navegador la respuesta y si es necesario el paso de parámetros. Por ejemplo: return new ModelAndView("welcome"); envía al recurso (jsp) llamado welcome.

La clase deberá quedar así:

package package.sw.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/")
public class HelloWorldController {

 @RequestMapping("/welcome")
 public ModelAndView viewDate () { 
  return new ModelAndView("welcome");
 }

}

Lo que significa que al hacer una petición GET desde "/welcome" de la aplicación se ejecuta el método viewDate() que envía al recurso welcome.


Creación de JSP

La aplicación tiene por defecto in index.html, el cual se borrará para crear el index.JSP.

Borrar el index.html.

Click derecho en la carpeta WebContent --> New à JSP File

Nombrarlo como "index.jsp", crear el contenido con un enlace hacia welcome así: 

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
 <h1>Esta es la prueba de Hola Mundo Spr</h1>
 <a href="welcome">Dar Click acá</a>
</body>
</html>

IMPORTANTE: El nombre welcome en el enlace debe ser el que se mapeó en el controlador @RequestMapping("/welcome").

Ahora se creará el welcome.jsp, se debe crear en WEB-INF/jsp.

Clic derecho en la carpeta WEB-INF-->New-->Folder nombrarlo como jsp. Clic derecho en la carpeta jsp creada, --> New --> JSP File. Nombrarlo como "welcome.jsp" con el siguiente contenido:

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
 <h2>Respuesta desde el controlador Spr</h2>
 <h3>Esta es la fecha y hora actual: ${fechaHora} }</h3>
</body>
</html>

A este punto el proyecto se verá similar a:

Configuración de Spring

Archivo de aplicación Web.xml:

Verificar si existe el archivo web.xml dentro de la carpeta WEB-INF. Si no existe crearlo: Clic derecho en la raíz del proyecto --> Java EE Tools --> Generate Deployment Descriptor Stub:

Abrir el archivo creado:

Se ha creado el archivo con el siguiente contenido:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>SWHelloWorld</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
</web-app>

A éste archivo es necesario adicionarle la configuración de Servlets de Spring:

<servlet>
        <servlet-name>springServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
        <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/spring-servlet.xml</param-value>
  </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

Donde se define, un nombre de servlet, por ejemplo springServlet o el que se desee. 

La clase del servlet, que para spring es org.springframework.web.servlet.DispatcherServlet, y en las etiquetas de parámetros el nombre del archivo donde se manejará la configuración de spring, en el ejemplo /WEB-INF/spring-servlet.xml archivo que se debe crear más adelante.

En el web.xml se define también el archivo de contexto para la aplicación, que aunque puede ser el mismo lo recomendable es manejar los archivos separados por su función. Este es el archivo donde se definen temas de aplicación como definiciones de anotaciones, etc.

<!-- Configuración global del contexto -->
    <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

En el ejemplo /WEB-INF/applicationContext.xml archivo que se debe crear más adelante.

El web.xml deberá verse similar a:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>SWHelloWorld</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <servlet>
        <servlet-name>springServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
        <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/spring-servlet.xml</param-value>
  </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <!-- Configuración global del contexto -->
    <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
  
</web-app>

Archivo de Spring spring-servlet.xml:

Click derecho en el directorio WEB-INF --> New --> File

En Filename: spring-servlet.xml --> Finish

En éste archivo se definen los beans de la aplicación dentro de las etiquetas <beans>.

El archivo debe tener la siguiente estructura:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">
        
    <context:component-scan base-package="package.sw.controller" />
 
 <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
  <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
  <property name="prefix" value="/WEB-INF/jsp/" />
  <property name="suffix" value=".jsp" />
 </bean>
 
 <mvc:annotation-driven />
</beans>

Donde se define el paquete base de búsqueda para el controlador, para el ejemplo "package.sw" y se define el bean del controlador indicándole el directorio de búsqueda, para el caso "/WEB-INF/jsp/".  También el tag <mvc:annotation-driven /> que permite el envío de solicitudes al controlador.


Archivo de Spring applicationContext.xml:

Click derecho en el directorio WEB-INF --> New --> File

En Filename: applicationContext.xml --> Finish

Es otro archivo de beans con la estructura similar, pero donde irán las etiquetas asociadas a la aplicación.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">
        
     <context:component-scan base-package="package.sw.*" />

</beans>

Para éste caso el component-scan, que define el paquete de búsqueda de anotaciones (ej: @Service, @Repository etc. en "package.sw.*".



El servicio

Normalmente se definen clases de servicio en donde está la lógica de la aplicación Web. En éste tutorial se creará una clase de servicio que tendrá un único método que devuelve una cadena con la fecha y hora. 

Dar clic derecho sobre el directorio Java Resources --> src del proyecto, New --> Class

Crear la clase HelloWorldService en el paquete package.sw.service

Esta clase servirá como interface, y se verá así:

package package.sw.service;

public interface HelloWorldService {

 public String getDateTime();

}

Se creará una clase Java con la implementación de la lógica del servicio, para éste caso la clase tendrá la implementación del método que devuelve el String con la fecha y hora.

Dar click derecho sobre el directorio Java Resources --> src del proyecto. --> New --> Class

Crear la clase HelloWorldServiceImpl en el paquete package.sw.service.impl

Esta clase implementa HelloWorldService y debe tener la anotación @Service.

La clase se verá similar a:

package package.sw.service.impl;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.stereotype.Service;

import package.sw.service.HelloWorldService;

@Service
public class HelloWorldServiceImpl implements HelloWorldService{

 public HelloWorldServiceImpl() {}
 
 public String getDateTime()
 {
  SimpleDateFormat sdf = new SimpleDateFormat("dd/M/yyyy hh:mm:ss");
  String date = sdf.format(new Date());
  
  return date;
 }

}

En éste punto ya se tienen los componentes de configuración y de implementación.


Inyección de Dependencias

Ahora se hará la invocación del servicio que devuelve la fecha y hora, desde el controlador.

Modificar la clase del controlador: Se usará la anotación @autowired para que Spring busque un bean que cumpla los requisitos para ser inyectado, en este caso el único requisito es que sea del tipo HelloWorldService.

        
@Autowired
private HelloWorldService helloWorldService;

Y se modifica la operación del controlador controlador para que devuelva el parámetro fechaHora que espera el welcome.jsp.

String fechaHora = helloWorldService.getDateTime();
return new ModelAndView("welcome", "fechaHora", fechaHora);

Con ésto ya se ha inyectado la clase del Servicio en el controlador y se puede hacer uso de las Operaciones del Servicio.

La clase se deberá ver similar a:

package package.sw.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import package.sw.service.HelloWorldService;

@Controller
@RequestMapping("/")
public class HelloWorldController {

 @Autowired
 private HelloWorldService helloWorldService;
 
 @RequestMapping("/welcome") 
 public ModelAndView viewDate () { 
  String fechaHora = helloWorldService.getDateTime();  
  return new ModelAndView("welcome", "fechaHora", fechaHora);
 }

}

Prueba en Weblogic 12c

Para probar el proyecto en Weblogic se debe tener en ejecución el servidor, mediante Start o Debug.

Click derecho en el proyecto --> Maven --> Update Project --> OK

Luego ir al servidor en la pestaña Servers, Click derecho --> Add and Remove…

Adicionar el proyecto y Finalizar.

Inicia la publicación y va mostrando el avance tanto en la pestaña de ErrorLog como en la de Console si se llegan a presentar errores. Al finalizar la publicación aparece:

Una vez publicada la aplicación, se puede acceder a través de un navegador mediante la URL teniendo en cuenta el puerto usado en Weblogic Server (WLS), para éste caso se usó el puerto por defecto del WLS integrado 7101.

http://localhost:7101/SWHelloWorld/

Clic en el enlace, si no existe ningún inconveniente, debe aparecer:

Resumen:

Se hizo una aplicación con Spring MVC básica en donde se pudo ver la inversión de control con el servlet controlador de spring, antes se enviaba la petición desde la vista, ahora el controlador de spring dependiendo de la solicitud mapeada (Request Mapping) dispara la lógica del controlador, y la inyección de dependencias a través del uso de un servicio y el manejo del flujo de la aplicación.