Ahhhh se me cae la baba con mi gata y con esas dos monadas de gatas…. De vez en cuando el de hachisvertas hace algo bien, como publicar esta entrada
Por cierto, q ver si me devuelve mi ordenador que tengo mucha gente que matar en el Enemy Territory.
Avancemos un poco más en nuestros conocimientos básicos de Spring - MVC. Vamos a extraer el negocio de nuestras clases controlers y vamos a llevarlos a nuevas clases de la capa de negocio.
holamundoBO
Bueno, repasemos los primeros pasos de Spring - MVC. Si necesitas ayuda mira la chuleta de la entrada anterior, sobre el proyecto holamundo con Spring - MVC.
Creemos un nuevo proyecto web dinámico, holamundoBO. Importamos las librerías necesarias, configuramos el web.xml para que utilice Spring al recibir extensiones ".lycka". Creemos nuestra clase controller, es.lycka.holamundoBO.control.HolaMundoController y la implementamos como hicimos en el tutorial anterior. Nos resta configurar el fichero xml de configuración de la servlet de spring, holamundoBO-servlet.xml para que mapee el path /holamundo.lycka al controlador que acabamos de crear.
Podemos utilizar las mismas jsp's que en el proyecto de holamundo, index.jsp y jsp/holamundo.jsp.
Desplegamos la aplicación en el servidor y comprobamos que se ven correctamente la ruta /holamundo.lycka.
Extraer el negocio
En nuestro caso el negocio es muy simple, es únicamente una sentencia. Habitualmente sabemos que no es así.
(new Date()).toString()
Para ello crearemos un interfaz, es.lycka.holamundoBO.negocio.HolaMundoBO, y lo implementaremos en la clase es.lycka.holamundo.negocio.impl.HolaMundoBOImpl.
package es.lycka.holamundoBO.negocio;
public interface HolaMundoBO {
public String getHoraActual ();
}
y
package es.lycka.holamundoBO.negocio.impl;
import java.util.Date;
import es.lycka.holamundo.negocio.HolaMundoBO;
public class HolaMundoBOImpl implements HolaMundoBO {
public String getHoraActual () {
return (new Date()).toString();
}
}
Configurar Spring
Vale, ahora vamos a sacar uso de la Inyección de Dependencias de Spring.
Creamos una variable privada en el controller del tipo HolaMundoBO, y un método set para esta variable. Utilizamos el método de negocio de esta variable, getHoraActual ().
private HolaMundoBO holaMundoBO;
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String ahora = holaMundoBO.getHoraActual();
logger.info("Se dirige a la vista holamundo con ahora = " + ahora);
return new ModelAndView("holamundo", "ahora", ahora);
}
public void setHolaMundoBO(HolaMundoBO holaMundoBO) {
this.holaMundoBO = holaMundoBO;
}
Ahora declaramos el bean en el archivo de configuración de Spring, holamundoBO-servlet.xml.
<bean id="HolaMundoBO" class="es.lycka.holamundoBO.negocio.impl.HolaMundoBOImpl" />
Y ahora le inyectamos el bean de negocio al controlador… cómo ? declaramos una nueva propiedad en el bean del controller para inyectarle este método de negocio.
<bean name="/holamundo.lycka" class="es.lycka.holamundoBO.control.HolaMundoController" >
<property name="holaMundoBO" ref="HolaMundoBO" />
</bean>
Probamos el códgio, et voilá, funciona ! Ya tenemos nuestra capa de negocio en un proyecto de Spring.
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 :
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.
Ya hemos publicado nuestro servicio web en un servidor. Ahora queremos generar un cliente que consuma este servicio.
Para ello utilizaremos las mismas herramientas descritas en la entrada sobre la generación del servicio web, y el fichero descriptor del contrato que se generó, HolaMundo.wsdl.
Generamos el cliente Servicio Web
Normalmente el cliente y el servidor estarán en distintas máquinas. Por eso crearemos un nuevo proyecto web dinámico, holamundoWSCliente. Introducimos las librerías que necesitamos y el fichero del contrato del servicio, HolaMundo.wsdl (yo lo meteré en una carpeta "doc").
Nos situamos sobre el fichero descriptor del contrato (HolaMundo.wsdl) y seleccionamos "Botón Derecho > Web Services > Generate Client".
Se nos genera automáticamente las siguientes clases dentro del mismo paquete (es.lycka.holamundoWS.webservices.impl) que la implementación del servicio (HolaMundoImpl):
Consumir el servicio web
Generamos una clase cliente de este servicio web que acabamos de crear. Por ejemplo en un nuevo paquete es.lycka.holamundoWS.clientes creamos una clase HolaMundoCliente. Esta clase será muy simple :
package es.lycka.holamundoWS.clientes;
import es.lycka.holamundoWS.webservices.impl.HolaMundoImpl;
import es.lycka.holamundoWS.webservices.impl.HolaMundoImplServiceLocator;
public class HolaMundoCliente {
public static void main(String[] args) {
try {
HolaMundoImplServiceLocator holaMundoWSServiceLocator = new HolaMundoImplServiceLocator ();
HolaMundoImpl holaMundoWS = holaMundoWSServiceLocator.getHolaMundoImpl();
String resultado = holaMundoWS.getSaludoLycka("Jero");
System.out.println("resultado: " +resultado);
} catch (Exception 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.
Es tan bonito lo simple !
Herramientas necesarias
Creación de los objetos de negocio
Los servicios web son en resumidas cuentas objetos de negocio reutilizables y compartidos.
Por tanto, nos creamos nuestro nuevo proyecto web dinámico, holamundoWS.
Lo primero que debemos crear es un interfaz para el servicio web con los métodos de negocio (es.lycka.holamundoWS.webservices.HolaMundo) y una clase que implemente dicho interfaz (es.lycka.holamundoWS.webservices.impl.HolaMundoImpl). En el ejemplo tendremos un método de negocio, getSaludoLycka.
El código para el interfaz, HolaMundo es :
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;
}
El código para la implementación, HolaMundoImpl es :
package es.lycka.holamundoWS.webservices.impl;
import java.rmi.RemoteException;
import es.lycka.holamundoWS.webservices.HolaMundo;
public class HolaMundoImpl implements HolaMundo {
public String getSaludoLycka(String nombre) throws RemoteException {
return "Lycka te saluda, " + nombre + ".";
}
}
Generación del Contrato del Servicio (fichero wsdl) y Publicación del servicio
Con los plugins del Eclipse resulta muy simple.
Sobre la interfaz del servicio, HolaMundo, y seleccionamos "Pulsamos Botón Derecho del ratón > Web Services > Generate Web Services". Introducimos la ruta de la implementación de la interfaz (Service Implementation). Se nos da la opción qué queremos hacer con el servicio (develop, assamble, deploy, install, start, test) y con el cliente; de momento elegiremos iniciar el servicio (start) y no generar el cliente.
Pulsamos "Next".
En esta pantalla podemos seleccionar los métodos que publicaremos en el servicio web, y el nombre del fichero wsdl. Por comodidad lo renombraré a HolaMundo.wsdl.
Se nos genera, entre otros ficheros, el descriptor del contrato de servicio (Web Content > wsdl > HolaMundo.wsdl)
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://impl.webservices.holamundoWS.lycka.es" xmlns:apachesoap="http://xml.apache.org/xml-soap" xmlns:impl="http://impl.webservices.holamundoWS.lycka.es" xmlns:intf="http://impl.webservices.holamundoWS.lycka.es" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<!–WSDL created by Apache Axis version: 1.4
Built on Apr 22, 2006 (06:55:48 PDT)–>
<wsdl:types>
<schema elementFormDefault="qualified" targetNamespace="http://impl.webservices.holamundoWS.lycka.es" xmlns="http://www.w3.org/2001/XMLSchema">
<element name="getSaludoLycka">
<complexType>
<sequence>
<element name="nombre" type="xsd:string"/>
</sequence>
</complexType>
</element>
<element name="getSaludoLyckaResponse">
<complexType>
<sequence>
<element name="getSaludoLyckaReturn" type="xsd:string"/>
</sequence>
</complexType>
</element>
</schema>
</wsdl:types>
<wsdl:message name="getSaludoLyckaResponse">
<wsdl:part element="impl:getSaludoLyckaResponse" name="parameters"/>
</wsdl:message>
<wsdl:message name="getSaludoLyckaRequest">
<wsdl:part element="impl:getSaludoLycka" name="parameters"/>
</wsdl:message>
<wsdl:portType name="HolaMundoImpl">
<wsdl:operation name="getSaludoLycka">
<wsdl:input message="impl:getSaludoLyckaRequest" name="getSaludoLyckaRequest"/>
<wsdl:output message="impl:getSaludoLyckaResponse" name="getSaludoLyckaResponse"/>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="HolaMundoImplSoapBinding" type="impl:HolaMundoImpl">
<wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="getSaludoLycka">
<wsdlsoap:operation soapAction=""/>
<wsdl:input name="getSaludoLyckaRequest">
<wsdlsoap:body use="literal"/>
</wsdl:input>
<wsdl:output name="getSaludoLyckaResponse">
<wsdlsoap:body use="literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="HolaMundoImplService">
<wsdl:port binding="impl:HolaMundoImplSoapBinding" name="HolaMundoImpl">
<wsdlsoap:address location="http://localhost:8080/holamundoWS/services/HolaMundoImpl"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
Testear el servicio web
Comprobemos que vamos bien, es decir, que el servicio se ha generado correctamente y está desplegado y disponible en nuestros servidor de aplicaciones. Nos situamos sobre el fichero descriptor del contrato (HolaMundo.wsdl) y seleccionamos "Botón Derecho > Web Services > Test with Web Services Explorer".
En la pantalla que se nos abre, Explorador de Servicios Web, podemos navegar entre los distintos servicios publicados y sus métodos. Para probar nuestro método, getSaludoLycka, pulsamos sobre su enlace y le introducimos un nombre. Yo le introduciré "Jero". Y pulsamos en "Go".
En la ventana de status podemos ver los mensajes SOAP que nos ha generado la acción, tanto el que se enviaría del cliente al servidor como el resultado que envía el servidor al cliente. Y efectivamente en este último viaja el saludo que nos devuelve Lycka, "Lycka te saluda, Jero."
Dónde está desplegado el servicio ?
Un detalle importante que no he comentado hasta ahora es cómo sabrá el cliente dónde está desplegado el servicio ?
El contrato del servicio lo especifica (por defecto pone localhost:8080). Para nuestras pruebas funcionará si el cliente se ejecuta en la misma máquina que el servidor, pero de no ser así deberemos sustituir localhost:8080 por el nombre de la máquina servidor y el puerto por el que atienda.
<wsdlsoap:address location="http://localhost:8080/holamundoWS/services/HolaMundoImpl"/>
No es grato anunciar otra despedida, esta vez la del cordobés del equipo, Álvaro. Parece que fue ayer cuando llegó, y se va después de aguantarnos 11 meses.
Siempre pensé que las ratas eran las primeras que abandonaban el barco, pero hace poco leía en navegápolis la misma idea expresada de una manera más poética:
Poco a poco, empezando por los mejores, van abandonando su departamento o la empresa
Se nos va otro personaje, de los mejores, otro gran demonio como dijo en su momento el Espince. El silencio a veces transmite más que cualquier palabra, como ilustra una cita que acompaña a esta bitácora en su cabecera, como se puede comprobar en este mismo post.
Lycka, y el que suscribe, le desea justicia, y un poquito de suerte que siempre viene bien. Al menos no tentrás problemas en encontrar mejor compañía en el futuro !
npc
Kirai
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 :
Normalmente también añadiremos al menos
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.