Segundo portlet con Liferay: listar una tabla (parte 1 de 2)

Hasta ahora hemos visto cómo crear un portlet muy básico que básicamente mostraba un mensaje en la página y alguna información del usuario que ha iniciado la sesión en el portal.

Vamos ahora a crear un nuevo portlet con un comportamiento un pelín más interesante, que acceda a una base de datos (Oracle, en este caso) y que muestre los datos de una consulta sobre una tabla. Lo llamaremos "ListarTabla" (olé ahí, derroche de imaginación eligiendo nombres ;-). La tabla que utilizaremos tiene esta estructura:

CREATE TABLE TABLA1
(
   ID varchar2(10) PRIMARY KEY NOT NULL,
   CAMPO1 varchar2(100),
   CAMPO2 varchar2(100)
);

Y estos datos:

INSERT INTO tabla1 VALUES(1, 'ENCARGADO DEL BOCADILLO', 'PEPE GOTERA')
INSERT INTO tabla1 VALUES(2, 'PROFESORA DE BAILE', 'JESSICA ALBA')
INSERT INTO tabla1 VALUES(3, 'ASESOR DE IMAGEN', 'LA PANTOJA DE PUERTO RICO')
INSERT INTO tabla1 VALUES(4, 'CONFESOR', 'COMISARIO TORRENTE')

Comencemos, pues.

1. Crear el portlet

Si no sabes cómo crear un portlet, a lo mejor te es útil echar antes un vistazo a esta entrada: Primer portlet con Eclipse y Liferay.

Utilizaremos el botón de Liferay de la barra de herramientas, y dentro de él la opción "New Liferay Plugin Project"

Fig 1. Creando el portlet "Listar Tabla"

Dejamos las opciones por defecto

Fig. 2. Trabajaremos con el framework MVC

Y tras pulsar Finish se nos debería haber creado la siguiente estructura de carpetas y ficheros

Fig. 3. Estructura de ficheros para el portlet "Listar Tabla"

2. Mostrar datos del usuario y preparar el sitio donde mostrar los resultados

Aunque esto no es necesario, quiero mostrar la información del usuario, como describimos en una entrada anterior, Objetos implícitos en portlets Liferay, así que añadiré el código correspondiente al fichero view.jsp. También añadiremos el sitio donde se mostrarán los datos procedentes de la consulta.

Fig. 4. Preparando el espacio donde se mostrará el resultado de la consulta (línea 30)

3. Crear una clase para acceder a los datos

Ahora viene lo interesante. Para facilitar la legibilidad del código de view.jsp, delegaremos la responsabilidad de acceder a los datos y convertirlos en una tabla HTML a una clase Java que posteriormente invocaremos desde esta página. Así, el fichero view.jsp se limitará a invocar las funciones de esta clase y su código será bastante reducido y limpio.

Esta clase, por cuestiones de organización, será conveniente que esté en un paquete específico. Si no se especifica un paquete concreto, la clase pertenece al paquete por defecto (default), cosa que no se recomienda.

Fig. 5. El uso del paquete 'default' no se recomienda

Así que lo mejor será que creemos antes el paquete que la contendrá. Le pondremos de nombre "accesoDatos" (Eclipse recomienda que los paquetes empiecen con minúscula, aunque esto es más bien una convención Java, no un requisito imprescindible). Para crear el paquete, nos vamos al menú File / New / Package

Fig. 6. Nuevo paquete

Le damos el nombre que hemos dicho, y le indicamos a Eclipse que la carpeta que contendrá los fuentes colgará de WEB-INF/src

Fig. 7. Creando el paquete "accesoDatos"

Tras esto, ya podemos ver en el Package Explorer que el nuevo paquete se encuentra en nuestro proyecto.

Fig. 8. El paquete recién creado

Ahora ya podemos crear la nueva clase dentro de ese paquete. Para ello, hacemos clic con el botón derecho sobre el paquete en el Package Explorer y seleccionamos New / Class

Fig. 9. Creando la nueva clase

Le pondremos de nombre "GestorDatos"

Fig. 10. La clase GestorDatos dentro del paquete accesoDatos

Para este ejemplo, utilizaremos una técnica que podríamos denominar "artesanal". Básicamente, consistirá en que el Gestor de Datos realizará una conexión a la base de datos, recuperará los registros que nos interesan, y a continuación los irá recorriendo en un bucle, construyendo una tabla HTML que irá almacenando en una cadena de texto. Esta cadena será la que devuelva al código invocante (el de view.jsp), que lo único que hará será mostrar esta tabla sin más.

Como digo, este método es muy primitivo, no se utilizan plantillas ni controles de interfaz de usuario, no se paginan los resultados, ni se pueden ordenar, ni ná de ná... Simplemente, se recuperan datos y se muestran. Pero esto es suficiente para ilustrar sin mayores complicaciones el proceso básico de conectarse a una base de datos y hacer 'algo' con los datos recuperados. Es mejor ir dando pequeños pasos, así nos concentramos en un aspecto cada vez.

Bueno, pues manos a la obra. La clase GestorDatos va a contener un único método público que será el que devuelva la tabla HTML. Su esquema será algo así:

Fig. 11. Estructura del método que devolverá la tabla HTML

Las acciones de conectar y recuperar datos se codificarán en dos métodos privados de esta clase, que servirán de apoyo al método público. Además, definiremos también un método público para devolver el número de registros recuperados (con la correspondiente variable privada para almacenar este dato).

4. El driver de Oracle

Como dije, voy a sacar los datos de una BD Oracle. Por eso, necesito el driver de Oracle, que descargaremos de la web oficial (http://www.oracle.com/technetwork/database/features/jdbc/index-091264.html). Imagino que tendréis que registraros con un email válido, en su momento yo tuve que hacerlo. Este driver es un fichero de nombre ojdbcXX.jar. El XX depende de la versión que os bajéis, lo cual, a su vez, depende de la versión del sistema operativo y de la versión del motor de la base de datos. Si no tenéis clara la versión del motor de Oracle, aquí podéis ver cómo se averigua. En mi caso, el fichero se llama ojdbc141.jar.

Para que este driver esté disponible en nuestro proyecto, hay que incluir la referencia en el subdirectorio WEB-INF/lib. Para ello, podemos hacer clic con el botón derecho del ratón sobre la carpeta "lib" que cuelga de WEB-INF y luego elegir "Import..." del menú contextual.

Fig. 12. Vamos a añadir el fichero JAR con el driver de Oracle

Para elegir el origen de la importanción desplegamos "General" y dentro de ella elegimos "File System" y pulsamos Next.

Fig. 13. Vamos a seleccionar un fichero del disco

Y en el siguiente diálogo, le indicamos la ruta donde tenemos ese fichero. Nos dará la opción de elegir qué ficheros de la carpeta seleccionada queremos importar. En este caso, sólo he marcado la biblioteca con el driver de acceso a Oracle, como se ve en la figura.

Fig. 14. Importamos solamente el fichero con el driver de Oracle

Tras pulsar Finish, podemos comprobar que ya debe aparecer en el árbol de nuestro proyecto esa biblioteca colgando del subdirectorio WEB-INF/lib

 

Fig. 15. La biblioteca con el driver de Oracle ya está referenciada en nuestro proyecto

Lo que ha hecho Eclipse internamente ha sido simplemente copiar el fichero indicado dentro del subdirectorio correspondiente, lo que podemos ver si con un explorador de archivos del sistema operativo echamos un vistazo a la carpeta WEB-INF/lib. Allí aparece el fichero que hace un momento no estaba. Por eso, otra forma más rudimentaria de importar el fichero en nuestro proyecto podría haber sido copiar manualmente este fichero.

Fig. 16. La biblioteca importada se ha copiado a la carpeta lib de nuestro proyecto

Bien, hasta aquí la primera parte de esta entrada. En la siguiente entrada completaremos la tarea.

Objetos implícitos en portlets Liferay

En la anterior entrada (Primer portlet con Eclipse y Liferay) vimos cómo hacer un portlet muy simple, un "Hola, Mundo". Hoy veremos cómo acceder a algo de información útil, relativa al usuario que ha iniciado la sesión en el portal de Liferay.

Si recordáis, el fichero view.jsp es el que contiene la vista del portlet, o sea, lo que se va a mostrar en el "recuadro" que contenga al portlet en la página web, la cual puede contener varios portlets. En esta ocasión, veremos qué hay que añadir a ese fichero para mostrar información del usuario.

El código que vimos en el último ejemplo, se limitaba a mostrar un mensaje de saludo.

Fig. 1. "Hola, Mundo" en todo su esplendor

 Ahora, para mostrar información del usuario, utilizaremos dos objetos: request y user.

El objeto request es un objeto implícito que tenemos disponible para acceso en nuestra página JSP y que representa la solicitud de página que hace el navegador a nuestro servidor. En esa solicitud viene, entre otras cosas, información del usuario que la ha pedido, y podemos acceder a ella a través del método getRemoteUser:

<br>Usuario autenticado: <%=request.getRemoteUser() %>

Este objeto request (y otros como response) están disponibles en todos los portlets y servlets, independientemente de que estemos utilizando Liferay o no. El tipo del objeto request es javax.servlet.http.HttpServletRequest y podéis ver todos sus métodos y atributos aquí:

http://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html

Una vez hecha tecleada la línea de arriba en nuestra página view.jsp, podemos observar la salida en nuestra página web:

 

Fig. 2. El usuario tiene un identificador numérico. Hmm... esto no nos dice mucho

 Como se ve, el identificador es un número que no nos es (en principio) demasiado útil. La buena noticia es que Liferay nos da otras variables con las que sacar información interesante, como el nombre del usuario (su login, por ejemplo) y otras. Para tener disponibles estas variables de Liferay debemos incluir estas dos líneas en nuestro código:

<%@ taglib uri="http://liferay.com/tld/theme" prefix="liferay-theme" %>
<liferay-theme:defineObjects />

Y una vez tecleado eso, ya podemos acceder al login del usuario y su nombre:

<br>Nombre: <%= user.getScreenName() %>
<br>Login: <%= user.getLogin() %>

Así pues, el código comleto nos quedaría así:

Fig. 3. Accediendo al nombre y login del usuario

Lo pongo aquí en modo texto por si alguien quiere copiar y pegar:

<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>
<%@ taglib uri="http://liferay.com/tld/theme" prefix="liferay-theme" %>
<liferay-theme:defineObjects />
<portlet:defineObjects />


This is the <b>Hola, Mundo</b> portlet.

<br>Usuario autenticado: <%= request.getRemoteUser() %>
<br>Nombre: <%= user.getScreenName() %>
<br>Login: <%= user.getLogin() %>

Ahora ya podemos ir a la página y ver la salida:

Fig. 4. La información del usuario en un formato más legible

Bien. Ahora ya podríamos tomar decisiones en función del usuario que se conecte (por ejemplo, mostrar una información u otra en función del usuario, gestionar permisos... en fin, todo lo que se nos ocurra y que pueda depender del usuario).

Primer portlet con Eclipse y Liferay

Bueno, siguiendo con la serie de entradas sobre Liferay, veamos hoy cómo hacer nuestro primer portlet. Un portlet es como un "trozo" de una página, un componente web que funciona como una miniaplicación independiente. O no tan mini, ya que la funcionalidad del portlet puede ser tan compleja como se desee. El ejemplo típico es una página que puede contener varios portlets (que no se deben solapar), aunque cada uno de ellos no tiene asociada una URL independiente, sino que están concebidos para funcionar dentro de la página contenedora. Si queréis más info, sobre los portlets, podéis mirar aquí para los conceptos básicos o, como siempre, preguntarle a cualquier buscador.

De acuerdo, pues. Veamos cómo realizar nuestro primer portlet, poco más que un "Hola, mundo", lo cual significa que no aportará mucha funcionalidad, pero nos valdrá para adquirir la idea básica de cómo hacer un portlet.

1. Configurar el Liferay SDK

Antes de poder crear ningún portlet, hemos de configurar el SDK de Liferay. Para ello, en Eclipse, elegimos el menú Window / Preferences, y en el diálogo que se nos abre, ir a Liferay / Installed Plugin SDKs / Add... y poner la ruta del SDK que nos descargamos.

Fig. 1. Configurar el SDK de Liferay

2. Crear el proyecto de portlet.

En la barra de herramientas de Eclipse, si hemos instalado el IDE de Liferay para Eclipse (como se describía aquí) tenemos un botón que, al desplegarlo, nos da varias opciones para crear portlets. Aquí nos surge la primera duda: ¿cuál de ellas utilizar?

Fig. 2. ¿Qué opción nos interesa para crear el primer portlet?

Como ya he dicho en otras ocasiones, yo estoy aprendiendo en estos temas, así que tampoco lo tengo claro. Por eso, para empezar voy a utilizar la opción que me explicaron en un curso que hicimos hace poco. Con el tiempo, espero ir conociendo las diferencias y, si viene al caso, contarlas aquí.

Así que elegiremos la primera opción "New Liferay Plugin Project" y le pondremos nombre al proyecto

Fig. 3. Dando a nuestro proyecto un nombre original donde los haya

Al pulsar Next, en el siguiente formulario dejaremos las cosas como están, para trabajar con el framework MVC de Liferay, aunque ya vemos que hay otras opciones que tendremos que explorar en el futuro. Tengamos en cuenta que lo que ahora nos interesa es construir un "Hola, mundo" básico con las mínimas complicaciones.

Fig. 4. Dejamos el framework Liferay MVC, la opción por defecto

Al pulsar Finish, tras unos segundos (a mí se me hacen eternos) veremos en la consola un mensaje como este

BUILD SUCCESSFUL
Total time: 2 seconds

y también veremos que en el Package Explorer, a la izquierda, se ha creado el proyecto de nuestro portlet con varias carpetas y ficheros. La que ahora nos interesa es la carpeta WEB-INF y lo que cuelga de ella.

Fig. 5. La carpeta WEB-INF contiene la chicha de nuestro portlet

Este portlet hace más bien poco, pero es lo que tienen los ejemplos "Hola, Mundo", así que no le añadiremos de momento ninguna funcionalidad, y lo que haremos será publicarlo sin más. Ya analizaremos más adelante los ficheros, las rutas... y añadiremos un poco de funcionalidad.

3. Publicar el portlet

Esto se puede hacer de manera gráfica muy fácilmente: bastará con arrastrar el porlet (nodo raíz "HolaMundo-portlet" en el Package Explorer) al servidor que hay abajo, como se ve en la figura 6.

Fig. 6. Arrastrar y soltar para publicar el portlet

También se puede publicar el portlet pulsando con el botón secundario del ratón sobre el servidor y elegir la opción "Add and remove..." del menú contextual.

Fig. 7. Publicar el portlet desde el menú contextual

En el diálogo que se nos abre, vemos los portlets disponibles (en este caso, sólo el que acabamos de hacer) y ya lo podemos publicar

Fig. 8. Seleccionamos el portlet a publicar y pulsamos Finish

En cualquier caso, una vez publicado el portlet, ya podemos ver que colgando del servidor, en la parte inferior izquierda de Eclipse, tenemos el porlet, y junto a él la leyenda [Synchronized]. Esto nos indica que está publicado y listo para ser utilizado en nuestras páginas web.

Fig. 9. El portlet publicado en el servidor

4. Incluir el portlet en nuestra página

Vayamos ahora a la página que creamos en el tutorial anterior (Primeros pasos con Liferay), aunque, si lo preferimos, también podemos crear una página nueva, naturalmente. Si hacemos clic en el signo "+" debemos abrir el grupo de componentes "Ejemplos" y dentro de él encontraremos el nombre que hemos dado a nuestro porlet (el "Display name"). Así que simplemente tenemos que pulsar "Añadir" (aparece al pasar el cursor junto al nombre del portlet, como se ve en la fig. 10)

Fig. 10. El porlet "Hola, Mundo" está en el grupo "Ejemplos", 

y al lado de su nombre el botón "Añadir"

Tras añadirlo, ya podemos ver que el portlet aparece en la página web

Fig. 11. El portlet ya incluido en nuestra página. De momento, no podemos añadir más instancias

Como se ve en la fig. 11, el nombre en el bloque "Ejemplos" ahora aparece en gris. Esto se debe a que es un portlet definido para que sólo se pueda incluir una vez en la página, o sea, un portlet de instancia única (un Singleton). En otra ocasión veremos cómo definir que el porlet puede aparecer más de una vez (multiinstancia).

Bueno, pues ya hemos visto cómo hacer el portlet más básico, "Hola, Mundo", cómo publicarlo y cómo incluirlo en nuestra página web. Con esto terminamos este pequeño tutorial.

Primeros pasos con Liferay

En una entrada anterior vimos cómo instalar Liferay. Veamos ahora el aspecto que tiene y cómo podemos empezar a realizar las tareas más básicas, como crear una página web simple y publicar una noticia en ella. Este será un paso previo antes de comenzar a desarrollar nuestros propios portlets y poder publicarlos.

1. Explorar el perfil del usuario test

Iniciaremos sesión con el usuario que configuramos la primera vez que abrimos el portal. En mi caso, dejé el usuario de prueba, con dirección de email "test@liferay.com" y clave "test".

Fig. 1. Inicio de sesión en Liferay

Una vez autenticados, veremos la página principal de nuestro portal. Esta página tiene de título "Welcome" y consta de dos elementos:

• una caja con el título "Login" donde se muestra nuestro nombre de usuario. El nombre de usuario tiene un enlace
• una caja de texto de título "Hello world" donde se muestra la versión de Liferay

Fig. 2. Página principal del usuario Joe Bloggs

   
En la caja "Login", si hacemos clic sobre el nombre del usuario, podemos ver el perfil de nuestro usuario y modificar los datos apropiadamente. En mi caso, me limitaré a cambiar la contraseña, cosa que podemos hacer en la segunda opción del menú de la derecha.

Fig. 3. Perfil del usuario. Aquí podemos consultar y cambiar datos, contraseña...

En la opción "Roles" podemos ver que este usuario tiene, entre otros, el rol "Administrator". Bueno, parece que con esto podremos hacer todas las tareas que deseemos. Ya veremos más adelante si es así.

Fig. 4. El usuario "test" tiene varios roles: Administrator, Power User, User, Power Ranger...

Bueno, toda esta información se guarda en una BD que Liferay lleva configurada por defecto y que, de ser necesario, podemos cambiar (de hecho, SE RECOMIENDA que se cambie para sistemas en producción). Habrá que investigar esto más adelante.

2. Crear una página "Hola, Mundo"

No quiero modificar la página por defecto, así que comenzaré por crear una nueva página en blanco a la que le iremos añadiendo "cosas". Estas "cosas" pueden ser desde simples cuadros de texto hasta complejas aplicaciones que podrían acceder a bases de datos, hacer cálculos complejos, etc... todo ello encapsulado en un portlet.

Para crear nuestra página, haremos clic en el botón con el símbolo "+" a la izquierda

Fig. 5. Crear nueva página

Le ponemos un título imaginativo como "Página 1" (¡qué creatividad!) y decidimos si queremos que se vea con una columna, dos columnas... y cómo se distribuye el espacio entre ellas.

Fig. 6. Especificaciones de la nueva página: título y formato visual

Tras pulsar "Añadir página" ya podemos ver la nueva página.

Fig. 7. La nueva página en blanco. Con la cara lavada y recién peiná

Ahora ya podemos empezar a añadir componentes, elementos o portlets (lo que antes llamé "cosas") a esta página. Uno de los portlets más simples es un visor de texto donde podemos poner un mensaje, por ejemplo, una noticia para nuestro sitio web. Para hacer esto, pulsamos de nuevo en el botón "+" (Añadir) y nos vamos al apartado de "Aplicaciones". Ahí elegimos el "Visor de contenidos web" y pulsamos añadir (número 1 en la fig. 8). Tras eso, aparece en la página el visor (número 2) y para modificar el texto pulsamos en el enlace "Añadir" dentro del Visor (número 3 en la fig. 8).

Fig. 8. Añadir un porlet "Visor de contenido web"

Ahora podemos editar el texto de la noticia

Fig. 9. Redactando una noticia importantísima para la Humanidad

Y ahora, al pulsar "Publicar", ya podemos ver nuestra página flamante mostrando la noticia que hemos creado.

 Fig. 10. Nuestra importantísima noticia, lanzada al mundo

Buen punto para cortar aquí. En una próxima entrada veremos cómo hacer nuestro propio portlet.

Configurar Eclipse para desarrollar para Liferay

Esta entrada podría verse como un complemento a la entrada que publiqué hace unos días sobre instalación y configuración de Liferay. Esta explicación que sigue es la que a mí me hubiera gustado tener cuando tuve que configurar Eclipse para trabajar con Liferay.

Una vez instalado Liferay, lo que queremos es prepararnos un entorno adecuado para comenzar a desarrollar portlets para publicarlos en nuestro portal. El entorno ideal para esto (aunque no tiene por qué ser el único, claro) es Eclipse. ¿Y cómo lo dejamos listo para esto? Veamos cómo hacerlo en tres pasos. Vamos allá.

Paso 1. Descargar e instalar Eclipse

Dirección de descarga: https://www.eclipse.org/downloads/
Ten la precaución de elegir la versión acorde con tu sistema: 32 o 64 bits.

Descomprime el ZIP descargado en la carpeta que quieras. En mi caso, lo descomprimiré en c:\bin\eclipse. Iniciando el ejecutable, debería verse una pantalla como esta.

Fig. 1. Desvirgando Eclipse

Pulsando en Workbench (arriba a la derecha) se accede a la zona de trabajo.

Paso 2. Instalar la perspectiva para Liferay

Eclipse puede trabajar con perspectivas, que son agrupaciones de vistas y editores. (Más info, aquí [http://www.comscigate.com/cs/valle/vistas.htm] o aquí [http://www.tecgurus.net/foro/19-eclipse/616-perspectivas-en-eclipse.html]), por ejemplo.

Si nos fijamos, recién instalado Eclipse sólo vemos la perspectiva típica para el desarrollo en Java.

 Fig. 2. Perspectivas en Eclipse

Vamos a instalar el soporte para la perspectiva de desarrollo para Liferay y veremos cómo cambia la cosa. Para ello, hay que ir al menú Help de Eclipse, y elegir la opción Install new software.... Pegar en Work with la dirección siguiente http://releases.liferay.com/tools/ide/latest/stable/
y seleccionar "Liferay IDE" (contiene 3 subopciones, que dejamos marcadas).

Fig. 3. Seleccionando el IDE de Liferay para integrar en Eclipse

Tras pulsar Next (2 veces) y aceptar los términos de la licencia, comienza la descarga. Puede ser que a mitad de la misma os pregunte si queréis descargar contenido no firmado. Lo descargamos y continuamos adelante.

 Fig. 4. Descargando complementos Liferay para Eclipse

Al terminar (en mi caso, la descarga dura unos 5 minutos), nos pedirá reiniciar Eclipse para que los cambios tengan efecto.

Fig. 5. Reiniciar, la eterna solución

Tras reiniciar, aparentemente todo está igual, pero no es así. (Por cierto, si por un casual alguien intenta instalar por segunda vez el plugin de Liferay, verá algo como esto)

Fig. 6. ¿Ande vas? Que eso ya está instalaaaaaadooooo

El caso es que ahora ya podemos pulsar en el botón que abre las diferentes perspectivas, y podemos ver una para Liferay

Fig. 7. Abrir la perspectiva para Liferay

Y podemos ver algunos puntos interesantes, como el botón para activar la perspectiva para desarrollo Liferay, y la vista de Servidores donde (por el momento) aún no tenemos ningún servidor configurado (todo se andará, tranquilos).

Fig. 8. Perspectiva Liferay instalada en Eclipse

Paso 3. El servidor de Liferay

Lo único que nos falta es configurar nuestro servidor para tener un entorno de desarrollo y pruebas para empezar a desarrollar portlets con Liferay. Para configurar el servidor, utilizaremos el que instalamos en la anterior entrada.

Pulsamos sobre el enlace para crear un nuevo servidor (esquina inferior izquierda) y elegimos el tipo de servidor dentro del grupo Liferay. En mi caso, Liferay v6.2 CE Server (Tomcat 7)

 Fig. 9. Elegir el tipo y versión del servidor Liferay

Al pulsar siguiente, nos pregunta que dónde está instalado el Tomcat. Se lo decimos

Fig. 10. ¿Dónde está el gatito Tom?

Si nos hemos descargado los Javadocs y los fuentes de Liferay, podemos configurarlos en la siguiente pantalla. Si no, podemos darle directamente a Finish, y ya veremos que nos aparece el servidor disponible para que lo arranquemos y podamos hacer cosas con él. Para iniciarlo, sólo hay que darle al play.

Fig. 11. El servidor Liferay disponible y a punto de ser iniciado

El arranque del servidor no es rápido. En mi equipo se lleva casi dos minutos, durante los cuales se van viendo diferentes mensajes en la consola, y junto al nombre del servidor aparecen las palabras "Starting, Synchronized". Cuando termina, se lanza automáticamente una ventana del navegador y en Eclipse se ven junto al servidor las palabras "Started, Synchronized". En la consola, deberéis ver entre los últimos mensajes algo así como

INFORMACIÓN: Server startup in 70733 ms

(En mi caso, tras este mensaje de "Server startup" tengo alguno más, de warning, pero creo que se debe a que para hacer esta pequeña guía he hecho varias instalaciones / desinstalaciones y seguramente he dejado algo de basurilla por ahí.)

Bueno, creo que éste es un buen sitio para dejar aquí el asunto de momento. Ya tenemos un entorno disponible; lo siguiente sería hacer nuestro primer portlet. Pero eso es cosa para otra entrada.