Aunque esto aplica para todo tipo de aplicaciones Java, un buen ejemplo es un servidor de aplicaciones J2EE. En este caso usaré Weblogic.

La parte más “difícil” es agregar algunos argumentos al comando que inicia al Weblogic. Para ello hay que abrir la pantalla Server Start de la instancia de Weblogic que queremos debuggear. La ruta es Environment >> Servers >> [servername] >> Server Start.

En esta pantalla hay un campo Arguments que nos permite mandar parámetros a la máquina virtual al momento de iniciar la instancia de Weblogic. En este campo agregamos lo siguiente:

Hace falta reiniciar la instancia de Weblogic que afectamos para que los cambios surtan efecto.

Ahora solo hay que crear una nueva configuración de Debug para conectarse a la aplicación Java remota. Para ello haz clic sobre Run >> Debug Configurations. En seguida crea una nueva configuración bajo la categoría de Remote Java Application y usa los siguientes datos como referencia:

Asegúrate de que el servidor Weblogic esté corriendo y que alguno de tus proyectos de Eclipse esté corriendo sobre el servidor. Ahora haz clic sobre el botón Debug para conectarse al servidor Weblogic y empezar a cachar las llamadas al debugger.

Eso fue todo. Es bastante sencillo pero muy útil cuando se requiere depurar una aplicación web que está un ambiente remoto.

Bueno, esas son algunas de las características de la versión Community. La versión completa cuesta USD$99 al año y cuenta con algunas otras monerías, como interactuar con una base de datos real en lugar de un script SQL, generar documentación y algunas otras cosas más. Sin embargo, la versión gratuita está muy completa.

Para lograrlo se utiliza un concepto muy interesante llamado Inversión del Control, también conocido como el principio Hollywood: “No nos llames, nosotros te llamaremos.” Esto permite que el código escrito por los desarrolladores para la lógica principal del sistema no tenga dependencias sobre las clases del framework; lo cual redunda en un código mucho más limpio y con la posibilidad de utilizar todas las ventajas de la programación orientada a objetos (específicamente la herencia).

Ya que tenemos una idea de la utilidad de Spring MVC, pongamos manos a la obra.

Objetivos:

Prerequisitos:

1. Instalando herramientas necesarias en Eclispe

Para empezar hay que instalar las herramientas necesarias para desarrollar una aplicación Web con Eclipse. Primero abre la ventana de instalación de nuevos paquetes haciendo click en la ruta Help >> Software Updates >> Find and Install…
Selecciona la opción Search for new features to install y haz click en Next.

Selecciona Europa Discovery Site.

Haz click en Finish y selecciona un mirror. En la pantalla siguiente selecciona Web and JEE Development, te marcará un error diciendo que las dependencias no están satisfechas, para lo cual presionamos el botón Select Required.

Después haz click en Next, acepta las licencias, de nuevo click en Next y luego en Finish. El manejador de actualizaciones empezará a descargar los paquetes necesarios.

2. Creando un proyecto Web

Una vez terminada la descarga e instalación haz click en File >> New >> Project. Selecciona Web >> Dynamic Web Project y haz click en Next. Elige un nombre para el proyecto (este nombre formará parte del URL), yo llamaré a mi proyecto spring1. Por último haz click en Finish.

Ahora vamos a integrar nuestra instalación de Tomcat para controlarla desde Eclipse, para lo cual vamos a Window >> Show View >> Other. En esta ventana selecciona Servers y haz click en Ok.

Para crear un nuevo servidor en Eclipse haz click derecho sobre el espacio blanco de la vista Servers y haz click en New >> Server. Elige el servidor que estarás usando (para efectos de este tutorial usaremos Tomcat, pero puede ser cuelquier otro contenedor de servlets, como JBoss o Weblogic).

Haz click en Next. En la siguiente pantalla selecciona la carpeta en la que se encuentra instalado Tomcat y haz click en Finish. Debe aparecer una nueva entrada en la vista Servers representando al servidor Tomcat que acabas de configurar.

Ahora agreguemos nuestro proyecto al Tomcat para que haga el deploy automáticamente, para lo cual hay que hacer click sobre el servidor Tomcat y luego en Add and Remove Projects. Aparecerá la siguiente ventana, donde hay que pasar el proyecto spring1 de Available Projects a Configured Projects y luego haz click en Finish.

Es hora de probar que todo funcione hasta ahora. Haz click derecho sobre el del servidor que acabamos de configurar y luego en Start. A continuación se mostrará la consola del servidor, el cual debe arrancar sin problemas. Ahora abre tu navegador favorito y abre la dirección http://localhost:8080/spring1/. Si se muestra un error 404 todo está bien (hasta ahora). El error es por que no hemos creado una página de inicio; según nuestro archivo WebContent/WEB-INF/web.xml se debe llamar index.jsp, por lo que procedemos a crearlo (en la carpeta WebContent):

<?xml version="1.0" encoding="UTF-8" ?>
<%@ page language="java" contentType="text/html; charset=UTF-8"
		pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
		"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
		<title>Hola Mundo!</title>
	</head>
	<body>
		Hola Mundo!
	</body>
</html>

Si vuelves a checar http://localhost:8080/spring1/ te aparecerá el contenido de index.jsp.

3. Spring MVC

Por si no lo han notado aún, lo que hemos hecho hasta ahora no ha tenido mucho que ver con Spring. Esto se debe a que solo hemos configurado un ambiente para desarrollo de aplicaciones JEE, lo cual nos facilitará las cosas para crear nuestra aplicación Spring MVC.

Ahora viene lo bueno. A manera de resumen, para crear un proyecto (mínimo) Spring MVC hay que seguir los siguientes pasos:

3.1 Colocar las librerías necesarias

Copia los siguientes archivos a la carpeta WebContent/WEB-INF/lib del proyecto:

3.2 Configurar al DispatchServlet como FrontController

Agrega lo siguiente al archivo WebContent/WEB-INF/web.xml dentro del tag web-app. El nombre que le daremos a este Servlet también será muy importante, ya que formará parte del nombre de el(los) archivo(s) de configuración del contexto del FrontController, donde definiremos los Beans que formarán nuestra aplicación.

<servlet>
	<servlet-name>spring1</servlet-name>
	<servlet-class>
		org.springframework.web.servlet.DispatcherServlet
	</servlet-class>
	<load-on-startup>1</load-on-startup>
</servlet>

La anterior definición solo le dice a Tomcat que cargue al DispatcherServlet al iniciar. Ahora hay que decirle qué URLs serán procesadas por Spring. Como pueden ver, el url-pattern incluye todas las direcciones que terminan con .jsp, en realidad esta es una terminación arbitraria y podemos sustituirla por cualquier cosa.

<servlet-mapping>
	<servlet-name>spring1</servlet-name>
	<url-pattern>*.jsp</url-pattern>
</servlet-mapping>

3.3 Configurar un View Resolver para asociar las vistas a los controladores

El View Resolver es un bean que se define en el contexto de la aplicación (del DispatcherServlet). Para lo cual debemos crear un archivo llamado spring1-servlet.xml en la carpeta WebContent/WEB-INF/. El archivo tiene el siguiente contenido:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
		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-2.5.xsd">

	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/jsp/" />
		<property name="suffix" value=".jsp"/>
	</bean>
</beans>

En el código anterior hay tres cosas que notar: 1) El View Resolver que se utiliza. InternalResourceViewResolver es uno de los más sencillos y fáciles de usar, pero existen otros con mayor flexibilidad. 2) La property “prefix” define la carpeta en donde se encuentran las vistas. 3) La property “suffix” define la extensión de los archivos de las vistas.

3.4 Escribir un controlador y agregarlo al contexto del DispatcherServlet

Spring MVC prevee varios tipos de controladores que tienen usos diferentes, por ejemplo:

En este caso usaremos el más sencillo: AbstractController.

package com.andreimosso.spring1.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class HomeController extends AbstractController {

	@Override
	protected ModelAndView handleRequestInternal(HttpServletRequest request,
			HttpServletResponse response) throws Exception {

		return new ModelAndView("home");
	}
}

Aquí debemos considerar un par de cosas importantes: 1) Los controladores deben implementar el método handleRequestInternal, que recibe un request y un response, y que también debe regresar un objeto de tipo ModelAndView. Este último objeto, como su nombre indica, contiene la información necesaria para representar al modelo y a la vista asociadas a un controlador. En este caso vemos que en el constructor del objeto ModelAndView se para una cadena: “home”. Esta cadena será utilizada por el View Resolver para generar el path para localizar al archivo de la vista (ejemplo: WebContent/WEB-INF/jsp/home.jsp).

Lo único que resta con el controlador es agregarlo al contexto de la aplicación. Agregaremos un bean más al archivo spring1-servlet.xml que haga referencia al controlador que recien creamos.

<bean name="/home.htm" class="com.andreimosso.spring1.controller.HomeController"/>

3.5 Escribir una vista (JSP)

Crea un archivo llamado home.jsp en la carpeta WebContent/WEB-INF/jsp/ con el siguiente contenido.

<?xml version="1.0" encoding="UTF-8" ?>
<%@ page language="java" contentType="text/html; charset=UTF-8"
		pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
		"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
		<title>Insert title here</title>
	</head>
	<body>
		Hola Mundo!
	</body>
</html>

Finalmente podremos ver los resultados de todo este trabajo. Abre la siguiente dirección en tu navegador http://localhost:8080/spring1/home.htm y verifica que se despliegue el contenido que definiste en la vista home.jsp.

Con esto concluye el ejercicio más simple que hay en Spring MVC. Sin embargo, a veces lo más difícil es ponernos sobre los pies y dar el primer paso. Espero pronto publicar una secuela a este post para manejar información enviada en una forma y tal vez un tercer post para acceso a bases de datos.

Espero que este tutorial haya sido de utilidad. Hasta la próxima.

La única condición para hacerse de una copia digital de este libro es registrarse a InfoQ, que por cierto yo recomendaría que se registren aunque no quieran el libro. Bueno, ya basta de preámbulos y vayan por su copia.

Esta vez recomiendo el tutorial de la tarjeta de presentación que aunque ya lo había visto hace un tiempo, no tiene mucho que me animé a seguirlo; sorprendentemente con muy buenos resultados. He aquí lo que obtuve siguiendo el tutorial:

Aunque a los autores les toma un par de días actualizar la página, vale la pena visitarla periódicamente. Para comenzar de inmediato visita el tutorial original (en inglés) o la traducción a español.

Ahora mis sospechas quedan fundamentadas: ¡soy un freak! Lo más que pude hacer fueron 23.8 segundos.

(Haz click en la imagen para jugar)

Gracias al Mosh, por mandarlo.