Creando un Custom Portlet Service con Maven y sin RAD

En la entrega anterior les mostré como desarrollar un portlet básico sin RAD. En esta ocasión nos toca ver cómo desarrollar un Custom Portlet Service para WebSphere Portal, obviamente sin RAD y empleando Maven.

Lo primero que vamos a necesitar es el archivo public_spi.jar que contiene algunas de las clases e interfaces que requeriremos para desarrollar el portlet service. Habitualmente este archivo se encuentra en una ruta similar a esta: /doc/compile.

Luego, nos valemos de Maven para agregar este jar a nuestro repositorio de dependencias.

mvn install:install-file -Dfile=public_spi.jar -DgroupId=com.ibm / -DartifactId=public-spi -Dversion=1.0 -Dpackaging=jar

A continuación, creamos un proyecto simple con Maven y agregamos las dependencias correspondientes a la api portlet 2.0 y al jar que acabamos de agregar.

	<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>pe.apiconz.portletsapps</groupId>
	<artifactId>portletservice-example</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<name>portletservice-example</name>
	<url>http://maven.apache.org</url>
	<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
	<dependencies>
	<!-- Estas dependencias son de 3eros -->
	<dependency>
	<groupId>com.ibm</groupId>
	<artifactId>public-spi</artifactId>
	<version>1.0</version>
	<scope>provided</scope>
	</dependency>
	<!-- Estas dependencias se encuentran en el servidor y por ello no se agregarán
	al war -->
	<dependency>
	<groupId>javax.portlet</groupId>
	<artifactId>portlet-api</artifactId>
	<version>2.0</version>
	<scope>provided</scope>
	</dependency>
	<dependency>
	<groupId>org.apache.portals.pluto</groupId>
	<artifactId>pluto-util</artifactId>
	<version>2.0.3</version>
	<scope>provided</scope>
	</dependency>
	</dependencies>
	</project>

view raw pom.xml hosted with ❤ by GitHub

Ahora crearemos una interfaz que contendrá la declaración de métodos públicos que se expondrán a través del servicio y, obviamente, crearemos también la clase que la implementará:

	package pe.apiconz.portletsapps.portletserviceexample;
	import java.io.IOException;
	import javax.portlet.PortletRequest;
	import javax.portlet.PortletResponse;
	import com.ibm.portal.portlet.service.PortletService;
	public interface MyPortletService extends PortletService {
	public void miPrimerPortletService (PortletRequest request, PortletResponse response) throws IOException;
	}

view raw MyPortletService.java hosted with ❤ by GitHub

	package pe.apiconz.portletsapps.portletserviceexample;
	import java.io.IOException;
	import java.util.prefs.Preferences;
	import javax.portlet.PortletRequest;
	import javax.portlet.PortletResponse;
	import com.ibm.portal.portlet.service.PortletServiceUnavailableException;
	import com.ibm.portal.portlet.service.spi.PortletServiceProvider;
	public class MyPortletServiceImpl implements MyPortletService,PortletServiceProvider {
	private String message;
	public void init(Preferences servicePreferences)
	throws PortletServiceUnavailableException {
	message = servicePreferences.get("message", "Mi primer servicio");
	}
	public void miPrimerPortletService(PortletRequest request,
	PortletResponse response) throws IOException {
	System.out.println("Invocando a mi primer portlet service : " + message);
	}
	}

view raw MyPortletServiceImpl.java hosted with ❤ by GitHub

En este punto, debemos generar el JAR del servicio para luego registrarlo en el Portal.

• Colocamos el jar en la ruta: /wp_profile/PortalServer/config
• En la consola del WAS del Portal, registraremos el portlet service valiéndonos del Resource Environment Provider llamado "WP PortletServiceRegistryService".
• Creamos  un nuevo registro en los Custom Properties. En el nombre ingresamos jndi.pe.apiconz.portletsapps.portletserviceexample.MyPortletService y en el valor colocamos el nombre completo de la clase que lo implementa: pe.apiconz.portletsapps.portletserviceexample.MyPortletServiceImpl.
• Guardamos y reiniciamos el portal.

La invocación del portlet service que acabamos de crear sería como sigue:

	package pe.apiconz.portletsapps.tools;
	import java.io.IOException;
	import javax.naming.NameNotFoundException;
	import javax.naming.NamingException;
	import javax.portlet.GenericPortlet;
	import javax.portlet.PortletException;
	import javax.portlet.RenderRequest;
	import javax.portlet.RenderResponse;
	import pe.apiconz.portletsapps.portletserviceexample.MyPortletService;
	import com.ibm.portal.portlet.service.PortletServiceHome;
	public class UnPortlet extends GenericPortlet {
	private PortletServiceHome portletServiceHome;
	private MyPortletService portletService;
	@Override
	public void init() throws PortletException {
	/* Lookup the portlet service */
	try {
	javax.naming.Context ctx = new javax.naming.InitialContext();
	Object home = ctx
	.lookup("portletservice/pe.apiconz.portletsapps.portletserviceexample.MyPortletService");
	if (home != null)
	portletServiceHome = (PortletServiceHome) home;
	} catch (NameNotFoundException ex) {
	// Exception handling code goes here
	} catch (NamingException ex) {
	// Exception handling code goes here
	}
	}
	@Override
	protected void doView(RenderRequest request, RenderResponse response)
	throws PortletException, IOException {
	portletService = portletServiceHome
	.getPortletService(MyPortletService.class);
	portletService.miPrimerPortletService(request, response);
	getPortletContext().getRequestDispatcher("/WEB-INF/jsp/unjsp.jsp")
	.include(request, response);
	}
	}

view raw UnPortlet.java hosted with ❤ by GitHub