Lycka Bonita

Ya sabemos cómo publicar un servicio web y cómo construir un cliente que consuma dicho servicio partiendo del fichero descriptor del contrato.

Ahora integraremos el cliente del servicio que hemos desarrollado en un proyecto Spring.

Podríamos partir de un nuevo proyecto dinámico web, holamundoWSClienteSpring, añadir spring.jar y spring-mvc.jar, y configurar el web.xml para utilizar Spring. O podemos partir del proyecto que ya construimos basándonos en Spring, holamundo.

Debemos añadir las librerías que hemos utilizado en los anteriores proyectos :

• axis.jar
• commons-discovery.jar
• jaxrpc.jar
• saaj.jar
• wsdl4j.jar

Y necesitamos el interfaz del servicio, que podemos construir nosotros u obtenerlo como ya se ha mostrado a partir del fichero WSDL. Es el mismo que ya hemos utilizado, es.lycka.holamundoWS.webservices.HolaMundo :

package es.lycka.holamundoWS.webservices;

import java.rmi.Remote;

import java.rmi.RemoteException;

public interface HolaMundo extends Remote {

      public String getSaludoLycka (String nombre) throws RemoteException;

} 

Vale, ahora vamos a implementar un fichero xml con el formato de Spring para definir un bean de nuestro servicio web, es.lycka.holamundoWS.webservices.clientes.spring.application-context-ws.xml

<?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="holamundoService" class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean">

            <property name="wsdlDocumentUrl">

<value>http://localhost:8080/holamundoWS/services/HolaMundoImpl?WSDL</value>

            </property>

            <property name="namespaceUri">

<value>http://impl.webservices.holamundoWS.lycka.es</value>

            </property>

            <property name="serviceName">

                  <value>HolaMundoImplService</value>

            </property>

            <property name="portName">

                  <value>HolaMundoImpl</value>

            </property>

            <property name="serviceInterface">

<value>es.lycka.holamundoWS.webservices.HolaMundo</value>

            </property>

      </bean>

</beans>

Ya sólo nos queda construir el cliente, es.lycka.holamundoWS.clientes.spring.HolaMundoClienteSpring :

package es.lycka.holamundoWS.clientes.spring;

import java.rmi.RemoteException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import es.lycka.holamundoWS.webservices.HolaMundo;

public class HolaMundoClienteSpring {

      public static void main(String[] args) {

            String resultado;

            try {

                  ApplicationContext contexto = new ClassPathXmlApplicationContext("/es/lycka/holamundoWS/clientes/spring/application-context-ws.xml");

                  HolaMundo servicio = (HolaMundo)contexto.getBean("holamundoService");

                  resultado = servicio.getSaludoLycka("Jero");

                  System.out.println("resultado = " +resultado);

            } catch (RemoteException e) {

                  e.printStackTrace();

            }

      }

} 

Ejecutamos esta clase (con el servidor iniciado donde esté desplegado el servicio, y con conectividad entre las máquinas cliente y servidor) y en la consola deberíamos de ver :

resultado: Lycka te saluda, Jero.

Ver también

• Web Services - Primeros pasos con Eclipse - Generar Servicio Web
• Web Services - Primeros pasos con Eclipse - Generar Cliente Servicio Web

Spring - MVC es uno de los módulos del Framework de Spring, y como su propio nombre nos indica implementa una arquitectura Modelo - Vista - Controlador que utilizaremos como base para desarrollar nuestra aplicación web.

Si ya has utilizado antes el Framework de Struts, que también implementa una arquitectura MVC, no tendrás muchos problemas en utilizar este módulo.

Partiendo de una aplicación web

Sabemos que necesitamos nuestras herramientas Java (JDK), un IDE (hoy por hoy Eclipse es el rey y yoxos su profeta) y un servidor de aplicaciones (Tomcat siempre es una buena elección). 

Bueno, pues con todo listo partimos de una aplicación web, que llamaremos holamundo. Para comenzar nos basta un nuevo proyecto web dinámico con un fichero de bienvenida, index.jsp. Recuerda que se indica en el web.xml la lista de ficheros de bienvenida.

Desplegando la aplicación en nuestro servidor de aplicaciones deberíamos ver nuestra página de bienvenida introduciendo en nuestro navegador la URL <URL_Servidor_Aplicaciones>/holamundo (si el servidor está en nuestro ordenador, http://localhost:8080/holamundo).

Librerías Spring - MVC

Añadimos lo primero las librerías del Tomcat. Encima del proyecto, botón derecho > Propiedades > Java Build Path > en la pestaña de Librerías > Añadir Librería > Server Runtime > Seleccionamos el Servidor de Aplicaciones (Tomcat)

Ahora añadiremos las librerías que necesitamos para utilizar Spring - MVC. Las necesarias son :

• spring.jar, contiene las clases del núcleo de spring.
• spring-mvc.jar, contiene las clases del módulo de MVC de Spring.

Normalmente también añadiremos al menos

• standard.jar y jstl.jar para utilizar etiquetas JSTL en nuestro proyecto.
• commons-logging.jar (o log4j.jar) para el logging de nuestra aplicación.
• junit.jar para utilizar JUNIT para las pruebas de nuestras clases. Evidentemente si eres español esto te sobra, porque aquí programamos como los hombres, a pelo, a pecho descubierto y con las luces en el traje.

Configurando Spring - MVC

Debemos indicar ahora a nuestra aplicación web que utilice la servlet de Spring. Sip, eso lo hacemos en el web.xml. En este ejemplo definimos una servlet (holamundo) que responderá al encontrar una URL con el patrón *.lycka.

<servlet>

      <servlet-name>holamundo</servlet-name>

      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

      <load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

      <servlet-name>holamundo</servlet-name>

      <url-pattern>*.lycka</url-pattern>

</servlet-mapping> 

Y Spring MVC también tiene su archivo de configuración, al estilo del struts-config.xml de Struts. En este caso el nombre es el nombre de la servlet (<servlet-name>) seguido de "-servlet.xml". En este caso, holamundo-servlet.xml.

<?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">

      <!– the application context definition for the springapp DispatcherServlet –>

      <bean name="/holamundo.html"      class="es.lycka.holamundo.control.HolaMundoController"/>

      <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">

            <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>

            <property name="prefix" value="jsp/"></property>

            <property name="suffix" value=".jsp"></property>

      </bean>
 </beans>

Hemos a definir un controlador (es.lycka.holamundo.control.HolaMundoController), que atenderá la llamada a un path ("/holamundo.lycka").

<bean name="/holamundo.lycka"      class="es.lycka.holamundo.control.HolaMundoController"/> 

Este controlador realizará sus operaciones pertinentes, y según su resultado decidirá el siguiente paso : devolverá como resultado una vista (una jsp) con sus parámetros correspondientes. En este caso, se dirigirá a la vista "holamundo" pasando un parámetro, "ahora".

public class HolaMundoController implements Controller {

      protected final Log logger = LogFactory.getLog(getClass());

      public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)

                  throws ServletException, IOException {

            String ahora = (new Date()).toString();

            logger.info("Se dirige a la vista holamundo con ahora = " + ahora);

            return new ModelAndView("holamundo", "ahora", ahora);

      }

}

Ahora entra en juego el otro bean definido en nuestro xml, "viewResolver". Para independizar la ubicación de los ficheros de las vistas de los contraldores podemos definir reglas para encontrar la vista a partir de su nombre. En este caso, van a estar dentro del directorio "jsp/" y su extensión será ".jsp".

Así que nos queda construir la jsp que responderá, holamundo.jsp dentro del directorio jsp.

Puf, mucho trabajo no? Bueno, llegados a este punto deberíamos de poder desplegar en nuestro servidor y probar qué nos devuelve si introducimos en nuestro navegador la ruta "<URL_Servidor_Aplicaciones>/holamundo/holamundo.lycka". Cruzamos los dedos y…

Más información

• Spring Framework, el sitio web del framework de spring. Podrás consultar documentación y bajarte documentación, librerías , código y aplicaciones simples a modo de ejemplo.
• Developing a Spring Framework MVC application step-by-step.

Technorati Tags: Spring Framework, Spring-MVC

En los comienzos de la programación, los programas eran lineales y monolíticos. El flujo de ejecución era simplemente ejecutar línea tras linea.

Aparecieron dos conceptos que revolucionaron la programación: la modularidad y la reutilización de los componetes: se crean librerías de componentes reutilizables. El flujo se complica, saltando de componente a componente, y aparece un nuevo problema: la dependencia (acoplamiento) entre nuestros componentes.

El problema se empieza a considerar lo suficientmente importante como para definir nuevos conceptos en el diseño :

• Inversion of Control (IoC)
• Dependency Injection (DI)

La utilización de interfaces y la aparición de los frameworks es un primer paso para minimizar estas dependencias entre componentes, aunque pagamos un precio: la configuración en ficheros xml se empieza a volver monolítica, difícil de mantener, crítica y es fácil cometer errores.

Inversion of Control

Es una técnica que inverte el flujo tradicional. Lo tradicional es que el código que implementes llame a las librerías; la inversión de control ocurre cuando son las librerías las que llaman a tu código.

En Spring, la inversión de control consiste en ceder el control a una entidad externa a la aplicación, llamada "Contenedor", que se encargará de gestionar las instancias (así como sus creaciones y destrucciones).

Dependency Injection

Es un término comunmente confundido con el anterior.

En un escenario en el que utilizamos IoC, delegamos en una entidad "Contenedor" no solo la gestión de las instancias, sino la inyección de las sub-partes (dependencias). Si una venta se compone de un cliente y un producto, al instanciar un objeto venta la DI le inyecta directamente su cliente y su producto específicos.

Un ejemplo podría ser una cadena de montaje:

Tradicionalmente se encendía la cinta de montaje cuando se necesitase (instanciamos un objeto), los componentes eran transportados por la cinta y cada operario ensamblaba secuencialmente un componente para obtener un producto final (el objeto instanciado con todas sus propiedades concretas), y finalmente se apagaba la cinta cuando ya no era necearia (destruimos el objeto).

Utilizando IoC y DI, es un robot ("Contenedor") quien detecta cuando se necesita un objeto, pone automáticamente en marcha una cinta, ensambla sus partes y nos devuelve nuestro objeto final volviendo a su estado de stand-by hasta el siguiente pedido.

Más información

• [Lyckapedia] - Inyección de Dependencias
• [Lyckapedia] - Inversión de Control