Cambiar el nombre del equipo en Ubuntu

El equipo en el que estamos trabajando tiene un nombre, que se puede consultar con el comando 'hostname' tanto en Linux como en Windows.

¿Y para cambiarlo?

En la última instalación de mi Ubuntu no estuve muy acertado al elegir el nombre de equipo, y ahora me gustaría cambiarlo.

Simplemente, hay que editar estos dos ficheros:

/etc/hostname
/etc/hosts

Y ya está.

Bueno, en mi caso, además tuve que reiniciar.

En Windows se puede cambiar desde la interfaz gráfica, en Propiedades de "Equipo" o "Mi PC" (según versión).

Gracias a la comunidad Ubuntu por esta información, que podéis consultar, junto con muchas otras cosas útiles, aquí. Aunque hay que reconocer que la web está un poco dejada...

Aversión a las versiones

Escudos y bichos con alas encima: mismo tema, diferentes versiones

(Baeza, palacio de Jabalquinto)

Aunque resulte difícil de creer, hay usuarios que no saben con qué versión de Windows están trabajando.

- José, tengo no-recuerdo-qué-problema con el ordenador de mi casa. ¿Cómo lo arreglo?
- Hmm... ¿qué versión de Windows tienes? (ya paso de preguntar qué versión de "sistema operativo", porque entonces me toca explicar qué es eso)
- Pues... no sé... ¿el 2007?
- No, eso es el Office que tienes pirateado

Como diría Forges: Gensanta.

Parece una trivialidad saber la información del sistema operativo, o que puede que esto no tenga demasiado interés, pero el asunto puede traer más cola de lo que parece. Así que allá van algunas formas de saber la versión del Sistema Operativo con la que estás trabajando.

1. Windows, modo gráfico

Ir a Inicio / Panel de Control / Sistema
Dependiendo de la versión, verás una ventana u otra, pero en cualquier caso, por algún lado te debería informar acerca de  la versión.

En Windows XP y Windows 7 se ve algo así:

Fig. 1. Información de la versión y algo más en Windows XP

Fig. 2. Información de la versión y algo más en Windows7

En ambos casos, además de la versión del SO, también se da información sobre el equipo como memoria, parches instalados, velocidad del procesador... En fin, que merece la pena echarle un vistazo.


2. Windows, modo ventana negra
La opción gráfica está bien para los usuarios "normales" pero, como informáticos, a veces puede que queramos utilizar la información de la versión en un programa, por ejemplo, un script que recupere esta información del SO y tome las decisiones oportunas.

En principio, podemos abrir una ventana de comando (Inicio / Ejecutar... cmd) y... y nada más. En Windows XP y Windows 7 la propia ventana ya te muestra una línea con la versión, aunque puede ser un poco críptico entender que la versión 6.1.7601 es en realidad Windows 7

Fig. 3. Tengo el Windows 6.1.7601. ¡Qué sorpresa!

No obstante, si queremos usar la información en un script, necesitaremos un comando que devuelva esa información. Como podéis ver en la Fig. 3, el comando ver permite obtener esta información.

Al menos Windows XP sí que te pone, antes del numerito, que estás utilizando Windows XP

Fig. 4. Y este es el XP

 3. Linux, modo gráfico
Cada distro de Linux es un mundo, así que yo sólo puedo hablar de Ubuntu 15.04, que es lo que tengo actualmente. En ese caso, en la pantalla de login inicial se muestra la información:

Fig. 5. Información sobre la versión en Ubuntu 15.04, antes de entrar

4. Linux, modo ventana
Pero de nuevo, si nos interesa obtener la información en un comando para usar esto en nuestros scripts, podemos utilizar el comando lsb_release con el parámetro -a (lo de LSB significa Linux Standard Base, por si ardíais en deseos de saberlo, que os conozco)

Fig. 6. Comando lsb... (LSB = ¿Lo SaBe? ¡Vivan los chistes malos!)

Desconozco si este comando es el mismo en otras distros, aunque imagino (más bien, espero) que sí.

En cuanto al comando, me gusta más cómo lo hace Windows. Creo que "ver" es bastante intuitivo y fácil de recordar para recuperar la VERsión, mientras que el comando de Ubuntu no me parece tan recordable (entre otras, esa es una de las razones por las que escribo estas notas para mí). Sin embargo, en la información que devuelven, veo mucho más legible la de Ubuntu que la de Windows 7.


5. Android y similares
Ya puestos, pongamos también cómo consultarlo en Android, porque muchas veces las aplicaciones que podemos instalar están limitadas por la versión de Android, y aquellos usuarios para los cuáles yo soy su servicio-técnico-del-móvil con frecuencia no saben la versión de Android que lleva su móvil. Imagino que esto os pasará a más de uno.

Lo de "similares" que he puesto en el título de este apartado es que en mi caso, en vez de mirarlo en un Android "estándar" de Google, yo tengo el CyanogenMod, pero vamos, para el caso, es lo mismo.

Para ver la versión en estos SO, hay que entrar en Ajustes / Información del teléfono y buscar una entrada similar a esta

Fig. 7. Version de Android / Cyanogenmod

6. La anécdota
Y por último, y hablando de versiones de sistemas operativos, dejemos hueco para la anécdota. Como sabréis, tras el récord de permanencia de XP (mira que ha durado años en nuestros equipos: era una buena herramienta), las versiones de Windows se han sucedido en los últimos años a una velocidad algo rápida: Windows 7, Windows 8 y... ¿Windows 9? Pues no, directamente ahora llega Windows 10. Y, aunque no hay una explicación oficial para este salto, esta entrada de Genbetadev comenta algunas de las bromas que se han utilizado para explicar este hecho. Y después acaba mostrando código REAL que parece hecho de broma. Muy ameno, bien explicado y recomendable para quién tenga que programar y pelearse con la versión del sistema operativo.

Generar RTF desde nuestras aplicaciones

A veces puede ser muy interesante que nuestra aplicación genere un fichero RTF que luego los usuarios puedan editar con Word o Writer para modificar, imprimir, convertir a diferentes formatos como PDF, docx, odt...

La buena noticia es que los RTF son simplemente ficheros de texto con unas etiquetas especiales que indican el formato del texto, de las tablas, de las imágenes y de los demás elementos. Así que no es difícil hacer un programa que vaya escribiendo este tipo de etiquetas combinadas con el texto a incluir.

La mala noticia es que los distintos editores con capacidad para crear un RTF tienen distintas opiniones acerca de lo que debe incluirse en un documento con Formato de Texto Enriquecido (que es lo que significa más o menos la sigla RTF, Rich Text Format).

Si creáis un RTF sencillo con cualquier editor ofimático, tendréis algo así (en este caso, parto de un RTF creado con LibreOffice Writer 4.4 en Ubuntu):

Fig. 1. Un RTF sencillo

Y ahora, si en vez de hacer doble clic sobre el icono del fichero, lo abrís con un editor de texto podréis ver algo similar a esto:

Fig. 2. Las tripas del RTF (versión LibreOffice Writer)

Si abrimos ese mismo RTF con Word 2003 y lo volvemos a guardar, vemos que Word le ha metido bastante más información

Fig. 3. El RTF después de pasar por las manos de MS-Word, el cual ha decidido añadirle muuuuuuchas cosas

Por último, lo he abierto y vuelto a guardar con WordPad (de Windows 7) y veo que es el que deja el RTF más limpito, con aparentemente la menor cantidad de información.

Fig. 4. El RTF exportado con WordPad (Windows 7)

Como es lógico, los tres ficheros difieren bastante en el tamaño, ya que la versión de Word es la que más información lleva (8 KB) y la versión de WordPad es la más pequeña (225 bytes).

Como curiosidad, decir que he generado un RTF a mano con el editor de texto y dejándolo en algo tan reducido como esto

Fig. 5. Un RTF superreducido generado a mano

Aquí podéis ver los tamaños de las distintas versiones

Fig. 6. A menos paja, menos tamaño

Ojo, el caso manual tiene "trampa", pues me he saltado algunas partes que son necesarias según la especificación oficial del formato RTF, pero como los programas prefieren rellenar la falta de información con valores predefinidos antes que morir dando un error miserablemente, podemos abrir este documento hecho a mano sin problemas en Word 2003, WordPad y LibreOffice 4.3 (tanto versiones de Windows como de Ubuntu), que ya se encargan ellos de asignar valores por defecto a todo lo que no se especifique (fuentes de texto, colores...). Eso sí, cada uno de estos programas le ha puesto un tipo de letra y un tamaño a su antojo, ya que el documento creado de forma manual no indica nada respecto a las fuentes a utilizar, así que los valores por defecto juegan aquí un papel fundamental.

En próximas entradas entraré en los detalles de los RTFs, a fin de que nuestras aplicaciones puedan generar este tipo de ficheros sin demasiadas complicaciones.

Por de pronto, los impacientes pueden ir empezando a leerse la especificación oficial:

http://www.biblioscape.com/rtf15_spec.htm

Para mí ha sido la Biblia durante unos cuantos días.

Trocear parámetros de la línea de comando (comando xargs)

Hoy os voy a contar la solución a un pequeño problema que se me ha presentado hace unos días, y así aprovecho para contaros una cosa que no sabía y que he acabado utilizando del comando xargs.

El caso es que tenemos un script que procesa cadenas de texto y compone con ellas una cadena más grande. En concreto, las cadenas son una serie de valores con los que el script compone la condición de una instrucción SQL (una select) del estilo

select campo1, campo2...
from tabla
where dato in ('dato1', 'dato2', 'dato3'...)

Esos dato1, dato2... son los parámetros que se le pasan al script.

Queda más claro viendo la Fig. 1.

Fig. 1. Salida del script que genera instrucciones SQL con cláusula "in"

Como es fácil imaginar, el script no está pensado para ejecutarlo manualmente, sino que las cadenas a incluir proceden de una lista existente en un fichero de texto plano. He sustituido los datos reales por basura, pero más o menos, algo así:

Fig. 2. La lista de valores a procesar. Imaginativa, ¿a que sí? Lo que yo decía...

Hay que aclarar que el script no procesa la entrada estándar, en cuyo caso podríamos haber utilizado los pipes (tuberías), sino que espera que le llegue la lista de cadenas (datos) como parámetros. Es decir, los extrae de la variable $argv (es un script PHP).

Una forma fácil de pasarle los valores al script podría ser utilizando las comillas simples invertidas para ejecutar el comando cat y luego la salida de este comando que se sustituya en la línea de comandos de la llamada a nuestro script. No os compliquéis leyendo de nuevo lo que he dicho, queda más claro leyendo el código de la Fig. 3. Vamos, algo así:

Fig. 3. Uso de las comillas simples invertidas para pasar los parámetros al script

Otra solución podría ser utilizar el programa xargs. ¿Y qué hace este programa? Básicamente, recoge todo lo que haya en su entrada estándar y se lo pasa como parámetros al programa que le digamos. Se entenderá mejor con un ejemplo: vamos a ver en la Fig. 4 cómo conseguir lo que hemos hecho antes utilizando xargs en vez de las comillas invertidas.

Fig. 4. Uso de xargs para conseguir el mismo resultado que antes

Hasta aquí vemos dos formas en apariencia más o menos equivalentes (de momento, no entraremos a hablar de rendimiento) de hacer lo mismo. Sin embargo, el problema que estamos resolviendo tiene una peculiaridad más, y aquí ya veremos cómo ambas formas de hacerlo ya no nos valen por igual.

TROCEAR LA ENTRADA

La lista a procesar tiene muuuuuuuuuuchos valores, más de diez mil. En vez de que se nos genere una cláusula "in" monstruosamente grande, lo que queremos es trocear la consulta en diferentes consultas que iremos dosificando poco a poco a la base de datos, a fin de no saturarla y poder ir obteniendo resultados parciales. O por los motivos que sea, que ahora mismo dan igual.

Y aquí es donde se revela una ventaja muy importante de xargs: la capacidad de generar no una, sino N llamadas al comando indicado, pero dándole "bloques" de argumentos del tamaño que queramos. Es decir, en vez de llamar una sola vez al script, y en esa llamada pasarle todos los parámetros de golpe, puede que queramos ir pasándole los argumentos de 10 en 10, pongamos por caso, y que nos devuelva las diferentes SQL con los parámetros de cada bloque.

¿Y cómo se consigue esto: simplemente con la opción -nX del comando xargs, donde debemos sustituir X por el número que indique cuántos parámetros se le pasarán al comando en cada llamada. Así, por ejemplo, si queremos pasarle los argumentos de 10 en 10, pondríamos lo siguiente:

Fig. 5. Pasando los parámetros al script en bloques de 10

En este caso, la lista que he utilizado tiene sólo 29 elementos, así que podemos ver que en la última SELECT se han utilizado los 9 últimos que quedaban, y no 10 argumentos, como en las dos llamadas anteriores. Es decir, que si el script está pensado para recibir un número fijo de parámetros, hay que tener en cuenta que al trocearlos, es posible que la última invocación no incluya todos los necesarios.

Una cosa interesante es que si invocáis a xargs con la opción -t, podéis ver qué se ejecutará sin llegar a ejecutarlo de verdad, sólo se muestra la línea de comando que se ejecutaría. Esto viene bien para hacer pruebas antes de lanzar la llamada definitiva.

No me extiendo más, pero os sugiero que le dediquéis un rato a la página del manual del comando xargs, que posiblemente amortizaréis el tiempo empleado en ello.

Que ustedes tengan un buen tecleo.

PARA SABER MÁS

1. En español: http://systemadmin.es/2009/04/uso-de-xargs-herramientas-unix-ii#

2. En inglés: https://en.wikipedia.org/wiki/Xargs

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

Bueno, por diversos motivos he tenido que estar parado un tiempo sin poder actualizar el blog, lo siento mucho. Así que voy a ver si ahora puedo poco a poco volver a la normalidad y hacer las entradas de forma más frecuente.

Continuamos con la creación de un portlet que consulta a una BD Oracle y nos muestra los datos en una simple tabla HTML.

Enlace a la primera parte.

Recordemos que lo último que habíamos hecho era incluir el driver de Oracle en nuestro proyecto, así que ya podemos pasar a establecer la conexión con la BD.

5. Establecer la conexión

Para crear la conexión, necesitamos un objeto de la clase Connection. Esta clase se encuentra en el paquete java.sql, así que añadiremos estas líneas al código:

    import java.sql.Connection;
    ...
   
    //conectar
    Connection conOracle = null;
    conOracle = this.getConexionOracle();

También necesitaremos otras clases de este paquete, así que las añadiremos:

    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.sql.ResultSet;

Una opción más cómoda sería haber importado todo el paquete java.sql con una única instrucción, así:

    import java.sql.*;
   
Pero yo prefiero especificar individualmente cada clase (si fueran muchísimas no me complicaría la vida e importaría todo el paquete, pero en este caso son pocas). De esta manera, hacemos explícito el conocimiento de las clases que estamos importando.

Para conectar con un servidor Oracle, necesitamos los siguientes datos: servidor (nombre o dirección IP), puerto (por defecto, 1521), nombre del esquema, usuario y la clave. Si tenéis claro todo esto, el método para obtener la conexión quedaría algo así (he borrado los datos específicos de mi instalación, naturalmente):

    private Connection getConexionOracle() {
        String
            servidor = "xx",
            puerto   = "1521",
            esquema  = "xx",
            passBD = "xx",
            usuario = "xx";
        String cadenaBD = "jdbc:oracle:thin:@" + servidor + ":" + puerto + ":" + esquema;
        Connection conOracle = null;
        try {
            DriverManager.registerDriver (new oracle.jdbc.driver.OracleDriver());
                conOracle = java.sql.DriverManager.getConnection(cadenaBD, usuario, passBD);           
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("Error en getConexionOracle() : " + e.getMessage());
        }
        return conOracle;
    }

OJO: esto de poner en el propio código Java los datos de la conexión probablemente no es la forma más adecuada de hacerlo. De momento lo dejaremos así por simplicidad de comprensión, pero no es lo más recomendable. Sería mejor configurar la conexión a nivel del contenedor de portlets (Tomcat en nuestro caso, Javaboss... ) y desde el código Java obtener la conexión.

6. Realizar la consulta

Una vez obtenida la conexión, ya está hecho lo más difícil. Ahora tan sólo nos queda realizar la consulta, lo cual podemos hacer con el código que se ve a continuación

    //recuperar datos
    Statement orclStmt = conOracle.createStatement();
    String sql = "select campo1, campo2 from tabla order by campo1 ";
    orclResult = orclStmt.executeQuery(sql);

Como vemos, se utiliza el método createStatement del objeto conOracle y el objeto Statement devuelto nos permite ejecutar la consulta correspondiente.

El objeto oraclResult es de tipo java.sql.ResultSet. Como véis, no lo he declarado en estas líneas, y eso se debe a que voy a poner todo este código dentro de un bucle try/catch, ya que los métodos createStatement y executeQuery pueden lanzar algunas excepciones y debemos atraparlas. Por ello, declararé las variables orclResult y la variable conOracle antes de este bloque, así:

public String recuperarTablaHTML() {
    String res = "<table border=1>";
   
    Connection conOracle = null;
    ResultSet orclResult = null;
    try {
        //conectar
        conOracle = this.getConexionOracle();

        //recuperar datos
        Statement orclStmt = conOracle.createStatement();
        String sql = "select campo1, campo2 from tabla1 order by campo1 ";
        orclResult = orclStmt.executeQuery(sql);

Nuestro código va tomando forma.

7. El bucle de procesamiento

Una vez obtenido el resultado, ya sólo nos queda ir recorriendo el conjunto de registros del resultado. Algo que podemos hacer así:

    while (orclResult.next()) {
        String campo1 = orclResult.getString("campo1");
        String campo2 = orclResult.getString("campo2");
        res += "<tr>";
        res += "<td>" + campo1 + "</td>";
        res += "<td>" + campo2 + "</td>";
        res += "</tr>";
        this.numResultados++;
    }

También hemos introducido en el bucle un contador del número de registros procesados, como puede verse en la última línea dentro del bucle.

8. Mostrar los resultados

Bueno, pues hecho todo lo anterior, sólo nos queda regresar al fichero view.jsp y añadir el código para mostrar el resultado.

Fig. 17. Mostrando los resultados en la vista del portlet

Ahora nos vamos al portal y comprobamos si todo funciona como debería:

Fig. 18. Ejecutando el portlet en nuestro portal

Bueno, parece que sí. Así que ya podemos dar por terminada esta entrada.

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.