Ya hemos visto como desarrollar portlet para Liferay y también como desarrollar una pequeña aplicación con Spring e Hibernate. ¿Por qué no unirlo todo? Creo que sería una gran idea poder realizar un portlet para Liferay utilizando Spring e Hibernate. No, no soy un visionario, ni un gurú. Ya existen miles de portlet así, pero a mí me encanta aprender y creo que será genial aprender cómo se realiza un portlet para Liferay utilizando Spring e Hibernate. Creo que mi SEO se verá resentido con eso no poner siempre lo mismo 😉

Para empezar vamos a realizar un pequeño “hello world” para irnos haciendo con el entorno, que aun siendo conocido (como es el caso de Liferay IDE) siempre es conveniente comprobar que todo funciona antes de atascarnos en algo más complejo.

Antes de empezar vamos a dejar claro que es la Dependencia de Inyección. Según la Wikipedia es un patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase quien cree el objeto.

Para que nos quede más claro en el Libro “Portlets in Action” nos ponen un ejemplo muy aclaratorio que voy a “traducir” a continuación:

Imaginemos que tenemos entre manos una aplicación para un ecommerce, esta aplicación tiene estos objetos definidos (puede que tenga muchos más, pero nos centraremos en estos de momentos).

• OrderHandler: Un componente de la capa de presentación es responsable de manejar las órdenes cursadas por los clientes.
  Depende OrderService para guardar las ordenes entregadas (submitted)
• OrderService: Un componente que contiene la lógica de negocio para guardar un orden en la base de datos. Depende OrderDAO para guardar la información de la orden en la base de datos.
• OrderDAO: Un objeto de acceso a datos que es responsable de la interacción con la base de datos para guardar la información de pedido enviado por el cliente.

Este sería el esquema de dependencias de las clases que hemos expuesto aquí

Entonces teniendo este esquema en mente el código sería una cosilla más o menos así:

public class OrderHandler {
private OrderService orderService = new OrderService();
public void saveOrder(...) {
orderService.saveOrder(...);
}
}
public class OrderService {
private OrderDAO orderDAO = new OrderDAO();
public void saveOrder(...) {
orderDAO.saveOrder(...);
}
}

Como podemos observar el código OrderHandler está “ligado” o mejor dicho acoplado con OrderService que su vez está acoplado con OrderDAO. Por ello cualquier cambio que hagamos en alguna de las clases hará peligrar la aplicación debido al acoplamiento.

Una solución a este problema vendría dada con la Dependencia de Inyección, ya que lo que haríamos sería tener una interfaz común y realizar clases que implementaran dicha interfaz, creando además un patrón factoría para reducir la dependencia al crear los objetos.

Lo que conseguimos al utilizar DI es alejar (p.e. un archivo externo XML) toda la configuración y dependencias de la aplicación.

Esto es solo una pequeña simplificación de todo lo que pasa al utilizar dependencias de inyección, nos quedaría explicar muchísimas cosillas, pero vamos a lo práctico. Todo esto se simplifica utilizando Spring.

Creando portlet “hola mundo” con Spring

Creando el proyecto

Así que vamos a ello, lo que haremos ahora será crear un pequeño Hello world utilizando Spring. Para ello utilizando el plugin de Eclipse Liferai IDE pinchamos sobre un nuevo proyecto de tipo portlet y en un alarde de imaginación lo llamamos “HelloSpring”

Ahora tenemos que configurar el portlet para decirle que vamos a utilizar Spring. El hecho de utilizar Liferay IDE nos facilita un poco el proceso, así que lo que hacemos es editar el archivo liferay-plugin-package.properties añadiendo las siguientes librerías pulsando sobre “Portal dependencias jars”

• org.springframework.asm-3.0.0.RELEASE

• org.springframework.beans-3.0.0.RELEASE

• org.springframework.context-3.0.0.RELEASE

• org.springframework.core-3.0.0.RELEASE

• org.springframework.expression-3.0.0.RELEASE

• org.springframework.web-3.0.0.RELEASE

-org.springframework.web.portlet-3.0.0.RELEASE

•  org.springframework.web.servlet-3.0.0.RELEASE

*Si no tuviésemos Liferay IDE, o no estuvieran dichas librerías habría que añadirlas dentro de la carpeta lib del proyecto.

Creando el controlador

La clase que gestiona todo el portlet es la clase Controladora y la vamos a crear ahora mismo.

Esta clase que implementa Controller de “Spring framework” la llamaremos HelloWorldController.java y es más o menos así:

public class HelloWorldController implements Controller {
        @Override
       public void handleActionRequest(ActionRequest arg0, ActionResponse arg1)
                    throws Exception {
       }
        @Override
       public ModelAndView handleRenderRequest(RenderRequest arg0,
                    RenderResponse arg1) throws Exception {
             Map<String, Object> model =       new HashMap<String, Object>();
             model.put("helloWorldMessage", "Hello World Jesuslc.com");
             return new ModelAndView("HelloWorld", model);
       }
 }

Lo único destacable es que el método handleRenderRequest devuelve un Map con el modelo como key (son los datos) y la vista como value(son las páginas JSP).

Creando la vista

Vamos a crear la vista de nuestro portlet, para ello tenemos que crear una carpeta dentro de WEB_INF llamada jsp donde colocaremos nuestro archivo “HelloWorld.jsp”

Este archivo solo imprime el mensaje que le llega del controlador

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>
<%@ page contentType="text/html" isELIgnored="false" %>
<c:out value="${helloWorldMessage}"/>

Configurando portlet.xml

Ahora vamos a configurar el archivo “portlet.xml” para decirle que vamos a utilizar Spring como Dispatcher y no GenericPortlet. Por ello solo tenemos que modificar el atributo portletclass por esto:

<portlet-class>org.springframework.web.portlet.DispatcherPortlet</portlet-class>

Quedando un archivo así:

Ahora solo nos queda declarar los “bean” , pero que es un “bean” . Según la wikipedia, un Bean es un componente  software que tiene la particularidad de ser reutilizable y así evitar la tediosa tarea de programar los distintos componentes uno a uno. Se puede decir que existen con la finalidad de ahorrarnos tiempo al programar.

Creando el beans

Es decir, lo que hemos creado es un bean, es una aplicación que imprime por pantalla. Por ello, lo único que debemos hacer es crear un nuevo archivo .xml dentro de WEB-IN llamado “HelloSpring-portlet.xml” . Entonces ahí escribimos lo siguiente:

<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">

       <bean id="helloWorldController"
             class="com.jesuslc.code.HelloWorldController"/>

       <bean id="portletModeHandlerMapping"
             class="org.springframework.web.portlet.handler.PortletModeHandlerMapping">
             <property name="portletModeMap">
                    <map>
                           <entry key="view">
                                  <ref bean="helloWorldController" />
                           </entry>
                    </map>
             </property>
       </bean>
       <bean id="viewResolver"
             class="org.springframework.web.servlet.view.InternalResourceViewResolver">
             <property name="viewClass"
                    value="org.springframework.web.servlet.view.JstlView" />
             <property name="prefix" value="/WEB-INF/jsp/" />
             <property name="suffix" value=".jsp" />
       </bean>
</beans>

Casi terminando con web.xml

Por ultimo debemos terminar de configurar web.xml para indicar que el bean que hemos creado en el paso anterior debe usarse alguna vez 😉

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

       <servlet-mapping>
             <servlet-name>ViewRendererServlet</servlet-name>
             <url-pattern>/WEB-INF/servlet/view</url-pattern>
       </servlet-mapping>

Resultado Final

Ahora solo tenemos que posicionarnos encima del archivo build.xml y usar ant para desplegar el portlet y añadirlo a Liferay

Referencias

Me he basado en el libro Portlet in Action de la editorial Manning