Apuntes de Java

Un par de regalos para finalizar el año: Plugins para NetBeans

2011-12-29T13:20:00.002-05:00

Antes de finalizar este año - que personalmente me sucedieron varias cosas entre buenas y malas - quiero dejaros un par de enlaces de plugins para que lo anexen a su NetBeans 7.x y con ello tendrán un editor de XSLT y de otros plugins.

Considerar los siguientes enlaces

http://deadlock.netbeans.org/hudson/job/nbms-and-javadoc/lastStableBuild/artifact/nbbuild/nbms/updates.xml.gz
http://deadlock.netbeans.org/hudson/job/xml/lastSuccessfulBuild/artifact/build/updates/updates.xml

Ambos se deben agregar en la ventana Tools > Plugins y en la ficha "Settings". Una vez agregado, se mostrarán los plugins adicionales en la ficha "Available plugins".

El primer enlace contiene varios plugins interesantes, entre los que mencioné en un anterior post: Plugins curiosos para NetBeans 6.8

El segundo contiene el editor de XSLT mencionado en el post: Un editor de XML Schema gratuito... NetBeans

Que el nuevo año les sea para bien :)

AOP con Java EE 6

2011-09-26T07:00:00.000-05:00

En un anterior Post hablé sobre AOP usando Spring. Es un post algo antiguo, y me había basado de un artículo publicado en JavaRanch.

Esa vez fue usando el famoso Framework Spring, pero esta vez mencionaré como funciona el AOP desde Java EE6. Creo que ya existía desde la versión EE 5, pero no importa, aquí lo mencionamos para el deleite de todos.

A diferencia del Spring, es que este AOP funciona desde un contenedor Java EE, y sobretodo, en un EJB. En Spring funciona desde cualquier aplicación que tenga la biblioteca Spring.

Así que, para que funcione nuestro ejemplo, debemos crear un módulo EJB.. pero esta vez - a diferencia de otros tutoriales - crearemos una Aplicación Enterprise (EA) con un módulo EJB y WAR. El EA se llama aop-ea, y los módulos se llaman aop-ejb y aop-war respectivamente.

Luego, en nuestro módulo EJB crearemos una clase común y silvestre llamada MonitoreoInterceptor y tendrá el siguiente contenido:

package com.apuntesdejava.aop.ejb.interceptor;

import java.lang.reflect.Method;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.interceptor.AroundInvoke;
import javax.interceptor.InvocationContext;

public class MonitoreoInterceptor {
    static final Logger LOGGER=Logger.getLogger(MonitoreoInterceptor.class.getName()); //para mostrar el log
    
    @AroundInvoke //Define un método interceptor que se interpondrá en los métodos del EJB
    public Object seguimientoMetodo(InvocationContext invocationContext) throws Exception{
        Object objetoInterceptado=invocationContext.getTarget();
        Method metodoInterceptado=invocationContext.getMethod();
        // para mostrar el metodo que se va a ejecutar
        LOGGER.log(Level.INFO, "Ejecutando m\u00e9todo: {0}.{1}()", 
                new Object[]{objetoInterceptado.getClass().getName(), metodoInterceptado.getName()});
        
        Object o=invocationContext.proceed(); //hacemos ejecutar el método, o si hay otro interceptor, le damos la posta
        // la variable devuelta es el resultado del método, o NULL si es un método VOID
        
        LOGGER.log(Level.INFO, "Saliendo del m\u00e9todo: {0}.{1}()", 
                new Object[]{objetoInterceptado.getClass().getName(), metodoInterceptado.getName()});
        
        LOGGER.log(Level.INFO, "EL m\u00e9todo devuelve el valor: {0}", o);
        
        return o; //que continue la secuencia
    }
    
}

Solo aquí hemos definido el interceptor. Ahora, crearemos un EJB en el móduglo EJB con un par de métodos y lo interceptamos con la clase que acabamos de crear.

package com.apuntesdejava.aop.ejb.facade;

import com.apuntesdejava.aop.ejb.domain.Persona;
import com.apuntesdejava.aop.ejb.interceptor.MonitoreoInterceptor;
import java.util.ArrayList;
import java.util.List;
import javax.ejb.Stateless;
import javax.interceptor.Interceptors;


@Stateless
public class PersonaFacade {

    private static List<Persona> personas = new ArrayList<Persona>();

    @Interceptors({MonitoreoInterceptor.class}) //le colocamos un conjunto de interceptores
    public void nuevo(Persona p) { //el método es uno común y corriente.
        personas.add(p);
    }

    @Interceptors({MonitoreoInterceptor.class})// tambien le colocamos un conjunto de interceptores
    public List<Persona> lista() { //este método devuelve algo
        return personas;
    }
}

Y desde un Servlet llamamos al EJB como si fuera cualquier EJB común.

Uno de los grandes beneficios es que no necesitaremos que heredar código para hacer algo repetitivo, ni repetir el código en todo lugar donde se necesite. Por ejemplo, si queremos monitorear el acceso a ciertas partes de la lógica de negocio, lo colocamos en el Interceptor, y si queremos cambiar la manera cómo vamos a manejar el monitereo, pues claro.. cambiamos solo un interceptor.

//...
@WebServlet(name = "ListaServlet", urlPatterns = {"/ListaServlet"})
public class ListaServlet extends HttpServlet {

    @EJB
    private PersonaFacade personaFacade;

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        List<Persona> lista = personaFacade.lista();
        request.setAttribute("lista", lista);
        RequestDispatcher rd = request.getRequestDispatcher("/lista.jsp");
        rd.forward(request, response);
    }

//...

Además, también podemos ejecutarlo desde un Cliente EJB... Con algunas consideraciones en el EJB, tenemos el siguiente código para el cliente EJB:

//...
public class Main {

    @EJB
    private static PersonaFacadeRemote personaFacade;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Persona p1 = new Persona(1, "Ana");
        Persona p2 = new Persona(1, "Bernardo");
        Persona p3 = new Persona(1, "Carl");
        personaFacade.nuevo(p1);
        personaFacade.nuevo(p2);
        personaFacade.nuevo(p3);
    }
}

El resultado en el Servidor es el siguiente..

Y listo!.. ya estoy monitoreando los métodos!!

Este post no pretendió ser un tutorial de EJB, por lo que me he saltado muchas cosas. El objetivo de este post es solo mostrar como funciona el AOP. Para la creación de un EJB con cliente lo veremos en otro artículo.

El código fuente de este post, incluyendo el cliente de EJB se puede descargar desde aquí: http://kenai.com/projects/apuntes/downloads/download/AOP/aop-ea.tar.gz

Más información sobre los Interceptors, aquí, en la documentación de Java EE 6: http://download.oracle.com/javaee/6/tutorial/doc/gkeed.html

Premios Open Source 2011

2011-09-21T10:17:00.001-05:00

PACKT anuncia la entrega de premios "Open Source 2011" en el que se presentan los mejores productos OpenSource de la comunidad.

Los nominados a esta premiación son los siguientes:

Open Source CMS
- Drupal
- Joomla!
- mojoPortal
- Plone
- SilverStripe

Open Source Mobile Toolkits and Libraries
- FoneMonkey
- jQuery Mobile
- Min3D
- PhoneGap
- Sencha Touch

Most Promising Open Source Project
- Chamilo
- FLOW3
- ImpressPages
- Nette Framework
- Seo Panel

Open Source Business Applications
- Magento
- nopCommerce
- OpenCart
- PrestaShop
- SugarcCRM

Open Source JavaScript Libraries
- Dojo Toolkit
- jQuery
- RaphaelJS
- Sencha (ExtJS)
- YUI Library

Open Source Multimedia Software

Airtime
Blender
GIMP
Inkscape
Krita

¡¡Voten por sus favoritos!!

Para conocer más sobre este evento, visiten:

http://www.packtpub.com/open-source-awards-home

Yo ya tengo mis favoritos.. veamos quien es el ganador.

Java Day en la UNI - agradecimientos

2009-11-27T10:22:00.000-05:00

Anoche se realizó el Java Day en la UNI, donde se expusieron interesantes temas respecto a la tecnología Java, los frameworks (como Spring MVC, Spring ROO) que apoyan enormemente al desarrollo de aplicaciones, las tendencias del desarrollo de sistemas basados en SOA, y más. Fue realmente impresionante.

Solo que el tiempo no nos dió para más. Habían muchos temas que se quedaron en el tintero.

Agradezco a José Luis Casiano por haberme invitado como expositor a este evento. Estuvo todo organizado... y (como le dije).. su tranquilidad me desesperaba. Otras personas estarían golpeándose la cabeza o gritando cuando algo no habría salido como espera.. pero José Luis mantuvo la calma de un cirujano en plena operación.

Los que no pudieron ir ayer al evento, aquí les dejo mi presentación sobre Java EE6.

Lo nuevo de Java EE6

View more presentations from Diego Silva.

También me tocaba exponer sobre JavaFX... solo que el tiempo ya se nos había acabado. Así que aquí publico la presentación de JavaFX.

RIA con JavaFX

View more presentations from apuntesdejava

Anoche no pude acabar con la demostración de una aplicación usando JavaEE6, así que en un siguiente post publicaré el código fuente (además del proyecto para que lo puedan bajar) y de la misma manera sobre JavaFX. Tenía unos ejemplos monos.. en fin.. ya será para otra oportunidad.

Libro: Java EE 6 Development with NetBeans 7

2011-09-20T09:45:00.000-05:00

La gente de PacktPub.com la noble tarea de revisar un libro que habla sobre Java EE 6 con NetBeans 7: Java EE 6 Development with NetBeans 7

Acabo de leerlo y aquí van mis comentarios.

Conozco gente que desea aprender a hacer aplicaciones profesionales utilizando Java EE 6, bajo plataforma Web, JMS, WebService, base de datos, etc. Esta gente conoce el lenguaje Java pero no sabe por donde empezar. En las bibliotecas y librerías no he visto algún libro que hablara de toda la tecnología Java EE 6 utilizando un IDE como este.

Es un libro práctico de leer, orientado a programadores y desarrolladores que conocen el lenguaje Java. Envuelve varios puntos importantes de cada tecnología de Java EE 6. Los tutoriales gratuitos y manuales que se encuentran en la red no cubren ni exponen toda la potencia de Java EE 6. El autor de este libro sí lo hace, de manera ordenada, concisa, directa.

Hubiera sido de mejor utilidad si se expusiera el desarrollo de un tema concreto, y ver como el NetBeans resuelve el problema utilizando el Java EE 6. Pudo haber mostrado el desarrollo de una solución de eCommerce basado desde Servlets / JSP y como se puede mejorar hasta tener RESTful. Aunque, pensándolo bien, ya escaparía el alcance de este libro, ya que su objetivo principal es mostrar todo lo que puede hacer con NetBeans.

El NetBeans es la estrella de este libro, ya que permite realizar tareas complejas utilizando pocos clics: Pruebas de servicios web, creación de páginas JSF, creación de manejadores de JPA, etc. Lo más sorprendente son los capítulos dedicados a EJB y CDI, ya que explican como hacer cliente en EJB, y cómo utilizar el AOP en Java EE 6.

Algo que no me dejó de buen gusto, es que hay partes (muy pocas) que son tomadas de una versión anterior de NetBeans. Quizás el autor, por la prisa, no pudo diferenciar imágenes y código de su anterior publicación (Java EE 5 Development with NetBeans 6). Esto puede confundir al lector porque pudiera esperar el mismo resultado en su IDE tal como aparece en el libro. Pero esto no afecta en la exposición de las tecnologías de Java EE 6. Pero son partes muy pequeñas y no muy relevantes. Creo que soy muy exigente en este punto.

Recomiendo este libro para los desarrolladores Java que quieran entrar en el mundo de Java EE 6. No es la Biblia de Java EE 6, ya que esta tecnología es bastante extensa y no habría libro que cubra profundamente todos los aspectos de Java EE 6, pero da una clara y completa visión de lo que se puede hacer con ella, y qué más, utilizando un gran IDE como es NetBeans.

Aquí les dejo una muestra del capítulo 4, sobre la creación de JSF: Chapter 4 Developing-Web Applications using JavaServer Faces 2.0

Para más información del Libro, ver: http://www.packtpub.com/java-ee-6-development-with-netbeans-7/book

Acceder a ManagedBean desde otro ManagedBean en JSF 2.0

2010-02-13T18:11:00.001-05:00

Cuando se trabaja con variables sesión en JSP/Servlets es fácil guardar estas variables y también accederlas... bueno, al menos para quien ha trabajado bastante con este tipo de variables de sesión: Desde un servlet se debería escribir

request.setAttribute("obj1",obj1);

... cuando se desea guardar una variable de sesión de alcance "request".Para uno de alcance "sesión" es una historia similar.

Y desde un JSP para acceder a esta variable de sesión, usando EL, deberíamos usar algo como esto:

 Mostrando objeto: ${ob1}

Pero en JSF (en especial la versión 2.0), ya no se debería utilizar variables de sesión ya que JSF propone ManagedBeans que tengan alcance Scope, Request, Application, Custom y none. Pues bien, esto funcionaría así.

Un ManagedBean:


@ManagedBean(name="bean1")
@SessionScoped
public class Bean1 {

    public Bean1() {
    }
    private String nombre;

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

}

Y para accederlo desde una página JSF, debería ser así:


<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
        <h:form>
            Nombre:<h:inputText value="#{bean1.nombre}" />
            <br/><h:commandButton value="Guardar" />
        </h:form>
    </h:body>
</html>

Todo normal.. y si accedemos desde otra página, bastaría con escribir #{bean1.nombre}

Hasta ahí todo normal y muy bien.. pero que pasaría si tenemos otro managedBean y queremos acceder al primer managedBean?

Pues bien, se debería declarar una propiedad (con set/get) del tipo del primer ManagedBean, y agregarle la anotación @ManagedProperty("#{bean1}") (Donde bean1 es el nombre del otro managedbean. Y listo!! solo usar.


@ManagedBean(name = "bean2")
@RequestScoped
public class Bean2 {

    @ManagedProperty("#{bean1}")
    private Bean1 bean1;

    /** Creates a new instance of Bean2 */
    public Bean2() {
    }

    public String getSaludo() {
        return "Hola " + bean1.getNombre();
    }

    public Bean1 getBean1() {
        return bean1;
    }

    public void setBean1(Bean1 bean1) {
        this.bean1 = bean1;
    }

    
}

El código fuente de este ejemplo se encuentra aquí: http://diesil-java.googlecode.com/files/ScopesJSF20.tar.gz

Probando RESTful con Poster

2011-09-13T17:36:00.000-05:00

Seguimos con RESTful en Java!
Ya luego comentaré qué pasó conmigo y por qué no estuve enviando contenido a mi blog.
Hasta el momento hemos visto casi de manera abstracta el funcionamiento de RESTful usando Jersey desde NetBeans.

Ahora veremos como probar todo un CRUD de RESTful desde un complemento de Firefox llamado Poster.
La mejor manera de probar un servicio es no creando una aplicación. Es decir, si vamos a probar como funciona algo, no tenemos que hacer un programa que utilice ese algo.
El objetivo principal del RESTful es proveer servicios estándar para todo tipo de cliente ¿cierto? Entonces, si hacemos una aplicación que consuma nuestro servicio, corremos el peligro de que ajustemos el servicio para que corra con nuestra aplicación y al final no sea estándar.

Así que, antes de mostrar el RESTful, debemos instalar el complemento Poster en nuestro Firefox (porque asumimos que como buenos programadores, usamos Firefox) Este se puede descargar desde aquí: https://addons.mozilla.org/es-ES/firefox/addon/poster/

Ahora, les comento que he ordenado un poco el proyecto que hemos estado haciendo en los post anteriores. Ahora tiene un EJB que manejará la colección de entidades (como debe ser) y que está separado de la clase de recursos (como debe ser).

Además, el manejo de las peticiones CRUD en un REST son como sigue:

Verbo REST	URI	Acción a realizar
POST	`/persona`	Create
GET	`/persona/id`	Read
PUT	`/persona/id`	Update
DELETE	`/persona/id`	Delete

Así, el código final del recurso REST es el siguiente:

@Path("/persona")
@Consumes({"application/json", "application/xml"})
@Stateless
public class PersonaService {

    @EJB
    private PersonaFacade facade;

    @POST
    public Response create(Persona p) {
        facade.insert(p);
        return Response.ok(p).build();
    }

    @GET
    @Path("{id}/")
    public Persona read(@PathParam("id") int i) {
        Persona p = facade.findById(i);
        return p;
    }

    @GET
    public List<Persona> read(@QueryParam("nombre")
            @DefaultValue("") String nombre) {
        List<Persona> l = nombre.isEmpty() ? facade.findAll() : facade.findByNombre(nombre);
        return l;
    }

    @DELETE
    @Path("/{id}")
    public Response delete(@PathParam("id") int i) {
        if (facade.delete(i)) {
            return Response.ok().build();
        }
        return Response.status(Response.Status.NOT_FOUND).build();
    }

    @PUT
    @Path("/{id}")
    public Response update(@PathParam("id") int i, Persona p) {
        p.setId(i);
        facade.update(p);
        return Response.ok().build();
    }
}

Y el EJB es el siguiente:

@Stateless
public class PersonaFacade {

    private static List<Persona> lista = new ArrayList<Persona>(); //lista temporal

    public void insert(Persona p) {
        lista.add(p); //agrega a la lista

    }

    public Persona findById(int id) {
        Persona p = new Persona(id); //crea un objeto temporal...
        int i = lista.indexOf(p); //... para buscarlo en la lista
        if (i < 0) {//si no lo encuentra        
            return null; //... devuelve null
        }
        return lista.get(i);  // sino, lo devuelve
    }

    public List<Persona> findAll() {
        return lista;
    }

    public List<Persona> findByNombre(String nombre) {

        List<Persona> $lista = new ArrayList<Persona>(); //un arreglo temporal
        for (Persona persona : lista) {  //se recorre la lista...
            if (persona.getNombre().contains(nombre)) { //se compara el nombre
                $lista.add(persona); //y si es parecido, lo agrega en la lista
            }
        }
        return $lista; //... para devolverlo
    }

    public boolean delete(Persona p) {
        return lista.remove(p);
    }

    public void update(Persona p) {
        int pos = lista.indexOf(p); //busca en la lista..
        if (pos >= 0) { //si lo encuentra...
            lista.set(pos, p); //... lo actualiza            
        }

    }

    public boolean delete(int i) {
        Persona p = findById(i);
        return delete(p);
    }
}

Ejecutando Poster

Ahora bien, una vez instalado el Poster en Firefox, lo abrimos haciendo clic en la barra inferior del navegador en el ícono color amarillo con una letra P. Esto nos abrirá la siguiente ventana:

Es bastante fácil su utilización como lo veremos a continuación.

Ejecutemos el proyecto desde nuestro NetBeans y veremos que se abrirá una ventana de bienvenida (no muy elegante) y un enlace para visualizar la descripción del recurso. Al hacer clic en ese enlace, se mostrará el WADL Podemos examinar por curiosidad para conocer los recursos existentes. Pero en este momento vamos a ver cómo funciona el Poster.

En la casilla URL se deberá poner el URI del servicio completo. Para nuestro ejemplo es http://localhost:8084/PersonasRestful/rest/persona (cambiar el puerto si es necesario)

En la casilla central llamada "Content type" se pondrá el tipo de datos que se manejará en el envío. Le pondremos el valor: application/json

En la caja grande de entrada es el contenido a enviar. Ahí pondremos los datos a enviar.

Create

Para crear un nuevo objeto en la "base de datos" usando el servicio, necesitamos colocar el contenido siguiente:

{
  "nombre":"Ann",
  "fechaNacimiento":"2010-11-12"
}

Luego, hacemos clic en el botón central "POST". El Poster nos mostrará un resultado:

Este resultado es porque se ha puesto que devuelva el objeto que se agregó.
Intentemos agregar más objetos y hacer POST por cada uno de ellos.

Read

Para obtener el listado de todos los objetos registrados en el servicio, nos aseguramos que el URL apunte a URI /rest/persona y hacemos clic en el botón GET. El Poster nos mostrará el siguiente contenido.

Esto me devuelve el listado completo. Pero si solo quiero uno de ellos, y conozco el ID, pondremos en el URI el ID de una persona. Por ejemplo /rest/persona/2 y luego hacemos clic en "GET".

Update

Para actualizar un registro se debe tener lo siguiente: apuntar a un URI incluyendo el ID /rest/persona/2 y en el contenido colocar las propiedades a actualizar. Por ejemplo:

{
  "nombre":"Alfred",
  "fechaNacimiento":"2010-11-12"
}

Y hacemos clic en el botón PUT
Esta petición no nos ha respondido nada, ya que así lo hemos pusimos en el RESTful.
Podemos verificar el contenido haciendo un GET de todos los objetos registrados.

Delete

Igual que el PUT y UPDATE... solo le indicamos el ID en el URI y hacemos clic en "DELETE". Luego verificamos haciendo un GET de todos los objetos registrados y veremos si está o no.

Cambiando el objeto resultado

Como podemos ver, todas las peticiones que hemos hecho (PUT y POST) tienen el formato JSON, pero los resultados a nuestras peticiones tienen formato XML. Bueno, por omisión el Jersey devolverá bajo ese tipo. Pero también permite devolver formato JSON si así lo solicita el cliente POSTER. Para ello vamos a la pestaña "Headers" del Poster y agregamos la siguiente cabecera:

Accept: application/json

.. y hacemos clic en "Add/Change"

Y luego, hagamos el GET de todos los objetos para visualizar el contenido.

Recursos

El proyecto utilizado se puede descargar desde aquí:
http://kenai.com/projects/apuntes/downloads/download/CRUDPersonasRest/personas-restful-crud.tar.gz

RESTful parte 4: Actualizando y eliminando elementos de una colección.

2011-01-15T21:47:00.002-05:00

Todo mantenimiento de objetos debe tener siempre lo que en inglés se llama CRUD (Create - Read - Update - Delete). Hasta ahora hemos visto C y R. Faltan el U y el D. Así que en este artículo hablaremos de ello

En cualquier manera de almacenamiento de datos (sea un arreglo o una base de datos) siempre se debe poder identificar a un solo objeto a través de una clave principal. ¿Cómo se puede borrar o actualizar un solo objeto si no sabemos cuál es?.

En nuestros anteriores artículos hemos creado objetos y le hemos puesto un ID automático. Aunque no es la manera más optima de hacerlo (ya que le hemos puesto como ID el tamaño del arreglo), vamos a actualizar un poco esta asignación. Para ello editaremos la clase Persona de tal manera que tenga un contador de objetos. Para ello hagamos lo siguiente.


//...
public class Persona {    
    private static int contador = 0;    
    public static int getNuevoId() {
        return ++contador;
    }
//...

Luego, en la clase PersonasResource, en el método guardar le cambiaremos la línea donde se asigna el ID con lo siguiente:


//...
     public Response guardar(Persona p) {
            p.setIdPersona(Persona.getNuevoId());     //nueva manera de asignar ID
            personas.add(p);
            return Response.ok(p).build();
     }
//...

Ahora, necesitamos también una manera óptima de identificar un objeto Persona a través de su ID. Creame que usando el for() no es la manera óptima. Debemos usar los mecanismos propios de Java. Para ello, debemos reescribir el método equals() en la clase Persona. Y, como siempre, el NetBeans nos va a ayudar. Abramos esa clase y hagamos clic derecho y seleccionamos Insert code...

y luego seleccionamos "equals() & hashCode()...". Ahora, seleccionamos el campo "idPersona" en ambos paneles. Esto es que se utilizará el campo "idPersona" para hacer la comparación (equals) y para agrupar la comparación (hashCode)

Clic en "Generate".

Y vemos que el NetBeans creó los métodos mencionados.
Una rápida explicación de esos métodos: el equals() sirve para poder comparar dos objetos. Es la única manera de comparar objetos que utilizará el Java. Así nos evitaremos hacer una comparación de un campo por nuestra cuenta cada vez que necesitemos. Y método hashCode() permite devolver un valor que permitirá reducir la comparación. Por ejemplo, si tenemos mil objetos, y todos tienen id diferentes, y necesitamos buscar un ID específico, el Java agrupará todos los que tengan el hashCode similar, y después hará la búsqueda uno por uno dentro de ese grupo reducido.

Obtener un objeto de la colección a través de su ID

Lo que haremos es acceder a un objeto de la colección pero le damos el ID como parte del URL. Por ejemplo, hasta el momento hemos accedido a un URL como este:

http://localhost:8080/PersonaRESTWeb/resources/listaPersonas

... y nuestro reto ahora es obtener el objeto con ID=2 usando este URL

http://localhost:8080/PersonaRESTWeb/resources/listaPersonas/2/

Antes de continuar, recordemos en el artículo donde se habló cómo manejar un solo objeto en RESTful, que el recurso mismo es el que tiene un URL para devolver el objeto.Entonces, modificaremos el recurso PersonasResource (el que tiene el arreglo) para que devuelva el PersonaResource (el que tiene un solo objeto) y devuelva el objeto seleccionado. Entonces, debemos modificar este último recurso para que la variable Persona que tiene no sea static, pero que el valor de esa variable sea recibida por un método.


//...
 public class PersonaResource {
       private Persona persona;
   //...
       public void setPersona(Persona persona) {
             this.persona = persona;
       } 
}

Ahora sí, regresemos al recurso PersonasResource (el que tiene la colección de objetos) y agreguemos una referencia al recurso PersonaResource. Como es un EJB, entonces lo declaramos como tal:


//... 
@Stateless
@Path("/listaPersonas") 
public class PersonasResource {
    @EJB
    PersonaResource personaResource;
   //...

Luego, agregamos un método que recibirá como parámetro el ID del objeto a buscar, busca el ID en el arreglo, y si existe, le asignará al recurso personaResource y lo devolverá al cliente.


//...     
public PersonaResource getPersona(Integer id) {
           if (id == null) { //si no se pasó el ID...
                 return null; //... termina el método
           }
           Persona $temp = new Persona(); //creamos un temporal...
           $temp.setIdPersona(id); //.. que tendrá el ID...
           if (personas.contains($temp)) { // ... para buscarlo en la colección. Para eso sirve el método equals(). Si existe en la colección...
                 int idx = personas.indexOf($temp);  //... obtenemos su índice...
                 Persona actual = personas.get(idx); //... lo obtenemos de la colección...
                 personaResource.setPersona(actual); //.. y lo marcamos como "actual"...
                 return personaResource; //... para que lo devuelva al cliente.
           }
             return null; //.. si no lo encuentra, devuelve null
    } 
//...

Listo, y funciona... pero no tan rápido ¿Cómo sabemos que el ID será parte del URL?. Bien, agregaremos la anotación @Path("{idPersona}/") de la siguiente manera


//...
     @Path("{idPersona}/")
     public PersonaResource getPersona(Integer id) {
 //...

... y para asociar ese parámetro al parámetro del método, lo hacemos con la anotación @PathParam() de la siguiente manera:


//...
     @Path("{idPersona}/")
     public PersonaResource getPersona( @PathParam("idPersona") Integer id) {
 //...

Al final, el método completo es como sigue:


//...
     @Path("{idPersona}/")
     public PersonaResource getPersona(@PathParam("idPersona") Integer id) {
             if (id == null) { //si no se pasó el ID...
                     return null; //... termina el método
             }
             Persona $temp = new Persona(); //creamos un temporal...
             $temp.setIdPersona(id); //.. que tendrá el ID...
             if (personas.contains($temp)) { // ... para buscarlo en la colección. Para eso sirve el método equals(). Si existe en la colección...
                   int idx = personas.indexOf($temp);  //... obtenemos su índice...
                   Persona actual = personas.get(idx); //... lo obtenemos de la colección...
                   personaResource.setPersona(actual); //.. y lo marcamos como "actual"...
                   return personaResource; //... para que lo devuelva al cliente.
             }
             return null; //.. si no lo encuentra, devuelve null
     } //...

Listo, ahore probemos colocando unos valores como:

{"nombre_persona":"Albert"} {"nombre_persona":"Bernard"} {"nombre_persona":"Carl"}

... desde el Test de NetBeans.

Ahora, del árbol izquierdo, abramos el nodo "listaPersonas" y seleccionemos el nodo "{idPersona}"

Y en el campo "idPersona", escribiremos el ID de uno de los creados, por ejemplo "2", y hacemos clic en "Test"

También podemos probar desde el URL de la siguiente manera. Primero toda la lista.

http://localhost:8080/PersonaRESTWeb/resources/listaPersonas

Y luego, el del ID=2

http://localhost:8080/PersonaRESTWeb/resources/listaPersonas/2/

Reemplazar objeto y borrar objeto de la colección

El recurso PersonasResource es el que tiene la colección de objetos. Así que aquí le deberemos agregar los métodos que modifiquen y eliminen los objetos de la colección. Pero - OJO - estos no serán accedidos desde el URL. Solo fueron puestos aquí porque tiene la colección. Si se manejara una base de datos, se tendría otro EJB que maneje esos objetos. Bien, nuestro recurso tendrá los siguientes métodos:

//...     
public void borrarPersona(Persona p) {
           personas.remove(p); //... busca en la lista y borra el elemento
     }
     public void cambiarPersona(Persona actual, Persona p) {
           int idx = personas.indexOf(actual); //... obtiene la posición del actual
           if (idx >= 0) { //... si existe...
                 p.setIdPersona(actual.getIdPersona()); //... ponerle el ID en el nuevo objeto...
                 personas.set(idx, p); //..y reemplazar el objeto en la misma posición del anterior
           }
     }//...

Cada línea está comentada para que quede bien explicado.

Recordemos otra vez que nuestro recurso PersonaResource tendrá el objeto seleccionado por el ID. Y como el que tiene la colección de objetos es el recurso PersonasResource y es un EJB, entonces agregaremos la referencia de la siguiente manera:


//... 
public class PersonaResource {    
//el que tiene el objeto actual       
@EJB    PersonasResource personasResource;   
//el que tiene la colección de objetos
//...

Entonces los métodos @PUT y @DELETE será sobre el objeto seleccionado. Así que en este recurso agregaremos los siguientes métodos:


//...    
@DELETE
public void borrar() {          
 personasResource.borrarPersona(persona);  //porque tiene la colección de objetos
}    
@PUT    
@Consumes({"application/xml", "application/json"})    
public void actualizar(Persona p) {
 personasResource.cambiarPersona(persona,p); //porque tiene la colección de objetos
}
//...

Y listo. Probemos el test de NetBeans,´agregamos los mismo objetos, y probemos la actualización: Seleccionamos el idPersona:2 y le ponemos el nuevo objeto a reemplazar, utilizando el método "PUT"

Y cuando consultamos el ID=2, este será el nuevo objeto:

Y luego para el método "DELETE", y le indicamos el de ID=1

.. y luego obtenemos el listado de objetos.

Código fuente del proyecto

Como siempre, aquí publico el código fuente del proyecto utilizado en este artículo para que lo prueben y vean que no miento :)

http://kenai.com/projects/apuntes/downloads/download/CRUDPersonasRest%252FPersonaRESTWeb.tar.gz

Contraseñas encriptadas con Java

2011-06-04T17:27:00.000-05:00

¿Quién no ha querido encriptar texto o archivo? Hay diversas maneras para hacer eso, por ejemplo, utilizando un diccionario donde se reemplazara cada caracter por un código.. y para poder desencriptarlo se debería utilizar el mismo diccionario para revertir el proceso. Pero si el diccionario cae en manos de alguien que no queremos que lo sepa, entonces estamos en peligro.
Cuando yo programaba en pascal, mi encriptación favorita era invirtiendo los bits... pero cualquiera también puede invertir los bits y listo.
Pero ya gente experta logró algoritmos de encriptación populares. Los más conocidos: MD5 y SHA.
En este post hablaremos cómo encriptar texto, sobretodo las contraseñas, utilizando MD5 o SHA.

La historia de la criptografía es bastante larga e interesante, pero para nuestro día a día, solo necesitamos cómo utilizar las bibliotecas existentes en el mercado.
Hace un tiempo, hice un post de ello (MD5 en Java) que consistía en utilizar el mismo API de Java para generar MD5.Pero ahora mostraré una biblioteca muy útil proporcionada por la fundación ASF.

Commons Codec

Podemos descargar su biblioteca desde aquí http://commons.apache.org/codec/download_codec.cgi
Descomprimimos el archivo y tomamos el .jar llamado commons-codec-1.5.jar y lo agregamos al proyecto. En NetBeans solo le damos clic derecho en Libraries del Proyecto y seleccionamos el .jar.

La clase DigestUtils es nuestra clase principal para utilizar los diferentes algoritmos de encriptación.

MD5

        String texto="Saludos desde Apuntesdejava.com";
        String encriptMD5=DigestUtils.md5Hex(texto);
        System.out.println("md5:"+encriptMD5);

La salida resultante es:

md5:e5adf3f9fe476c7816eacd3873f5b51f

Para comprobarlo, yo utilizo la consola de MySQL

SHA-HEX

Similar al MD5, solo es otro método

        String texto="Saludos desde Apuntesdejava.com";
        String encript=DigestUtils.shaHex(texto);
        System.out.println("shaHex:"+encript);

La salida resultante es:

shaHex:2b05363b154309d7fc069cd922f316fa3f3ff866

Y en MySQL:

SHA-256 / 512

Para el SHA 256 se utiliza el método DigestUtils.sha256, y para 512, se utiliza DigestUtils.sha512. Los resultados son como siguen:

sha-256:9a4557a0f654365312b430b80f0da46be2c3a9db6a083f545145398fc66c92d8
sha-512:4c0a2187e03531011c7787752b66e8848a5f146e8aa08e5b5615030c5daa9cd756150e225943b5182de2434d925a4d6889b2d129ed87f23943bce9a8342b02bd

Como podemos ver.. a mayor bits, mayor confiabilidad.

Su contraparte, en MySQL, se utiliza la función sha2(). Ojo, esta función recién está disponible en la versión 5.5.5.

Upload en JSF 2.0

2011-03-08T18:26:00.000-05:00

Después de varias semanas desconectado por motivo de trabajo (parece que ahora sí trabajo más que antes) retomo (y espero que sea más seguido) los artículos de este blog que, según veo las estadísticas, a varios desarrolladores ayudan.
Y bueno, estuve haciendo una aplicación con JSF 2.0, y una de las característica que debería tener es que permita anexar archivos. Los Servlet 3.0 - que son parte de Java EE 6 - permiten cargar archivos de manera nativa. Lo que mostraré en este post es justamente cómo utilizar el Upload de Servlet 3.0 desde una aplicación web con JSF 2.0. No usaré extensiones de JSF como el ICEFaces o el MyFaces, porque quiero hacerlo de la manera más genérica posible, de tal manera que no afecte a la implementación de JSF que estén usando.

Supongamos que nuestra aplicación debe registrar una bitácora de trabajo, y en cada registro permita anexar archivos, para que después se pueda descargar.

Nuestra aplicación web...

... se llamará "BitacoraWeb"...

... y se ejecutará en GlassFish V3...

... con soporte para JSF 2.0

Y listo...

Comencemos ahora sí. (Para la siguiente haré un post bien explicado sobre cómo crear aplicaciones web en NetBeans para ahorrarme estos pasos)

Para registrar la bitácora necesitamos de una base de datos. Lo mostraré aquí con MySQL, pero - naturalmente - ustedes pueden utilizar la que más se acomode.

Asumiré - para este post - que existe la base de datos "bitacora" asignado al usuario "bitacora" con contraseña "bitacora"

Ahora, necesitamos una entidad llamada "Entrada" que tendrá las siguientes propiedades:

@Entity
public class Entrada implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @Column
    private String descripcion;
    @ElementCollection
    private List<Adjunto> adjuntos;

    public void addAdjunto(Adjunto adjunto) {
        getAdjuntos().add(adjunto);
    }

    public List<Adjunto> getAdjuntos() {
        if (adjuntos == null) {
            adjuntos = new ArrayList<Adjunto>();
        }
        return adjuntos;
    }
//... métodos get y set por cada propiedad

Y la Clase Adjunto tendrá la siguiente estructura:


@Embeddable
public class Adjunto implements Serializable {

    @Lob
    private byte[] contenido;
    @Column
    private String tipoContenido;
    @Column
    private String nombreArchivo;

    public Adjunto() {
    }

    public Adjunto(byte[] contenido, String tipoContenido, String nombreArchivo) {
        this.contenido = contenido;
        this.tipoContenido = tipoContenido;
        this.nombreArchivo = nombreArchivo;
    }
//.. métodos set y get de las propiedades.

Ahora, necesitamos el manejador de la entidad Entrada. Con el NetBeans, esto se nos será muy fácil: basta con seleccionar desde la opción "File > New" la opción "Persistence > Session Beans For Entity Classes"

Seleccionamos las Entidades que queremos administrar...

... seleccionamos donde queremos que se creen...

... y listo.

Ahora, crearemos un ManagedBean de alcance "Session" llamado BitacoraBean. Este es el que mostrará los datos en el formulario.

No voy a detallar cada parte del código, porque es algo complejo. Además, el código colgado ya tiene sus propios comentarios. Pero sí voy a explicar partes principales de las clases principales.

En la parte inferior del JSF hay un formulario que es donde se registrará la bitácora. Pero también hay una parte para agregar los archivos. Para esto utilicé otra página para cargar los adjuntos.

//...
        <h:form id="form">
            <h:panelGrid columns="2">
                <h:outputLabel value="Descripción" for="descripcion" />
                <h:inputTextarea id="descripcion" value="#{bitacoraBean.entradaActual.descripcion}" />

                <h:outputText value="Adjuntos"/>

                <h:panelGroup>
                    <h:commandButton value="Recargar..." id="recargar">
                        <f:ajax render="adjuntos" />
                    </h:commandButton>
                    <h:button value="Agregar" onclick="return abrirAdjuntos()"/>

<!-- aqui va el codigo donde se muestra los adjuntos -->
                </h:panelGroup>
            </h:panelGrid>
            <h:commandButton action="#{bitacoraBean.guardarEntrada}" value="Guardar"/>
        </h:form>
//...

Por ello existe el botón "Cargar archivo". Lo que hace este botón es abrir un JSP que tiene un formulario para cargar cualquier archivo.

El boton "recargar" no hace nada. Solo que cuando se llama, se recarga la página, y por tanto, muestra los contenidos de la tabla de adjuntos. (Por ahora lo oculté, porque sino se confundiría con lo que quiero explicar)

El formulario de carga es bastante simple: (archivo form.jsp)

//...
        <h1>Cargar archivo</h1>
        <form action="<c:url value='/servlet/upload'  />" method="POST" enctype="multipart/form-data">
            Archivo:
            <input type="file" name="archivo" value="" />
            <button type="submit">Cargar</button>
        </form>
//...

El servlet que es apuntado por este formulario es lo principal. Veamos por qué:


@WebServlet(name = "UploadServlet", urlPatterns = {"/servlet/upload"})
public class UploadServlet extends HttpServlet {

    /** 
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        Part filePart = request.getPart("archivo"); //obtengo el archivo adjunto
        String nombreArchivo = extraerNombre(filePart.getHeader("content-disposition")); //extraigo el nombre

        InputStream is = filePart.getInputStream(); //obtengo el Stream
        long size = filePart.getSize(); //... el tamaño
        byte[] buffer = new byte[(int) size]; //.. creo el buffer
        is.read(buffer); //.. leo el buffer en un solo bloque
        is.close(); //... cierro el buffer
        String mimeType = filePart.getContentType(); //... obtengo el tipo de archivo
        Adjunto adjunto = new Adjunto(buffer, mimeType, nombreArchivo); //... creo el objeto ajdjunto
        BitacoraBean bitacoraBean = (BitacoraBean) request.getSession().getAttribute("bitacoraBean"); //obtengo el bean
        Entrada entradaActual = bitacoraBean.getEntradaActual(); //.. obtengo la entrada actual que está con el formulario
        entradaActual.addAdjunto(adjunto); //... adjunto el objeto del archivo
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            out.println("<html><head>"); //imprimo en el HTML para ejecutar un javascript
            out.println("<script type=\"text/javascript\">");
            out.println("window.opener.document.getElementById(\"form:recargar\").click()"); //busco el boton para recargar
            out.println("window.close()"); //cierro ventana
            out.println("</script>");
            out.println("</head></html>");
        } finally {
            out.close();
        }
    }

    /**
     * Método para extrar el nombre físico del archivo
     * @param header Parametro del nombre, con toda la ruta completa en el cliente
     * @return Devuelve solo el nombre del archivo
     */
    static private String extraerNombre(String header) {
        String[] parts = header.split(";");
        for (String part : parts) {
            if (part.trim().startsWith("filename=")) { //busco todos los que comienzan con filename
                String[] $parts = part.split("="); //separo el nombre
                StringBuilder $sb = new StringBuilder($parts[1]);
                String fn = $sb.substring(1, $sb.length() - 1); //el segundo es el nombre
                File f = new File(fn); //creo una entrada de archivo
                return f.getName(); //devuelvo el nombre del archivo
            }
        }
        return "";
    }

Ahora bien, el boton "Recargar" es utilizado justo por el JavaScript que devuelve el Servlet. La parte que contiene para mostrar los adjuntos (o sea, lo que oculté hace un rato) es como sigue:


 <h:dataTable id="adjuntos" value="#{bitacoraBean.entradaActual.adjuntos}"  var="adjunto" binding="#{bitacoraBean.adjuntosDataTable}">
   <h:column>
     <h:outputText value="#{adjunto.nombreArchivo}" />
   </h:column>
   <h:column>
     <h:commandButton value="X" action="#{bitacoraBean.quitarAdjunto}" />
   </h:column>
 </h:dataTable>

Como se ve, aquí se muestra los adjuntos tienen tener un botón (con una "X") para quitarlo de la bitácora que se va a registrar. Este botón llama al método quitarAdjunto. Pero para que funcione, se ha creado un binding llamado adjuntosDataTable. El método de quitarAdjunto es como sigue:


//...
    public HtmlDataTable getAdjuntosDataTable() {
        return adjuntosDataTable;
    }

    public void setAdjuntosDataTable(HtmlDataTable adjuntosDataTable) {
        this.adjuntosDataTable = adjuntosDataTable;
    }

    public String quitarAdjunto(){
        Adjunto adjunto = (Adjunto) adjuntosDataTable.getRowData();
        entradaActual.quitarAdjunto(adjunto);
        return null;
    }

//...

Por ello, cuando se hace clic en el botón "X", busca el objeto asociado (getRowData()), lo quita de los adjuntos de la entrada, y devuelve null para que recargue la página.

Listo....!!

Ah, falta mostrar los registros de la bitácora, y que muestre los archivos. Aquí el código:


        <h2>Entradas de Bitácora</h2>
        <h:dataTable border="1" value="#{bitacoraBean.entradas}" var="entrada">
            <h:column>
                <f:facet name="header">ID</f:facet>
                #{entrada.id}
            </h:column>
            <h:column>
                <f:facet name="header">Descripción</f:facet>
                #{entrada.descripcion}
            </h:column>
            <h:column>
                <f:facet name="header">Adjuntos</f:facet>
                <h:dataTable value="#{entrada.adjuntos}" var="adjunto">
                    <h:column>
                        <h:outputLink value="#{facesContext.externalContext.requestContextPath}/servlet/upload/abrir"  >
                            <h:outputText value="#{adjunto.nombreArchivo}" />
                            <f:param name="id" value="#{entrada.id}" />
                            <f:param name="archivo" value="#{adjunto.nombreArchivo}" />
                        </h:outputLink>
                    </h:column>
                </h:dataTable>

            </h:column>
        </h:dataTable>

Cada archivo adjunto que se está mostrando está apuntado por un enlace, que es un servlet. Y este servlet es el siguiente:


//...
@WebServlet(name = "MostrarArchivoServlet", urlPatterns = {"/servlet/upload/abrir"})
public class MostrarArchivoServlet extends HttpServlet {

    @EJB
    private EntradaFacade entradaFacade;

    /**
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        String $idEntrada = request.getParameter("id"); //obtengo el ID del parametro
        String archivo = request.getParameter("archivo"); //obtengo el nombre del archivo del parametro
        Long idEntrada = Long.parseLong($idEntrada); //convierto el ID a Long...
        Entrada entrada = entradaFacade.find(idEntrada);//.. para buscarlo en la base de datos 
        if (entrada == null) { //si no existe...
            response.setStatus(HttpServletResponse.SC_NOT_FOUND); //... devuelvo un mensaje de q no existe
            return; //... y termina
        }
        List<Adjunto> adjuntos = entrada.getAdjuntos(); //ahora, obtenemos todos los adjuntos de la entrada
        Adjunto adjuntoMostrar = null; //el adjunto actual
        for (Adjunto $adjunto : adjuntos) { //recorro todos los adjuntos
            if ($adjunto.getNombreArchivo().equals(archivo)); //comparamos el nombre, y si existe...
               adjuntoMostrar = $adjunto; //.. lo capturamos
        }
        if (adjuntoMostrar == null) { //si recorrio toda la lista y no encontro nada...
            response.setStatus(HttpServletResponse.SC_NOT_FOUND); //... devolvemos un mensaje que q no existe
            return; //.. y termina
        }

        OutputStream out = response.getOutputStream();
        try {
            response.setContentType("application/octet-stream"); //...preparamos el tipo para q se descargue la adjunto
            response.setHeader("Content-Disposition", "attachment;filename=" + adjuntoMostrar.getNombreArchivo().replaceAll(" ", "_")); //preparando el 'download' al navegador

            response.setContentLength(adjuntoMostrar.getContenido().length); //ponemos el tamaño...
            out.write(adjuntoMostrar.getContenido()); //... y vaciamos el contenido

        } finally {
            out.close(); //y cerramos el flujo
        }
    }

//...

Código fuente

El código fuente de proyecto se puede descargar desde aquí:

http://java.net/projects/apuntes/downloads/download/web/BitacoraWeb.tar.gz

Enmulando EJB en Web usando Spring

2010-09-14T10:33:00.003-05:00

Cuando salió el EJB 3.1 con la capacidad de poderse ejecutar en un módulo web, comencé a usarlo sin parar. Con los EJB me hace más fácil conectarme a la base de datosusando JPA porque simplemente debería usar @PersistenceContext respectivamente.

Pero no todos los servidores donde uno va a desplegar aplicaciones son Java EE6, así que las facilidades del EJB 3.1 serían truncadas.

Afortunadamente existe Spring para ayudarnos a instanciar clases como si fueran EJB, y más aún, nos permite usar JPA y mantener las notaciones @PersistenceContext.

Veamos cómo se hace esto.

Para comenzar, debemos considerar que existe nuestro archivo persistence.xml con la conexión a la base de datos. Para este ejemplo estoy usan la base de datos sample que viene en el JavaDB.


<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" 
   xmlns="http://java.sun.com/xml/ns/persistence" 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
                       http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="EjbSpringWebPU" transaction-type="JTA">
    <jta-data-source>jdbc/sample</jta-data-source>
    <exclude-unlisted-classes>false</exclude-unlisted-classes>
    <properties/>
  </persistence-unit>
</persistence>

Nuestros "Facade" que funcionarán como los EJB, será casi como un EJB, con todo la notación de persistencia:


public class DiscountCodeFacade {

    @PersistenceContext(unitName = "EjbSpringWebPU")
    private EntityManager em;

    public List<DiscountCode> getDiscountCodes() {
        Query query = em.createQuery("select o from DiscountCode o");
        return query.getResultList();
    }
}

Hasta aquí, todo normal. Ahora, necesitamos instanciar este facade y que ya tenga la conexión a la persistencia. Bueno, en Spring se tiene que hacer esto:

Instanciar la persistencia:


    <bean id="EjbSpringWebPU" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="EjbSpringWebPU"/>
    </bean>

Luego, decirle que ejecute todas las notaciones que se solicitarán en las siguientes clases:


    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>

Para terminar, instanciar el Facade:


    <bean id="DiscountCodeFacade" class="service.DiscountCodeFacade" />

Y listo, ya se puede utilizar casi como un EJB:


DiscountCodeFacade facade=ServiceFactory.getInstance().getDiscountCodeFacade();
List<DiscountCode> discountCodes = facade.getDiscountCodes();

El proyecto utilizado para este post se encuentra aquí:

https://java.net/downloads/apuntes/samples/web/EjbSpringWeb.tar.gz

Empaquetar una aplicación para distribuir, desde NetBeans

2010-06-08T00:00:00.001-05:00

Uno de los tantos motivos por lo que utilizo NetBeans en lugar de otro IDE, es que utiliza la Apache Ant para compilar, crear .jar .war .ear, javadoc, etc.. prácticamente para todo, y solo usando un archivo .xml. Y lo mejor es que se puede personalizar el .xml a nuestro antojo.

En este post se va a explicar cómo empaquetar una aplicación Swing en un archivo .zip para ser distribuido a los usuarios finales.

¿Qué hace NetBeans?

Si al hacer una aplicación Swing con NetBeans utilizamos diversas bibliotecas adicionales, el IDE nos puede crear una carpeta lista para distribuir a los usuarios incluyendo todas los .jars necesarios. Para ello hacemos clic derecho sobre el ícono del proyecto y seleccionamos "Build" (o Clean and Build)

Al hacer esto, el NetBeans compila, y construye la carpeta "dist" para distribuir. Esta carpeta se encuentra en la misma carpeta del proyecto. Podemos verla en el panel "Files" del NetBeans (Teclas Ctrl+2)

Ahora bien ¿qué hacemos con ese .jar? En el README.TXT lo explica. Pero NetBeans también lo dice en el panel "Output" (Ctrl+4) después de construir la aplicación.

"Para ejecutar esta aplicación desde la línea de comandos sin usar Ant, intente:..." y luego dice cuál es el comando que se tiene que hacer.

Si copiamos esa línea, abrimos la ventana del Símbolo del Sistema, y pegamos esa instrucción para ejecutarlo, pues nos ejecutará la aplicación sin problemas. Es más, se podría copiar a los usuarios finales este directorio "dist" y decirles que si quieren ejecutarlo hagan esto: abrir una ventana del Símbolo del Sistema, escribir esa instrucción y listo.........creo que al usuario no le va a gustar hacer esto ¿Por qué no mejor hacer un programa que al hacer doble clic ya se ejecuté? Buena idea.

Creando un .bat

De por sí, se puede hacer doble clic al archivo .jar para ejecutar la aplicación, pero funciona si es que en el computador del usuario no tiene algún descompresor de archivos asociado a los archivos .jar. Por ejemplo, si se tiene instalado el WinRAR, al hacer doble clic sobre el archivo .jar, en lugar de que se ejecute, se abrirá el WinRAR y mostrará el contenido del .jar... esto no es lo que queremos. La mejor manera es crear un archivo .bat que haga la llamada al comando java -jar bla bla

Esto le podemos decir al NetBeans que lo haga. Para ello, entramos al panel "Files" (Ctrl+2) y buscamos el archivo build.xml. Este es una extensión al .xml que utiliza el NetBeans para construir la aplicación.

Abrimos este archivo, lo revisamos un poco (todo está comentado y hay algunas instrucciones) y pondremos el tag <target name='-post-jar'/> que nos permitirá realizar una tarea después de que el NetBeans haya creado el .jar

    <target name="-post-jar">        <echo file="${dist.dir}/run.bat">java -jar ${application.title}.jar</echo>    </target>

El tag de la tarea <echo /> crea una salida a la consola, pero con el atributo file le estamos diciendo que la salida lo haga a un archivo. Para saber cuáles son los valores de las variables utilizadas en la construcción del proyecto, podemos revisar el archivo nbproject/project.properties.

Por ello utilicé las variables dist.dir, application.title.

Ahora bien, hagamos un "Build" al proyecto y veamos lo que hizo en la carpeta dist.

Y si vemos el contenido será justamente lo que hemos pensado. Abrimos una ventana del explorador de windows, y le damos doble clic al .bat. Listo, usuario satisfecho.

Pero.. sale una ventana negra fea con el comando de ejecución de la aplicación. Bueno, esto se puede solucionar. Podemos reemplazar la instrucción

<echo file="${dist.dir}/run.bat">java -jar ${application.title}.jar</echo>

Por

<echo file="${dist.dir}/run.bat">start javaw -jar ${application.title}.jar</echo>

El comando de Windows start permite ejecutar una aplicación y "soltarlo" para que se ejecute como un proceso más del Sistema Operativo. Y el comando javaw es un comando adicional al JRE que permite ejecutar una aplicación java sin mostrar una ventana del Símbolo del Sistema.

Bien, ahora solo nos bastaría con copiar a los usuarios finales el .bat, el .jar y las bibliotecas adicionales so hubiera. Lo empaquetamos y se lo enviamos.

¿Hay un poco de flojera para comprimir los archivos? ¿y si me falta uno?

Creando un .zip

El Ant también permite comprimir archivos usando la tarea <zip />. Es realmente fácil.

Creamos el siguiente tag después del <echo />.

        <zip destfile="${dist.dir}/${application.title}.zip" basedir="${dist.dir}" />

Hagamos "Clean and Build" al proyecto, y listo, ya tenemos nuestro archivo .zip para enviar a los usuarios finales.

Y les decimos "Estimados bla bla bla, descompriman el achivo .zip para ejecutar la aplicación".
¿También tenemos flojera de enviar el mail a los usuarios? :)

Documentación

Si deseas conocer más tareas que vienen incluidas en el ANT, revisa la siguiente página.

Apache Ant User Manual: http://ant.apache.org/manual/index.html

Ahí está la tarea mail

Proyecto

Y como de costumbre, aquí está el proyecto utilizado en este ejemplo:

http://java.net/downloads/apuntes/samples/netbeans/DemoSwingAntCustomized.tar.gz

Instalación de Liferay en un servidor GlassFish v3 para producción

2010-07-06T00:00:00.231-05:00

En un anterior post mencioné los Portales en Java, y la facilidad que nos da el utilizar una plataforma con muchas funcionalidades, y nosotros simplemente deberíamos hacer los componentes que faltan. Estos componentes se llaman Portlets.

Ahora mencionaré uno de los gestores de Portlets en Java que, según mi opinión, es bastante útil. Su nombre LIFERAY. Pero no hablaré de sus cualidades, ni todo lo que puede hacer.. eso ya lo hizo Pedro Edison en su blog :), y como no hay que amontonar la red con lo mismo, esta vez mostraré cómo instalar el LIFERAY desde cero. No desde la instalación de un .exe, sino desde un archivo .war y sobre GlassFish v3 usando MySQL como gestor de base de datos.

Esto no lo he inventado, sino lo tomé del tutorial mismo de Liferay... pero como está en inglés, y el lector promedio de este blog busca más información en castellano, quiero hacer un aporte a la comunidad con este post.

Recursos

Para esta tarea necesitamos lo siguiente:

Sistema operativo, cualquiera compatible con Java. Aunque estos pasos funcionan en todos los sistemas operativos con Java SE 6, en este post lo orientaré más a Windows... porque el lector promedio de este blog busca más información en Windows... etc etc etc.
JDK 6. El cual lo puedes descargar desde aquí: http://java.sun.com/javase/downloads/widget/jdk6.jsp
GlassFish v3. Si no lo has instalado, aquí lo mostraremos de la manera más fácil. Puedes descargar la versión .zip desde aquí: http://download.java.net/glassfish/3.0.1/release/glassfish-3.0.1-ml.zip. Esta es la versión multilingual, es decir, nos aparecerá en castellano los textos para entendernos mejor.
El .war de Liferay: http://downloads.sourceforge.net/lportal/liferay-portal-5.2.3.war
Archivos adicionales para preconfigurar el Contenedor Web: http://downloads.sourceforge.net/lportal/liferay-portal-dependencies-5.2.3.zip
MySQL instalado ya sea localmente o en otro host, pero que tengamos acceso a ese computador. Pude haber hecho con PostgreSQL, pero tengo un par de inconvenientes: me han bloqueado todo tipo de instalación en el computador de donde trabajo, y... conozco casi nada sobre PostgreSQL.. así que mis disculpas a los amigos del elefantito. Pero si sois curiosos, sabréis como acomodar esto.
OJO: que sea el MySQL puro, no uno de esos que vienen enlatados con Apache + PHP + PHPMyAdmin. Ya hablaré de este paquetito *AMP en otro post, que para unos es un alivio, pero puede ser un dolor de cabeza si no se usa con prudencia. El MySQL se puede descargar desde aquí: http://dev.mysql.com/downloads/mysql/
El JDBC de la base de datos que vamos a utilizar. Cómo estamos en MySQL, este se puede descargar desde aquí: http://dev.mysql.com/downloads/connector/j/ Si decides usar otro motor de base de datos, pues no te olvides de conseguir el JDBC correspondiente.

Hasta aquí es lo necesario para una instalación básica. Pero quiero compartir mi experiencia de esta instalación:

Usar el JDK de Sun. Toda esta instalación funciona bien con OpenJDK sobre un Ubuntu, CentOS, etc... pero el Captcha para autenticación no funciona correctamente sobre OpenJDK, por tanto usar el JDK de Sun.
Descargar el Xerces-J. La instalación descrita aquí funciona correctamente, pero cuando se agregan nuevos portlets, el Contenedor Web no es capaz de interpretar los archivos de despliegue de ellos. Para este ejemplo usaremos la versión 2.9.0: http://archive.apache.org/dist/xml/xerces-j/Xerces-J-bin.2.9.0.zip

Instalación y preconfiguración de GlassFish v3

La instalación de GlassFish v3 es bastante simple, más aún si es un .zip como el que sugerí para descargar: Solo hay que descomprimirlo. Por ejemplo, lo descomprimiremos en la raíz de C: Y tendrá una estructura como esta.

A partir de este momento, cada vez que mencione %GLASSFISH_HOME% se entenderá al directorio del GlassFish que se descomprimió. Es decir c:\glassfishv3

Importante: Mucho se acostumbra crear una carpeta con el mismo nombre del archivo comprimido, lo cual es una práctica no recomendada aquí, ya que el comprimido ya tiene una carpeta. Si se hace eso, se tendría una carpeta llamada glassfishv3, y dentro otra vez glassfishv3, y ocasionará confusión. Por tanto, no usar la opción "crear una carpeta con el nombre del archivo .zip". Simplemente descomprimirlo directamente a la raíz de "C:". Ojo que ya lo advertí :P.

Ahora, extraemos el contenido del archivo liferay-portal-dependencies-5.2.3.zip en cualquier carpeta, luego tomamos los archivos .jar que se obtuvieron y los pondremos dentro de %GLASSFISH%\glassfish\domains\domain1\lib. En esta misma carpeta ponemos el .jar del JDBC de MySQL, y los archivos xercesImpl.jar y xml-apis.jar de Xerces

Después de esto, iniciamos el GlassFish v3...

%GLASSFISH_HOME%\bin\asadmin start-domain

... para continuar con el siguiente paso.

Debemos modificar las propiedades de la máquina virtual donde se ejecutará el Liferay. Para ello seleccionamos del menú de la izquierda: Configuration > JVM Settings.

Y cambiamos los valores de MaxPermSize y Xmx a los siguientes:

-XX:MaxPermSize=256m
-Xmx1024m

Clic en "Save". Detenemos el GlassFish, y lo volvemos a iniciar.

%GLASSFISH_HOME%\bin\asadmin stop-domain%GLASSFISH_HOME%\bin\asadmin start-domain

Preparación de la base de datos

El Liferay utiliza una base de datos por omisión llamada HSQLDB, pero podemos configurarlo para que funcione con cualquier otra base de datos. En este caso veremos con MySQL. En sí, se necesita crear una base de datos en MySQL, configurar un Pool de Conexiones, y ajustar un poco el .war para que utilice este Pool.

Sugerencia: Antes de hacer esto, recomiendo siempre crear un usuario que acceda a esta base de datos, y no usar el root para tal fin. ¿Cómo crear ese usuario?.
Desde una ventana del símbolo del sistema, ejecutar

mysql -u root -p

Con esto se ejecutará el cliente de MySQL con el usuario root y pedirá la contraseña. Bueno, le ponemos y nos mostrará el prompt mysql>.

Escribimos lo siguiente para crear la base de datos lportal:

create database lportal;

y luego escribimos lo siguiente para el usuario lportal que accederá a esa base de datos:

grant all on lportal.* to lportal@localhost identified by "lportal";

Más sobre los permisos en MySQL, aquí: http://dev.mysql.com/doc/refman/5.1/en/grant.html

Ahora sí, seguimos...

Configuración del pool de conexiones en GFv3 para Liferay

Entramos a la consola web de GFv3 (http://localhost:4848) y seleccionamos del árbol de la izquierda Resources > JDBC > Connections Pool

Hacemos clic en el botón "New..." para crear una nuevo Pool de Conexiones. Escribimos:

Name: LiferayPool
Resource Type: javax.sql.ConnectionPoolDataSource
Database vendor: MySQL

Clic en Next.
Ahora, se mostrarán todas las propiedades de la conexión a la base de datos. Activamos el primer check llamado Ping: Enabled. Esto nos permitirá verificar si la conexión fue correcta después de crear el pool de conexiones. Luego buscamos las siguientes propiedades, y ponemos los valores que se muestran a continuación:

URL:jdbc:mysql://localhost/lportal
User: lportal
Password: lportal
UseUnicode: true
CharacterEncoding:UTF-8
EmulateLocators: true

Hacemos clic en el botón "Save", y si todo está correcto, se creará sin problema.

Con esto solo hemos creado un Pool de Conexión, ahora necesitamos registrarlo en el JNDI del Servidor. Para ello, seleccionamos la opción Resources > JDBC > JDBC Resources

Hacemos clic en "New..." y escribimos los siguientes valores en los campos:
JNDI Name: jdbc/LiferayPool
Pool Name: LiferayPool

¡¡El nombre del recurso es importante!! Debe estar en mayúsculas y minúsculas.

Clic en OK y listo. Seguimos con el siguiente paso.

Despliegue del .war

Como comenté hace un momento, el .war de liferay está preparado para funcionar con una base de datos incrustada llamada HSQLDB. Lo que necesitamos es que se conecte a nuestro MySQL. Por algo hemos preparado el Pool de conexiones. Así que necesitamos editar un archivo llamado portal-ext.properties, adjuntarle el atributo:

jdbc.default.jndi.name=jdbc/LiferayPool

... y luego ponerlo dentro del .war (en el directorio WEB-INF/classes dentro del .war) antes de desplegarlo.

Notar que el nombre del JNDI (jdbc/LiferayPool) debe ser exacto cómo se configuró en GlassFish en el paso anterior.

Si te es complicado crear el archivo, aquí puedes descargarlo: http://java.net/downloads/apuntes/resources/liferay/portal-ext.properties

Y si te es complicado poner el .properties dentro del .war, aquí ya tengo un .war preparado (que es el que uso en las instalaciones de Liferay)
http://java.net/downloads/apuntes/resources/liferay/liferay-portal-5.2.3.war

Ahora sí, tomar mucho cuidado con lo siguiente que se va a explicar respecto al despliegue del .war

En la consola del GlassFish, ir a la opción "Applications" del menú izquierdo, y hacemos clic en el botón "Deploy...". En la opción "Location", seleccionamos el archivo .war que de liferay. Al hacer esto, se mostrarán más opciones que corresponden a la configuración del despliegue del .war.

En la casilla llamada "Context Root:" aparecerá el nombre del archivo .war. Borrar este nombre y poner el signo "/".

Ahora, clic en "OK".

Esto tomará un tiempo procesar. Aún cuando ya se haya mostrado el mensaje en GlassFish que fue desplegado correctamente, no necesariamente habrá terminado, porque estará configurando archivos, bibliotecas, creando las tablas de la base de datos, preparando otros recurso, etc etc etc. Así que en esta parte tener paciencia. Se puede revisar el log para ver en qué está. %GLASSFISH_HOME%\glassfish\domains\domain1\logs\server.log.

La Ruta del contexto (Context Root) es importante porque la aplicación se mostrará en la raiz del host, y varios componentes de la aplicación se ubicarán en la misma ubicación, como "/c" y "/widgets".

Ejecutando el Liferay

Después del despliegue, ya podemos verlo en funcionamiento abriendo la siguiente dirección: http://localhost:8080 Sin ruta de contexto, ya que (como acabo de mencionar) está en la raíz del host.

El usuario creado por omisión para administrar este Portal es test@liferay.com y su contraseña es test.

Conclusión

Y esto sería todo para tener en producción un Contenedor de Portlets sobre GlassFish v3. De por sí el GFv3 es pesado para manejar en desarrollo, más aún si se utiliza con Liferay, así que hay que considerarlo si se utiliza en un computador de desarrollo con pocos recursos (entiéndase, no usar Pentium D.. sino algo muy superior, ni menos con 2GB de RAM).

En un siguiente Post veremos (ahora sí) cómo configurar NetBeans 6.9 con un servidor liferay y haremos nuestro primer portlet.

Hasta el siguiente post!

Nuestro primer Portlet en Liferay

2010-07-20T00:00:00.002-05:00

Hasta el momento hemos visto cómo configurar Liferay sobre un Servidor Glassfish v3 para producción. Esto nos permite tener un Portal en blanco listo para que nosotros le configuremos todo. Es decir, el Liferay que viene preconfigurado con el GF, Tomcat o Jetty que está disponible en la página de descarga de liferay.com, tiene contenido preparado, textos de ejemplo, temas, aplicaciones completas, etc. Además que viene configurado con HSQLDB. Si al preconfigurado le cambiamos el acceso a la base de datos para que utilice el MySQL o cualquiera, en ese momento todo el contenido del Portal estará en blanco.

Recomiendo la versión preconfigurada de liferay para conocer un poco cómo funciona, y además, para usarlo como caja de arena para probar nuestros portlets.

En este post veremos cómo hacer un Portlet para Liferay usando NetBeans 6.x

Quizás te preguntarás por qué quiero usar más GlassFish que Tomcat, así sea para una aplicación web simple. No tengo nada en contra de Tomcat, fue mi primer contenedor Servlet/JSP que utilicé (exactamente la versión 3). Es rápido y simple de usar. Pero para mi me es un problema cuando quiero gestionar con base de datos. Tomcat maneja su Pool de conexiones de manera eficiente, pero configurarlo no es muy agradable que digamos (editar un archivo .xml que es parte del .war no creo que sea muy portable si quiero pasar de desarrollo a producción sin editar nada) Mientras que en GlassFish la configuración del DataSource se hace desde la misma consola del servidor.
Bueno, esto fue un offtopic del post, explicando porqué uso más GlassFish que Tomcat.

Comencemos con la preparación de nuestro NetBeans para desarrollar un portlet:

Configurando NetBeans con un Servidor Liferay+Glassfish v3

Previamente ya debe estar instalado los plugins del PortalPack, que lo vimos en un post anterior.

Abrimos nuestro NetBeans y vayamos al panel de Prestaciones (Services) con Ctrl+5. Abrimos el nodo "Servidores" y hacemos clic derecho sobre ese nodo, seleccionando la opción "Agregar Servidor".
Seleccionamos de la lista "Liferay Portal Server 5.1.x/5.2.x" y hacemos clic en Siguiente.
Seleccionamos el tipo de Servidor a GlassFish, y el GlassFish Home a "C:\glassfishv3\glassfish".
Clic en "Siguiente". Dejamos los valores por omisión, y clic en "Terminar"

Ejecutando Liferay desde NetBeans

Bien, ahora que ya tenemos nuestro NetBeans configurado con Liferay, será bueno primero iniciar el Liferay para ver sobre donde vamos a trabajar. Para ello, hacemos clic derecho sobre el ícono del Liferay que hemos acabado de agregar al NetBeans, y seleccionamos "Start".

... y ~~si tienes un computador tan lento como el que tengo en la oficina, en unas horas~~ en unos momentos, se mostrará el Liferay en el navegador.

Nuestro primer portlet básico

Un portlet es en realidad una aplicación web que se distribuye en .war y que tiene archivos .xml de despliegue adicionales. Como aplicación web, también cuenta con su ruta de contexto (context-path), sus configuraciones del web.xml y demás. Ahora con la versión JavaEE6, también puede contener EJB 3.1, ya que - como acabo de decir - es una aplicación web. Solo que esta aplicación web no se desplegará desde la consola del contenedor web, sino desde el mismo contenedor de portlets, en este caso, desde liferay.

Creando un proyecto web

Así que comencemos creando una aplicación web desde Archivo > Nuevo proyecto > Java Web > Web Application.
Clic en Siguiente. Luego indicamos el nombre del proyecto y su ubicación. Le ponemos que se llamará SimplePortlet, y tomar la ubicación predeterminada.
Clic en Siguiente. Seleccionamos el servidor donde se desplegará. En este caso seleccionamos el que acabamos de agregar al IDE hace un momento. Notar que cuenta la versión del Java EE y la ruta de contexto.
Clic en Siguiente. Cuando nos pida los "Frameworks" a utilizar, activamos el que dice "Portlet Support". Y más abajo dice "Create Portlet". Lo dejamos desactivado para crearlo posteriormente.
Clic en Terminar.

Vemos que es un proyecto web mas archivos .xml adicionales....

Insisto diciendo que es un proyecto web, para que no sea chocante tratar de pensar que es otro tipo de proyecto y no se hagan preguntas como:

¿Puedo ponerle mis imágenes? ¿Dónde?
¿Puedo usar .css?
¿Puedo poner .js?
¿Dónde pongo las clases?
etc... etc.. etc

Este proyecto podrá tener más de un portlet. Así que comenzaremos a crear el primero.

Creado un portlet

Advertencia: Al momento de hacer este post, encontré problemas para desplegar un portlet desde NetBeans + PortalPack al Liferay/GFv3. Esto es porque el PortalPack considera que el Servidor a utilizar es Liferay/GFv2 o Tomcat. Utiliza el JSR88 para desplegarlo sobre GFv2, y este JSR88 ya no está disponible para GFv3. En resumen. Si utilizas el Liferay+GFv2, el despliegue será inmediato. Pero para este post haremos la manera no cómoda pero que funciona: desplegar el Portlet desde la Consola de Liferay.

Hagamos clic en Nuevo > Archivo nuevo (Ctrl+N) y seleccionamos Portlets > Portlet
Clic en Siguiente. Luego escogemos como nombre de la clase Portlet FactorialPorlet del paquete portlets. Eso es solo la característica de la clase. Pero esta clase debe tener características como Porlet, por ejemplo el nombre, descripción, etc. Así que pongamos los siguientes valores:
- PortletName: FactorialPortlet
- Portlet Display Name: Factorial Portlet
- Porlet Description: Portlet que calcula el factorial
- Portlet title: Factorial en Portlet
- Portlet Short Title: Factorial
- Activar los checks "Edit" y "Help". Estas serán páginas adicionales que interactuará con el usuario.
Clic en Siguiente. Activamos el check para que nos cree los .jsp correspondientes.
Clic en Terminar.

Con esto nos habrá creado una clase FactorialPortlet, y dentro de WEB-INF/jsp estarán los archivos .jsp que serán utilizados para el interfaz de usuario.

Vemos que hay dos métodos que nos llaman la atención (que nos recuerdan al doGet y doPost de los Servlets) processAction(), doView, doEdit y doHelp. Estos métodos son invocados por el Portal para mostrar una página dependiendo de la petición que haya hecho el usuario. Si solo quiere ver, se ejecutará el doView, si va a editar las preferencias del portlet, ejecutará doEdit, y si quiere ver la ayuda del portlet, se ejecutará doHelp. Pero cuando se quiere atender una petición, se ejecutará el método processAction(). Notemos que dentro está la clase PortletRequestDispatcher que no es más que una especialización de la clase RequestDispatcher utilizada en los servlet bajo el modelo MVC. Así que, aquí no hay modo de fallar :).

Ahora, editemos el archivo FactorialPortlet.java para que calcule el Factorial. Primero, el método que hace el cálculo.

    static long factorial(long base) {        if (base < 2) {            return 1;        }        return base + factorial(base - 1);    }

Y, editemos el método processAction() para leer un parámetro de la web, lo calculamos, y lo mostramos al usuario.

    public void processAction(ActionRequest request, ActionResponse response) throws PortletException, IOException {        String numero = request.getParameter("numero");        System.out.println("Parametro leido:" + numero);        if (numero != null && !numero.isEmpty()) {            try {                long $numero = Long.parseLong(numero);                long factorial = factorial($numero);                System.out.println("resultado:" + factorial);                request.setAttribute("factorial", factorial);            } catch (NumberFormatException ex) {                ex.printStackTrace();            }        }    }

Ahora, nos falta el formulario. Abramos el archivo FactorialPortlet_view.jsp, y escribamos el siguiente código:

<%@page contentType="text/html"%><%@page pageEncoding="UTF-8"%><%@ page import="javax.portlet.*"%><%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet"%><h3>Cálculo de factorial</h3><form action="<portlet:actionURL/>" method="post">    Ingrese un número:    <input type="text" name="numero" /><br/>    <button type="submit">Calcular</button>    <div>        Resultado: ${factorial}    </div></form>

La mayor parte del formulario nos es conocido: tiene input, botones, imprime resultado, etc. Pero el tag <portlet:actionURL/> quizás no sea claro, pero puede darnos la idea de qué es. Este tag devuelve la ubicación del mismo portlet dentro de toda la página de portlets. Me explico mejor:

Recordemos que cuando hacemos un formulario en JSP, siempre el action debe apuntar a una dirección web que recibirá los parámetros del formulario: puede ser un Servlet u otro JSP. Ahora, ¿qué pasaría si tuvieramos varios forms en una misma página que apuntan a diferentes direcciones? ¿Cómo hacemos para que diferencie que un formulario es diferente a otro y diferenciar las peticiones? Pues, hacer que el url del action sea totalmente diferente. Pues bien, bajo la misma lógica, el tag <portlet:actionURL/> nos ahorra saber cuál es el URL del Portlet que debemos ejecutar, además que le pone una identificación única para diferenciarlos de los demás Portlets.

Creando el archivo de despliegue

Para crear un archivo .war que contiene el Portlet, es bastante simple. Es tan igual como cuando se crea un archivo. Clic derecho el ícono de proyecto, y seleccionar Limpiar y Construir (Clean and Build).

Con esto, nos creará un archivo .war. Veamos donde lo creado en el panel de Salida (Ctrl+4) del NetBeans.

Desplegando el .war

Para desplegar un .war tenemos dos maneras: la larga, y la corta. Solo mencionaré la forma corta. Es simple: basta con copiar el .war en la carpeta "deploy" del GlassFish...

...esperamos unos segundos y el archivo desparecerá. Esperamos unos segundos más y estará desplegado en el Servidor.

Colocando el Portlet en el Portal

Primero debemos iniciar la sesión (por omisión es test@liferay.com con contraseña test). Luego, en el parte superior derecha está menú "dock", al que le damos clic y seleccionamos "Add application"

Esto hará que se muestre un panel en la margen izquierda y veamos una ventana con todas los portlets disponibles, agrupados por categorías. Nuestro portlet está en la categoría "User_Portlets".

Le damos clic en "Add" para agregar el Portlet, o si gustamos, lo arrastramos y lo soltamos en cualquier parte de la página.

Y lo hacemos funcionar...

Nota: Para cambiar la categoría del Portlet, debemos editar el archivo liferay-display.xml desde NetBeans.

Conclusión

Este post me fue lo más accidentando que me he atrevido a hacer. Pudo haber sido más simple o más completo, pero a medida que hago el tutorial, también construyo el proyecto para asegurarme que todo lo que digo sea correcto. Pero me encontré con problemas de versiones, componentes faltantes, y más cosas no esperadas. Quería terminar con el .JSF, pero ya no me dio el tiempo. Será para otro post. (También tengo que hacer cosas en donde trabajo.) En fin. Este post me motivó hacerlo ya que implementé el Liferay para el Site de la oficina donde trabajo. Aún no está del todo terminado, hicimos un par de portlets que funcionan bien, solo nos falta hacer un par más, implementar un nuevo Theme con los colores de la oficina y listo. Así que cada cosa que encuentro, lo voy colocando en mi blog.

Un tip importante que aprendí cuando hemos desarrollado los portlets de manera rápida (ya que mi computador es bastante lento para desplegar un .war en liferay), es:

Cambiar en las propiedades del proyecto a para que utilice el GlassFish v3 en lugar del Liferay
Desarrollar, probar, ejecutar, depurar como si se tratase de una aplicación web. Considerando los elementos de portlets, adaptar la aplicación para que funcione sin él. (Recordar que el método processAction() es similar a un Servlet, así que convendría utilizar un servlet por mientras.
Luego, cuando esté listo, acomodar los tags de la aplicación para pasar a liferay.
Cambiar en las propiedades del proyecto para que utilice Liferay en lugar de GlassFish v3.
Construir el .war
Desplegar el .war al Liferay.

Se pueden agregar más servlets, componentes JQuery, Ajax, Dojo, etc.

Espero que te haya hecho de utilidad.

El proyecto que utilicé en este post está aquí: http://java.net/downloads/apuntes/samples/web/SimplePortlet.tar.gz

Driver de Oracle dentro de NetBeans 7.0

2011-02-18T15:58:00.000-05:00

Acabo de bajar el NetBeans 7.0 Beta 2 con la traducción en español y comencé a probar la conectividad con Oracle. Había leído que el manejo de conexiones desde el IDE estaba mejorado (sobre todo con Oracle, ¿por que será?) y como estaba viendo un proyecto con Oracle (muchos oracle en un solo párrafo) decidí probarlo.

Para empezar, como toda conexión desde el IDE, vamos al panel de "Prestaciones". La manera más rápida es presionando las teclas Ctrl+5. Y en ese momento aparecerá el panel con los nodos de servicios (o prestaciones) para el IDE. Entre ellos está el nodo "Bases de datos".

Y como podemos ver, ya están preconfigurados los controladores para Oracle OCI y Thin. Así que trataremos de crear una conexión utilizando ese controlador. Le damos clic derecho y seleccionamos "Usar este controlador".

Pero el IDE nos dirá que no hay controladores disponibles (si es la primera vez que usamos este IDE aparecerá este mensaje).

Nos sugiere de donde bajarlo, pero como ya lo había bajado anteriormente, simplemente le doy clic en "Agregar" y uso el .jar del Oracle JDBC.

Después, clic en "Siguiente" para ver las propiedades de la conexión. Yo opté por un servidor oracle que tengo disponible, por ello el SID puse ORCL, pero si usan el Oracle Express, el SID será XE.

Hacemos clic en "Test Connection" (Ajá!, falta traducir este botón) y si está todo bien, nos mostrará el mensaje "Connection succeded" (otro más)

Clic en "Siguiente", y el IDE nos confirmará el esquema que va a utilizar.

Luego clic en "Terminar" y listo: Nuestro IDE ya está conectado a la base de datos. Espero que también pueda ver StoredProcedures, como el JDeveloper :)

Ajax en JSF 2.0 - Ejemplo 2: Tabla actualizada según se escriba

2010-06-29T11:11:00.057-05:00

Siguiendo con los ejemplos ~~después de mucho tiempo~~, ahora mostraré cómo actualizar una lista dependiendo del texto que se escribe en un input-text, pero usando Ajax. Es decir, a medida que se escribe, se actualizará el contenido del texto. Todo esto usando JSF 2.0 con su tag <ajax />

El EJB

Para comenzar, debemos tener un lista de elementos que se actualizarán de acuerdo a un parámetro. Yo tengo un EJB que hace una consulta por JPA-API a mi base de datos "samples" (Esta base de datos viene como parte de las bases de datos de ejemplo de Java DB / Apache Derby y que son accesibles desde NetBeans). La entidad que estoy manejando es el Manufacturer.

    public List<Manufacturer> findByName(String name) {        String $name = "%" + name.replaceAll(" ", "%") + "%";        CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();        CriteriaQuery<Manufacturer> criteriaQuery = criteriaBuilder.createQuery(Manufacturer.class);        Root<Manufacturer> manufacturer = criteriaQuery.from(Manufacturer.class);        criteriaQuery.select(manufacturer);        criteriaQuery.where(criteriaBuilder.like(manufacturer.get("name").as(String.class), $name));        List<Manufacturer> list = em.createQuery(criteriaQuery).getResultList();        return list;    }

El ManagedBean

Ahora, el ManagedBean que se comunicará con la interfaz de usuario y le dirá qué mostrar. Este tiene un atributo llamado "nombre" que estará asociado al input-text del formulario que el usuario verá. Lo que escriba se guardará ahí, y será tomado para la búsqueda en la base de datos.

@ManagedBean(name = "formBean")@SessionScopedpublic class ManufacturerManagedBean {    static final Logger LOGGER = Logger.getLogger(ManufacturerManagedBean.class.getName());    @EJB    private ManufacturerFacade manufacturerFacade; //el EJB    private String nombre = ""; //el atributo que estará asociado al input-text    private List<Manufacturer> manufacturerList; //la lista a mostrar    /** Creates a new instance of ManufacturerManagedBean */    public ManufacturerManagedBean() {    }    public String getNombre() {        return nombre;    }    public void setNombre(String nombre) {        this.nombre = nombre;    }    public List<Manufacturer> getListByName() {        if (manufacturerList == null) { //si es la primera vez que se accederá a la lista...            manufacturerList = manufacturerFacade.findByName(nombre); //... actualizar el contenido        }        return manufacturerList; //devuelve la lista con los elementos encontrados    }    public void nombreChangeListener(AjaxBehaviorEvent  event) {        //cada vez que haya un cambio en el texto, vuelve a generar la lista        manufacturerList = manufacturerFacade.findByName(nombre);    }}

El .xhtml

Y, en la tercera capa, vemos el .xhtml que mostrará el contenido actualizado y el formulario.

El contenido será mostrado en un <h:dataTable /> como cualquier resultado. Tendrá como ID=manufacturerTable. Este ID es importante porque es por donde el Ajax le dirá qué elemento de la página debe actualizar.

            <h:dataTable value="#{formBean.listByName}" border="1" var="item" id="manufacturerTable">                <h:column>                    <f:facet name="header">                        ID                    </f:facet>                    <h:outputText value="#{item.manufacturerId}" />                </h:column>                <h:column>                    <f:facet name="header">                        Nombre                    </f:facet>                    <h:outputText value="#{item.name}" />                </h:column>                <h:column>                    <f:facet name="header">                        e-mail                    </f:facet>                    <h:outputText value="#{item.email}" />                </h:column>            </h:dataTable>

Ahora, la parte más esperada: el input-text con el Ajax.

Realmente consiste en un tag h:inputText que tiene dentro un tag f:ajax. El que hace realmente el trabajo es este último tag.

            <h:inputText id="nombreFiltro" autocomplete="off" value="#{formBean.nombre}"  >                <f:ajax render="manufacturerTable" event="keyup" listener="#{formBean.nombreChangeListener}"/>            </h:inputText>

El atributo render dice qué IDs del HTML se van a actualizar. Aquí dice que es el ID del dataTable.
El atributo event dice qué evento del tag inputText (porque está manejando los eventos del tag que lo envuelve) va ejecutar el ajax. En este caso será el evento keyup del input-text.
El atributo listener indica cuál es el método que se ejecutará cuando suceda el evento. En este caso es el método nombreChangeListener del ManagedBean que hemos creado hace un momento.

Y listo, lo ejecutamos y ya.

El proyecto

Este proyecto, como todos los demás, debería ejecutarse si problemas en un NetBeans IDE 6.8/6.9, usando GlassFish v3. Aquí está para descargarlo.

https://java.net/downloads/apuntes/samples/web/JSF20AjaxTextoCambiaTabla.tar.gz

Reportes en NetBeans 6.1 con iReport/JasperReports y Visual Web JavaServer Faces

2008-08-08T13:22:00.006-05:00

[Este tutorial también se encuentra en los tutoriales en Español de NetBeans. Ya que es un Wiki, se puede tener el tutorial actualizado]

Introducción

Microsoft tiene su Visual Studio, Java tiene a NetBeans.

Microsoft tiene su Crystal Reports, Java tiene JasperReports.

Java no tiene nada qué envidiar a Visual Studio. Ni menos en los reportes.

JasperReports es un framework bastante completo para desarrollar reportes tanto web como desktop en Java.

Aunque el formato fuente de un reporte en JasperReports es un archivo XML, existe una herramienta que permite crear un reporte de manera visual. Su nombre: iReport.

Pero como estamos usando como IDE a NetBeans, podemos elaborar nuestro reporte sin salir del IDE. Para ello, existe un plugin (archivo .nbm) para NetBeans que muestra el iReport dentro del mismo IDE.

http://downloads.sourceforge.net/ireport/iReport-nb-0.9.2.nbm

Instalando el plugin

Después de descargar el archivo .nbm, abrimos el IDE NetBeans. Entramos al menú Tools > Plugins, y en la ficha Downloaded, hacemos clic en el botón Add plugins...

Seleccionamos el archivo .nbm que previamente hemos descargado. Después de esto se mostrará la ventana lista para instalarse el plugin:

Y hacemos clic en el botón Install. Se nos mostrará la siguiente ventana:

File:Pantallazo-NetBeans IDE Installer.png

Clic en Next. Aceptamos los términos de la licencia, y hacemos clic en Install. Nos mostrará la ventana de advertencia ya que el plugin es posible que no sea confiable:

File:Pantallazo-Verify Certificate.png

Pero como sabemos de dónde lo hemos descargado, hacemos clic en Continue.

Al finalizar la instalación del plugin, veremos que hay una opción nueva en la barra de herramientas,

y se muestra un panel nuevo de salida llamado "iReport output"

Verificando la biblioteca instalada.

Entremos a Tools > Libraries y seleccionemos la biblioteca JasperReports 2.0.5-snapshot. Revisemos el panel del classpath y veremos que hay una referencia marcada de rojo.

Pues bien, significa que según la ubicación donde se instaló el módulo no encuentra la ubicación del .jar que necesitamos para nuestra aplicación. Por tanto, lo configuraremos manualmente.

Hacemos clic en el botón Add Jar/Folder.. y buscamos la carpeta donde está instalada el NetBeans. Veremos que dentro hay una carpeta llamada ireport

Entramos a esa carpeta, luego a modules > ext.

Buscamos el archivo jasperreports-3.0.1.jar,lo seleccionamos

y hacemos clic en Add JAR/Folder.

Como podemos deducir, el problema que no encontraba el archivo jasperreports-2.0.5.jar era porque no existía.

Creando un proyecto

Lo que haremos en esta aplicación es mostrar en una lista todas las personas registradas en la base de datos TRAVEL. El usuario seleccionará uno de ellos, y hará clic en un botón llamado Mostrar Viajes para mostrar en un reporte todos los viajes relacionados a esta persona. Además, habrá un botón de opción (Radio Button) que permitirá escoger el formato del reporte: en PDF o en HTML.

Crearemos un proyecto web llamado TravelReport el cual utilizará el framework Visual Web JavaServer Faces.

Además, agregamos la biblioteca 'JasperReports 2.0.5-snapshot'

File:Pantallazo-Project Properties - TravelReport.png

La página con la lista de personas

De la paleta de componentes seleccionamos un Label y lo soltamos en el Page1.jsp. El texto que tendrá el componente label será "Seleccione una persona:".

Además, de la paleta de componentes arrastramos un Listbox y lo soltamos debajo del label que acabamos de pegar. En el panel de propiedades escribimos como id de este componente el valor personasLB.

También pegaremos un Radio button group al costado de la lista. Pondremos formatoCG como valor de la propiedad id.

Luego le damos clic derecho sobre el Radio button group que acabamos de pegar y seleccionamos la opción Configure Default Options... Editamos las opciones para que tengan como en la siguiente imagen:

File:Pantallazo-Options Customizer - formatoCG.png

Le damos nuevamente clic derecho y seleccionamos Add Binding attribute. Hacemos lo mismo con el componente personasLB.

Para finalizar con el diseño de esta página, pegaremos un componente button y tendrá como texto "Mostrar Reporte".

El diseño de la página debe quedar así:

File:Pantallazo-TravelReport - Page1.png

Accediendo a la base de datos

Entramos al panel de Services del panel izquierdo, o presionando Ctrl+5. Abrimos el nodo Databases, hacemos clic derecho sobre la conexión a la base de datos travel y seleccionamos Connect...

Seleccionamos el nodo Tables >> PERSON, lo arrastramos y lo soltamos sobre el componente personasLB. Sabremos que se realizó ya que las opciones que se mostrarán en el diseño serán "abc" tres veces.

Hacemos clic derecho sobre personasLB y seleccionamos Bind to data... Debe lucir así:

File:Pantallazo-Bind to Data - personasLB.png

Diseñando el reporte

Lo que necesitamos antes de programar cómo debe mostrarse el reporte, es, justamente, diseñar el reporte.

Presionamos Ctrl+N para mostrar el asistente para crear un nuevo archivo. Seleccionamos la categoría Report y el tipo de archivo Report.

File:Pantallazo-New File.png

Clic en el botón Next.

Escribimos viajes.jrxml como nombre del archivo, y en el campo Folder seleccionamos a través del botón Browse la carpeta src/java/travelreport

File:Pantallazo-New Report.png

Clic en el botón Next.

En la ventana donde se selecciona el Datasource, hacemos clic en el botón New.., y en la ventana de diálogo que se muestra, seleccionamos NetBeans Database JDBC Connection

Clic en el botón Next.

Escribimos 'travelDB como nombre, y de la lista desplegable seleccionamos la conexión para la base de datos travel.

Podemos hacer clic en el botón Test para comprobar que esté correcta la conexión.

Clic en el botón Save.

Clic en el botón Design query para diseñar la consulta del reporte.

En este diseñador de consultas, desplegamos la lista que se encuentra en la parte media izquierda y seleccionamos la base de datos TRAVEL. Con esto se mostrarán las tablas de la base de datos.

File:Pantallazo- query1.png

Hacemos doble clic en la tabla TRIP. Un ícono que representa a la tabla TRIP se mostrará en el panel derecho de la ventana. Hacemos doble clic también en la tabla TRIPTYPE. Veremos que se mostró la asociación existente entre ambas tablas.

Activamos las casillas de verificación de los campos DEPDATE, DEPCITY y DESTCITY de la TRIP, y DESCRIPTION de la tabla TRIPTYPE.

Clic en el botón Ok

El diseño de la consulta va a quedar así:

File:Pantallazo- query3.png

Clic en el botón Ok

Ahora vemos el comando SQL generada por el diseñador.

File:Pantallazo-New File-2.png

Clic en el botón Next.

En la selección de campos, hacemos clic en el botón ">>" para agregar todos los campos en el reporte.

File:Pantallazo-New File-3.png

Clic en el botón Next.

En la selección de grupos, hacemos clic en el botón Next, ya que no haremos alguna agrupación en el reporte.

En la selección de diseño ("Layout") del reporte, seleccionamos Tabular Layout.

File:Pantallazo-New File-4.png

Clic en el botón Next. Finalmente, clic en el botón Finish.

El IDE nos mostrará el diseño del reporte que acabamos de crear utilizando el asistente. Podemos editarlo para que luzca como en la siguiente imagen:

File:Pantallazo-NetBeans IDE 6.1-reporte1.png

Modificando el reporte para que permita parámetros.

Entramos a la opción Window > Navigating > Report Inspector. Se abrirá un panel llamado Report Inspector en la parte lateral izquierda inferior.

Hacemos clic derecho sobre el nodo Parameters y Add parameter. Con esto se agregará un nuevo nodo llamado parameter1.

Lo seleccionamos y modificamos las propiedades colocando lo siguiente:

name: personId
Default value expresion: "1"
use as a prompt: (sin seleccionar)

File:Pantallazo-NetBeans IDE 6.1-parameterPersonId.png

Hacemos clic derecho en una zona en blanco del diseñador de reportes, y seleccionamos Edit query. Se nos presentará el diseñador de consultas para el reporte actual.

File:Pantallazo-Report query.png

Tenemos dos caminos para agregar el parámetro personId en la consulta

Agregando el valor WHERE TRIP.PERSONID = $P{personId} desde la misma ventana de edición del comando SQL.
Utilizando el diseñador de reporte, haciendo clic en el botón Query designer. Para ello, desde el diseñador de consulta, damos clic derecho sobre el nodo WHERE y seleccionamos add condition

De cualquier manera, el query debe ser similar a este:

SELECT
     TRIP."DEPDATE" AS TRIP_DEPDATE,
     TRIP."DEPCITY" AS TRIP_DEPCITY,
     TRIP."DESTCITY" AS TRIP_DESTCITY,
     TRIPTYPE."DESCRIPTION" AS TRIPTYPE_DESCRIPTION
FROM
     "TRAVEL"."TRIPTYPE" TRIPTYPE INNER JOIN "TRAVEL"."TRIP" TRIP ON TRIPTYPE."TRIPTYPEID" = TRIP."TRIPTYPEID"

WHERE
     TRIP.PERSONID = $P{personId}

Hacemos clic en el botón Ok para cerrar la ventana Report query

Podemos hacer clic en el botón Preview de la barra de herramientas del diseño del reporte para ver una muestra de cómo se visualizaría el reporte.

Adicionando ImageServlet a la aplicación

Los reportes HTML de JasperReports utilizan algunos recursos propios como ciertas imágenes que ayudan a mostrarse un reporte correctamente. Para ello, debemos agregar un Servlet de JasperReports para que interprete las peticiones de imágenes usando sus propios recursos.

Abrimos el archivo web.xml, seleccionamos la sección Servlets, y hacemos clic en el botón Add Servlet Element que se encuentra en la parte superior derecha. En la ventana de diálogo que se muestra, escribimos los siguientes valores:

Clic en el botón OK

Programando el lanzamiento del reporte.

Hasta ahora hemos hecho todo el diseño visual. Ahora haremos la parte de la programación del botón Mostrar reporte.

Regresamos a la ventana Page1.jsp y estando en el modo "Design" vamos a la ventana Navigator. Examinamos los nodos y le damos doble clic en el nodo ApplicationBean1. El código fuente de ApplicationBean1.java se abrirá en el editor.

sugerencia: podemos escribir las siguientes líneas de código presionando Ctrl+Espacio cuando se desea escribir una clase o un método de tal manera que el IDE nos pueda sugerir cuáles son las clases que se utilizará y agregará los imports necesarios. También se puede copiar estas líneas de código y pegarlas en el editor del IDE, y luego presionar Ctrl+Mayúscula+I para importar las clases que se utilizan en la clase

.

Agregemos el siguiente método:

public void jasperReport(String tipo, String dataSourceName, Map<String, String> params) throws ClassNotFoundException {
        ExternalContext econtext = getExternalContext();
        InputStream inputStream = ApplicationBean1.class.getResourceAsStream("/travelreport/viajes.jasper");
        if (inputStream == null) {
            throw new ClassNotFoundException("Archivo viajes.jasper no se encontró");
        }
        FacesContext fcontext = FacesContext.getCurrentInstance();
        try {
            JRExporter exporter = null;
            Context  ctx=new InitialContext();
            DataSource ds=(DataSource) ctx.lookup(dataSourceName);
            Connection conn=ds.getConnection();
            
            JasperPrint jasperPrint = JasperFillManager.fillReport(inputStream, params, conn);
            HttpServletResponse response = (HttpServletResponse) econtext.getResponse();

            HttpServletRequest request = (HttpServletRequest) econtext.getRequest();

            response.setContentType(tipo);
            if ("application/pdf".equals(tipo)) {
                exporter = new JRPdfExporter();
                exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, response.getOutputStream());
            } else if ("text/html".equals(tipo)) {
                exporter = new JRHtmlExporter();
                exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                exporter.setParameter(JRExporterParameter.OUTPUT_WRITER, response.getWriter());
                exporter.setParameter(JRHtmlExporterParameter.IMAGES_URI, request.getContextPath() + "/image?image=");
            }
            if (exporter != null) {
                exporter.exportReport();
            }
        } catch (Exception ex) {
            Logger.getLogger(ApplicationBean1.class.getName()).log(Level.SEVERE, null, ex);
            throw new FacesException(ex);
        }
        fcontext.responseComplete();


    }

Ahora, desde la ventana Page1.jsp hacemos doble clic en el botón Mostrar reporte. Con esto se mostrará el método button1_action(). Editemos el método para que luzca así:

public String button1_action() {
        try {
            Map<String, String> params = new HashMap<String, String>();
            params.put("personId", getPersonasLB().getSelected().toString());
            String dataSourceName = getSessionBean1().getPersonRowSet().getDataSourceName();

            String tipo = (String) formatoCG.getSelected();
            getApplicationBean1().jasperReport(tipo, dataSourceName, params);

        } catch (Exception ex) {
            Logger.getLogger(Page1.class.getName()).log(Level.SEVERE, null, ex);
            error(ex.toString());
        }
        return null;
    }

Ejecutando la aplicación

Ejecutamos el proyecto con la tecla F6.

Seleccionemos una persona de la lista, seleccionamos una opción del tipo de reporte (html o pdf) y hacemos clic en el botón "Mostrar reporte".

Reporte en HTML:

Reporte en PDF:

Recursos

El código fuente del proyecto utilizado en este tutorial se encuentra aquí http://diesil-java.googlecode.com/files/TravelReport.tar.gz

Ver también

JComboBox de Objetos

2011-02-03T13:48:00.000-05:00

Cuando se usa Swing, el problema más común es mostrar elementos en un JComboBox. Lo que "normalmente" hacen es agregar cadenas a los elementos del JCB (JComboBox), pero para obtener el elemento seleccionado, se obtendría solo el valor puestos. Algunos hasta colocan el ID del elemento a mostrar, y luego buscan el elemento seleccionado en la colección. Toda una jarana... pero ¿han notado que para obtener el elemento seleccionado se utiliza el método getSelectedItem() que devuelve un objeto? Si debería mostrar String, entonces, debería devolver un String, ¿cierto? En este post explicaremos como utilizar correctamente el JCB.

Bien, supongamos que tenemos la clase Persona como el que sigue:

//...
public class Persona {

    private int idPersona;
    private String nombre;
    private int edad;

    public Persona() {
    }

    public Persona(int idPersona, String nombre, int edad) {
        this.idPersona = idPersona;
        this.nombre = nombre;
        this.edad = edad;
    }
//.. sus get y sets
//...

Y lo tenemos en una colección, o un arreglo, con elementos.. así:

//...
        Persona[] personas=new Persona[]{
            new Persona(10, "Albert", 20),
            new Persona(15, "Bernard", 21),
            new Persona(20, "Carl", 22),
        };
//...

Ahora, para crear un JCB con estos elementos, la manera rápida es así: pasando el arreglo como constructor:

//...
personasCB = new JComboBox(personas);
//...

Pueden usar cualquier forma, como addItem(), pero lo que quiero dejar en claro, es que no se agregan String, sino los mismos objetos.

Ahora, para obtener el objeto seleccionado, bastará con hacer esto:

//...
Persona p = (Persona) personasCB.getSelectedItem();
//...

Y listo!!!

Un momento, pero los elementos del combo me parecen cosas raras!! quiero que me devuelvan mi dinero!

Aún no terminé de explicar. El JCB convierte cada elemento del arreglo a String, si ponemos un arreglo de Long, lo vuelve a arreglo de String, un Double lo vuelve String.. y un objeto Persona también lo vuelve a String.

¿Sabes dónde se tiene que indicar como debe ser convertido a String un Objeto?

Respuesta: redefine el método toString() que es heredado de la clase Object... es decir, sobreescribimos el método toString() de la clase Persona.

//...
public class Persona {

    private int idPersona;
    private String nombre;
    private int edad;
//...
    @Override
    public String toString() {
        return nombre;
    }
    
    
}
//...

Si quieres que aparezca con ID, cambia lo que devuelve el método toString.. si quiers un formato especial.. igual.. todo es en el método toString()

El código fuente de este ejemplo se puede obtener de aquí:
http://java.net/projects/apuntes/downloads/download/Swing%252FJComboBoxObjetos.tar.gz

RESTful parte 3: Manejando colecciones de objetos y objetos complejos

2011-01-04T19:52:00.000-05:00

Comenzamos este año nuevo con la continuación del (creo yo) más esperado tema de tutorial: RESTful. Y esta vez hablaremos sobre el manejo de colecciones y objetos complejos. Por ahora será de manera básica y veremos poco a poco cómo hacerlo más y más complejo.

Manejo de colecciones

Para comenzar, tomaremos el mismo proyecto que vimos en el último post y agregaremos otro recurso llamado PersonaResource con el path apuntando por /listaPersonas.
¿Cómo hacer esto? Bien fácil:

Crear una clase llamada PersonaResource dentro del paquete com.apuntesdejava.rest
Agregar las siguientes anotaciones al inicio de la declaración de la clase:
```
@Stateless
@Path("/listaPersonas")
```

Es decir, al final tendremos el código para la clase de la siguiente manera:

package com.apuntesdejava.rest;

import javax.ejb.Stateless;
import javax.ws.rs.Path;

@Stateless
@Path("/listaPersonas")
public class PersonasResource {
}

Guardando objetos en la colección

Esto es realmente fácil. Es como cualquier método en Java que recibe un objeto y lo guarda en el arreglo:

//...
    static List<Persona> personas = new ArrayList<Persona>();

    @POST
    @Consumes({"application/xml", "application/json"})
    public Response guardar(Persona p) {
        p.setIdPersona(personas.size() + 1); //se le autoasigna un id al objeto
        personas.add(p);
        return Response.ok(p).build();
    }
//...

Sabemos que el objeto vendrá en formato JSON o XML. Si tenemos dudas, probemos con el "Test RESTful Web services" de NetBeans.

Probaremos enviando la siguiente cadena en el método POST.

{"nombre_persona":"Juan Perez",
"edad":"35",
"trabajador":"true",
"fechaNacimiento":"1976-01-01"}

Y veremos que en la respuesta nos devuelve con el ID de la persona autogenerada.

<?xml version="1.0" encoding="UTF-8"?>
   <persona id_persona="1">
       <fechaNacimiento>1976-01-01T00:00:00-05:00</fechaNacimiento>
       <nombre_persona>Juan Perez</nombre_persona>
       <sexo>0</sexo>
       <trabajador>true</trabajador>
   </persona>

Como se puede en esta imagen, está el envío de la data, y la respuesta del servidor.

Esto es bastante fácil, porque es lo mismo que se vió en el anterior post. Ahora veremos como se obtiene una lista.

Obteniendo objetos en la colección

Lo bueno de utilizar RESTful en Java es que no requiere declarar métodos extraños ni clases adicionales (hasta ahora). Entonces, si queremos que nuestra clase tenga un método que devuelva una lista de objetos de una lista en base a un criterio (por ejemplo, los que tengan uno determinado texto), podría ser como el que sigue:

    public List<Persona> buscar(String nombre) {
        List<Persona> lista = new ArrayList<Persona>();
        for (Persona persona : personas) {
            if (persona.getNombre().indexOf(nombre) >= 0) {
                lista.add(persona);
            }

        }
        return lista;
    }

¿Cierto? Bien, ahora lo convertiremos en servicio RESTful agregando la anotación GET, además de qué tipos va a devolver.

    @GET
    @Produces({"application/xml", "application/json"})
    public List<Persona> buscar( String nombre) {
        List<Persona> lista = new ArrayList<Persona>();
        for (Persona persona : personas) {
            if (persona.getNombre().indexOf(nombre) >= 0) {
                lista.add(persona);
            }

        }
        return lista;
    }

Pero como va a recibir un parámetro, por método @GET (es decir, como parte del URL.. o query string) entonces hay que darle un nombre usando @QueryParam.

    @GET
    @Produces({"application/xml", "application/json"})
    public List<Persona> buscar(@QueryParam("nombre") String nombre) {
        List<Persona> lista = new ArrayList<Persona>();
        for (Persona persona : personas) {
            if (persona.getNombre().indexOf(nombre) >= 0) {
                lista.add(persona);
            }

        }
        return lista;
    }

Ahora, probemos con el "Test REST" de NetBeans (previo registro de objetos, claro está).

Notemos que el nombre del parametro query no necesariamente tiene que ser el mismo nombre del parámetro del método de Java. Es decir, esto es totalmente válido:

    @GET
    @Produces({"application/xml", "application/json"})
    public List<Persona> buscar(@QueryParam("name") String nombre) {
//...
    }

Objetos complejos

Ahora bien, ya nos podemos imaginar que si permite exportar una simple colección de la manera más simple, también se puede exportar un objeto compuesto (es decir, un objeto que tenga propiedades que son otros objetos).
Pero antes de seguir, quiero recordar que esta parte del tutorial es aún básico. Por ahora no pretendamos poner un objeto que tenga una referencia cíclica, es decir, que tenga una propiedad que es otro objeto y que este tenga otra propiedad que apunte al primer objeto. Sí se puede hacer, pero por ahora no lo veremos porque para ello hay que hacer algunas modificaciones adicionales.

Crearemos una clase llamada Telefono que tendrá las propiedades area y numero.

public class Telefono {

    private String numero;
    private String area;

    public String getArea() {
        return area;
    }

    public void setArea(String area) {
        this.area = area;
    }

    public String getNumero() {
        return numero;
    }

    public void setNumero(String numero) {
        this.numero = numero;
    }
}

Y, en nuestra clase Persona agregaremos una colección de la clase recién creada:


public class Persona {
//....
    private List<Telefono> telefonos;

    public List<Telefono> getTelefonos() {
        return telefonos;
    }

    public void setTelefonos(List<Telefono> telefonos) {
        this.telefonos = telefonos;
    }
//....

Ahora, probemos con la siguiente cadena JSON (no olvidar que se selecciona POST (application/json)) para registrar nuestro objeto:

{
  "nombre_persona":"Carl",
  "telefonos"     :[
                    {"area":"51","numero":"12345"},
                    {"area":"54","numero":"98765"}
                   ]
}

Y al obtener la lista de los objetos, se obtiene sin ningún problema. Ya sea en XML...

... o en JSON...

Si quieres conocer más sobre los formatos de JSON, visita aquí: http://www.json.org/json-es.html

Ya haré un post dedicado únicamente a los clientes de RESTful, tanto como para probar como para hacer una aplicación desktop, javascript, javafx, mobile, etc.

El siguiente post, cómo manejar los java.util.Map y después, los métodos @DELETE y @PUT

El código fuente

Aquí está el infaltable código fuente del proyecto

http://kenai.com/projects/apuntes/downloads/download/PersonaRESTWeb%252FPersonasRESTWeb.tar.gz

Bendiciones!

Delay

2010-12-09T11:05:00.000-05:00

Mantener un blog es complicado, mas no imposible.

Me había propuesto en poner un post cada martes, así en un mes habrían al menos cuatro apuntes que podrían ayudar a la comunidad java - en especial a los hispanos. Si en estas últimas semanas no he podido publicar más artículos no fue porque no sé qué publicar, sino por falta de tiempo.

Estamos terminando un año, y con él muchos proyectos se deben cerrar, y para preparar (no es por presumir, pero vuestros comentarios me lo confirman) un buen artículo se necesita un tiempo exclusivo.

Hay bastante material para publicar en mi blog, por ejemplo:

RESTful con objetos complejos, con entidades, con arreglos, con conversores de tipo y sus clientes en PHP, JavaScript, JavaFX, etc.
Plantillas en Liferay.
JPA 2.0 y todo lo que se puede hacer.
JSF 2.0: más ejemplos de Ajax, y sus extensiones con ICefaces
JasperServer
NetBeans Platform
Java EE 6 sobre WebLogic
etc

Como se ve, hay bastante material para publicar, sin mencionar los tutoriales de NetBeans.org que quiero traducir y los cursos virtuales que ya bastante tiempo los estoy postergando.

Dios mediante, este blog no va a morir.

Por lo pronto me pueden seguir en Twitter (@apuntesdejava), FriendFeed (http://friendfeed.com/apuntes-de-java) y Facebook.

Gracias por su preferencia.

Bendiciones...!

RESTful - Parte 2: Manejando un solo objeto

2010-11-25T05:15:00.004-05:00

Hemos visto en el anterior post cómo hacer un servicio REST solo para producir y consumir un texto simple. Ahora bien, en la vida real no son textos simples, sino estructuras de datos algo complicadas. Pero para ir lentos pero seguros, aprenderemos cómo hacer un servicio REST pero para manejar un solo objeto.

Afortunadamente para nuestros proyectos, no debemos crear ningún XML, ni tener algún "parser" que convierta nuestros objetos en formato XML o algo parecido para enviar y recibir objetos por la red. Solo necesitamos crear nuestros JavaBeans... y ponerle algunos tags.

Manos a la obra...

Supongamos que tenemos creado el proyecto web PersonaRESTWeb sobre GlassFish v3 y sin ningún framework adicional. Recordemos que nuestro proyecto se autoconfigura en REST cuando se aplica una anotación especial.

Creando un javaBean

Una vez creado el proyecto, crearemos un JavaBean llamado Persona


public class Persona {

    private int idPersona;
    private String nombre;
    private java.util.Date fechaNacimiento;
    private boolean trabajador;
    private char sexo;
//...

... con sus respectivos set y get.

Ahora, este JavaBean lo entendemos muy bien en Java, pero recordemos de que un servicio web debe ser compatible para otros lenguajes, y que la estructura de datos más "compatible" es el XML. Así que vamos hacer que este JavaBean se convierta en XML. Bastará con poner la anotación @XmlRootElement al inicio de la declaración de la clase.


@XmlRootElement
public class Persona {

    private int idPersona;
    private String nombre;
    private java.util.Date fechaNacimiento;
    private boolean trabajador;
    private char sexo;
//...

Creando recurso manejador de Persona

El diseño de este Servicio obliga a que exista un solo recurso manejador por cada Entidad. Por tanto, debemos crear la clase PersonaResource. Y para que administre un JavaBean, declararemos un objeto static.

Nota: Lo normal aquí es usar un manejador de persistencia (sea JPA, JDBC, etc..), pero como el objetivo de este tutorial es ver cómo funciona un REST, no gastaremos esfuerzo por conectarnos a una base de datos.

Este es el código fuente del recurso PersonaResource


@Stateless
@Path("/personas")
public class PersonaResource {

    static Persona persona;
}

Ahora, necesitamos implementar los métodos para registrar un objeto Persona desde el cliente, y leer el objeto desde el hacía hasta el cliente. Por tanto, crearemos dos métodos: registrar y leer.

Leer valor del objeto

Esto ya lo hemos visto. Es declarar un método y declararlo con la anotación @GET


//...
    @GET
    public Persona leer(){
        return persona;
    } 
//...

Sí, nada más (por ahora)

Guardar valor al objeto

Esto debería ser sencillo. Bastaría con poner este código


//...
    @POST
    public void guardar(Persona p) {
        persona = p;

    }
//...

Pero no es así. Porque toda petición que se hace a un recurso web (el que sea) siempre debe devolver algo.. así sea un error, pero debe devolver algo. En REST debe devolver un objeto javax.ws.rs.core.Response que contiene el estado de la petición: si está OK, si hay error de restricción, si no responde, etc.. todos los errores que conocemos para HTTP están contenidos en ese objeto. Pero para nuestro caso, vamos a devolver el valor "ok" de la siguiente manera:


//...
    @POST
    public Response guardar(Persona p) {
        persona = p;
        return Response.ok(p).build();
    }
//...

Ahora sí... a desplegarlo y a probar... pero si lo probamos en este momento, nos mostrará la siguiente ventana.

y.. qué pondremos en la caja de texto? Pues el objeto a enviar... pero ¿cómo? Pues un dato estándar, como XML o JSON. Por ejemplo, este código


<persona>
       <idPersona>20</idPersona>
       <nombre>Albert</nombre>
       <trabajador>true</trabajador>
</persona>

Lo probamos y... error!!! ¿qué pasó?

Pues nuestro servicio REST no sabe si la data que va a recibir es un XML, o un JSON. Hay que decirle al método de ese recurso cómo va a recibir los datos. Por ahora, vamos a poner esta anotación en el método:


//...
    @POST
    @Consumes("application/xml")
    public Response guardar(Persona p) {
        persona = p;
        return Response.ok(p).build();
    }
//...

Ahora sí, desplegamos, ejecutamos el Test y... vemos que ahora el método POST dice qué tipo permitirá:

Escribimos nuevamente el texto y voila!! Status: 200 (OK)

"Bien, el XML funciona, pero el formato es un poco grande ¿se puede usar JSON?" Sí.. y lo mejor, es bien sencillo activar esa opción.


//...
    @POST
    @Consumes({"application/xml","application/json"})
    public Response guardar(Persona p) {
        persona = p;
        return Response.ok(p).build();
    }
//...

Listo, ahora nuestro método guardar() permite recibir tanto JSON como XML. Probemos ahora colocando el siguiente valor en el módulo de prueba:


{  "idPersona":"20",
   "nombre":"Bernard",
   "trabajador":"true"
}

... seleccionamos el tipo JSON...

... y listo.. funciona!

Si no están seguros de que guardó correctamente, ejecutemos el método GET para ver si lo guardó en el objeto

Modificando el tipo de formato para leer el objeto

Ya vimos que se puede establecer el tipo que el Servicio recibirá por la red usando @Consumes. Y cuando probamos la lectura, lo convierte siempre a XML ¿se puede cambiar para que sea JSON? Por su puesto, y es igual de simple:


//...
    @GET
    @Produces({"application/json","application/xml"})
    public Persona leer() {
        return persona;
    }
//...

Por omisión usará el primer tipo especificado (en este caso "json"), o - dependiendo cómo se indique en el cliente - puede utilizar el formato XML.

Modificando la estructura de los datos

Nuestro bean utiliza la propiedad idPersona, y el REST lo procesa correctamente. Pero, si el estándar de los proyectos donde se va a utilizar, dice que debe ser id_persona y el campo nombre sea nombre_persona ¿Cómo modificamos esto?

Esto también es fácil. Por cada método "get" que debemos cambiar el formato, le agregamos la anotación @XmlElement seguido del nombre como deberá ser manejado. Vayamos al Bean Persona y pongamos esto:


//...

    @XmlElement(name = "id_persona")
    public int getIdPersona() {
        return idPersona;
    }

    @XmlElement(name = "nombre_persona")
    public String getNombre() {
        return nombre;
    }
//...

Ahora, probemos el método "GET".

¿Y si, el id_persona tiene que ser un atributo del XML? Cambiamos la notación @XmlElement por @XmlAttribute


//...

    @XmlElement(name = "id_persona")
    public int getIdPersona() {
        return idPersona;
    }

//...

Ojo, cuando es atributo y se desea enviar en formato JSON, se debe considerar ql nombre del atributo antepuesto por un @.


{  "@id_persona":"20",
   "nombre_persona":"Bernard",
   "trabajador":"true"
}

"En ningún momento aparece el nombre del método `guardar()` y `leer()` ¿Cómo sabe qué método utilizar?"

Pues por el mismo método HTTP utilizado: Si se hace "POST", ejecuta el método que está asociado a @POST, si se hace "GET", utiliza el @GET.

¿"Y si quiero diferenciar un 'update' de un 'create' ? " Pues utilizar otro método. Como comenté en el anterior post, el POST debe estar asociado al "create",el GET asociado a la búsqueda, el "PUT" al "update" y el "DELETE" al borrar.

Si hay que hacer otro tipo de "POST" o de "DELETE", debemos utilizar otro objeto Recurso (con anotación @Path) ya que será accedido desde otra ruta.

Por ello comenté en el anterior post de que este diseño asegura de que los métodos de mantenimiento están asociados a una sola entidad.. y nos evitará tener métodos en servicios web que no corresponde, por ejemplo, no habrá un manejo de proveedores en un servicio de clientes.

Código del proyecto

Aquí se encuentra el código fuente del proyecto web:

http://kenai.com/projects/apuntes/downloads/download/PersonaRESTWeb%252FPersonaRESTWeb.tar.gz

Aquí el código fuente de una aplicación Java Desktop:

http://kenai.com/projects/apuntes/downloads/download/PersonaRESTWeb%252FPersonaRESTClient.tar.gz

Lo que se viene con JDK 7 & NetBeans 7

2010-11-16T00:00:00.123-05:00

Se dice que el número 7 es el número de la perfección, y para el mundo Java este número no está lejos de serlo.
Está cerca el JDK 7, con muchas mejoras en la sintaxis, y casi a la par también sale el NetBeans 7 con su respectiva compatibilidad.

En este post mostraré algunas características de estos software.

(Mientras termino la continuación del RESTful para objetos, voy mostrando esto)

Descargando e instalando JDK 7

Primero, debemos descargar el JDK, y este lo podemos obtener de aquí

http://dlc.sun.com.edgesuite.net/jdk7/binaries/

... bajo el título Windows Offline Installation, Multi-language JDK file
jdk-7-ea-bin-b118-windows-i586-11_nov_2010.exe

Nota: Esta es la versión disponible a la fecha de este post. Si no existe, buscar dentro de http://download.java.net/jdk7/.

La instalación del JDK no es cosa del otro mundo, ya que el instalador siempre nos dice qué opción debemos elegir... y hasta creo que es mucho más rápida.

Luego comprobamos que la instalación fue correcta, escribiendo en la línea de comandos java -version

Ojo, yo aún tengo instalado el JDK 6, y si deseo utilizarlo, cambio la ruta de la variable JAVA_HOME.

Aquí quiero hacer una notación importante. La variable de entorno JAVA_HOME debe apuntar a la carpeta o directorio que tiene el subdirectorio "bin" del Java. Por ejemplo, en este momento tengo mi variable establecida así:

a pesar que ya tengo instalado la versión JDK 7.. incluso el compilador puedo utilizar la versión 6,

para utilizar la nueva versión, debo cambiar la variable de entorno al directorio de la versión 7.

Para cambiar el valor de la variable de entorno en Windows, entrar a las propiedades de la PC (una manera más rápida es presionando las teclas Win+Pausa) y buscando la opción "Variables de Entorno". Para XP, Vista, 7 cada ventana son diferentes, así que no diré cómo son las ventanas.

Descargando e instalando NetBeans 7.0

A la fecha de este post, el NetBeans 7.0 está en la etapa M2, así que descargaremos esta versión desde aquí:

http://bits.netbeans.org/netbeans/7.0/m2/

Personalmente, cada vez que quiero probar una versión del NetBeans, elijo la opción ".zip", ya que solo descargado y descomprimo el contenido y listo! ya tengo el NetBeans instalado (Eclipse, no te creas en ser el único)

Pero para asegurarnos de que el NetBeans utilizará el JDK7, debemos modificar el archivo de configuración del IDE. Este se encuentro en el subdirectior "etc" de NetBeans. El nombre del archivo es "netbeans.conf", y agregamos esta línea

netbeans_jdkhome="C:\Archivos de programa\Java\jdk1.7.0"

.. y luego le damos doble clic al netbeans.exe para ejecutar el IDE.

Luego de leer la licencia, memorizarla y aceptarla, ya podemos disfrutar del IDE NetBeans 7 + JDK 7

Ahora, crearemos un nuevo proyecto de Aplicación Java, y veremos que por omisión la clase prinicipal que contiene el método public static void main() ya no es Main ya que ocasionaba muchas confusiones para los principiantes, sino es el mismo nombre del proyecto. Ojo, puede ser cualquier nombre, pero aquí el NetBeans sugiere ese nombre.

Luego, entramos a las propiedades del proyecto, y cambiamos la versión del código fuente a utilizar en nuestro proyecto.

Características nuevas de JDK 7 en NetBeans 7.0

Aquí vienen las características más esperadas ~~que todo el mundo se quejaba de que Java no tena~~ y que vienen a nuestra salvación.

`switch` con cadenas

Esta es - creo yo - la que muchos esperábamos: usar cadenas en switch. Por definición, los switch solo permiten una variable de tipo escalar (nativo), como el char, int, byte, etc... es decir, los String no "juegan". Entonces, solo con los Strings usábamos "if" encadenados, como aquí:

Pero aquí NetBeans nos muestra una sugerencia: cuando pasamos el ratón por el foquito del margen izquierdo nos dice

.. y al seleccionar la opción.. adivinen qué sucede...

Operador "diamante": anulando Genericos redundantes

En la versión Java 1.5 aparecieron los Genéricos, una notación importante para asegurar los tipos de las colecciones. Es decir, antes en un List podía tener String, objetos persona, Integer, arreglos.. etc... y para obtener un elemento debía hacerse "casting". Pero en la versión 5, con los genéricos, se podía declarar un tipo para una colección y asegurar que el objeto devuelto siempre era del mismo tipo declarado y evitaba hacer "cast".

List<Persona> personas=new ArrayList<Persona>();

Pero había un problema: el tipo de la colección que se estaba instanciando debería ser del mismo tipo de la declaración. Es decir, no se podía hacer esto:

List<Persona> personas=new ArrayList<Empleado>();

por más que Empleado sea subclase de Persona. Se puede utilizar caracteres comodines, pero eso es otra historia. El asunto es que para una declaración simple como la mencionada antes, debería usarse siempre el mismo tipo en la instanciación. Entonces, si ya fue declarado con un tipo, ¿Ya no debería mencionarlo en la instanciación? Pues, aquí NetBeans nos sale a la ayuda.

Antes:

Después:

Multicatch

¿Tienes una código que contiene muchos catch, y según la recomendación de Jav se debería usar un catch específico por cada excepción para manejarla de manera específica.... y en tu código en todos los catch se hace lo mismo.. y quieres evitar de usar la clase Exception? No te preocupes. Aquí aparecen los multicatch. Supongamos este código:


        File f=new File("d://temp.xml");
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document d = builder.parse(f);
        } catch (SAXException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (ParserConfigurationException ex) {
            ex.printStackTrace();
        }

El IDE nos sugerirá algo en el primer "catch".

Antes:

Después:

Estos fueron algunos.. más información de NB 7.0 lo podeís ver aquí:

http://wiki.netbeans.org/NewAndNoteworthyNB70

Hasta el siguiente apunte!!

Descargar XLS y PDF sin abrirlos en el navegador (versión Servlet)

2010-08-18T16:19:00.001-05:00

Anteriormente hice un post de cómo "Descargar XLS y PDF sin abrirlos en el navegador" pero fue realizado con PHP. Ahora les traigo el mismo ejemplo pero usando Servlet

Para realizar esto, es necesario tener un Servlet que reciba como parametro el url que le indica dónde está el archivo a mostrar para descargar. En este ejemplo he preparado para que descargue desde cualquier host.

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String paramUrl = request.getParameter("url"); //el URL enviado como parametro
        URL url = new URL(paramUrl);

        response.setContentType("application/octet-strem");
        response.setHeader("Content-Disposition", "attachment;filename='" + url.getFile() + "'"); //preparando el 'download' al navegador

        URLConnection connection = url.openConnection();
        InputStream in = connection.getInputStream(); //conectando para descargar
        OutputStream out = new DataOutputStream(response.getOutputStream());

        byte[] buffer = new byte[BUFFER_SIZE];
        int sizeRead = 0;
        while ((sizeRead = in.read(buffer)) >= 0) { //leyendo del host
            out.write(buffer, 0, sizeRead); //escribiendo para el navegador
        }
        in.close(); // y cerrando
        out.close(); // todo


    }

El proyecto utilizado para este ejemplo se encuentra aquí:
http://kenai.com/projects/apuntes/downloads/download/ejemplos%252Fweb%252FDescargarWebApp.tar.gz

Instalando Liferay 6 en GlassFish v3

2010-09-09T19:00:00.001-05:00

Retomando los tutoriales, ahora vengo con lo de la instalación de Liferay 6 en GlassFish v3.

La verdad, es casi lo mismo que está explicado en el anterior post "Instalación de Liferay en un servidor GF v3 para producción", con la excepción de que se debe considerar algunos cambios:

Los archivos se deben descargar de aquí (al momento que se escribió este post, la versión disponible es la 6.0.5): https://sourceforge.net/projects/lportal/files/Liferay Portal/6.0.5/

Dentro hay varios archivos, los principales que vamos a utilizar para desplegar el liferay son los siguientes:

Bibliotecas de dependencias: https://sourceforge.net/projects/lportal/files/Liferay Portal/6.0.5/liferay-portal-dependencies-6.0.5.zip/download
.War del portal: https://sourceforge.net/projects/lportal/files/Liferay Portal/6.0.5/liferay-portal-6.0.5.war/download

Nota:

No se necesitará el archivo XercesImpl.jar.
Se debe reemplazar un archivo del GlassFish. Este archivo se llama commons-codec-repackaged.jar y se encuentra dentro de $GLASSFISH_HOME/glassfish/modules. En su lugar debe estar la biblioteca commons-codec.jar. Esta se puede obtener desde aquí: http://commons.apache.org/codec/ (Exactamente, desde aquí: http://commons.apache.org/codec/download_codec.cgi)
Cuando se configure el Pool de Conexiones para LiferayPool, poner emulateLocators=false

Todo lo demás, es exactamente lo mismo como se explicó en el anterior post. Hasta también podeis usar el portal-ext.properties para utilizar la base de datos como Pool de Conexiones: http://kenai.com/projects/apuntes/downloads/download/ejemplos%252Fliferay%252Fportal-ext.properties.

¿Y la migración desde una versión anterior? La verdad me está resultando difícil. A mi me interesa, ya que tengo un portal que quiero migrarlo a esta nueva versión. Así que ya os avisaré cuando lo haya logrado.

Liferay: Registrando varios usuarios (usando complemento Hook)

2010-09-22T01:51:00.001-05:00

He estado buscando alguna opción de Liferay que me permita crear varios usuarios a la vez... pero no tuve éxito. Pensé (y hasta pregunté en el foro de liferay.com) si se podía modificar directamente la base de datos. Pero como es un sistema complejo, hacer esto podría malograr el sistema.

Entonces pensé que debería haber otra solución utilizando el API de Liferay. Al final de todo, es una plataforma, y debería existir un API completo para ello.

Bien, el API existe, pero la documentación es bastante pobre (solo echarle un vistazo al javadoc http://docs.liferay.com/portal/6.0/javadocs/ no tiene ni una descripción de alguna clase.. al menos sirve para saber qué clases tiene el API)

Encontré en el wiki de Liferay sobre el desarrollo de extensiones para el Portal, y este me pareció interesante: http://www.liferay.com/community/wiki/-/wiki/Main/Portal+Hook+Plugins. Habla de manera general para qué sirven los Hooks dentro de Liferay y muestran algunos ejemplos.

En líneas generales, los hooks son complementos que modifican el comportamiento del liferay. Hay de tres tipos:

Los que se ejecutan al inicio del portal
Los eventos de inicio de sesión, y
Los eventos de servicios.

Como mi caso es crear usuarios masivamente, me corresponde crear un Hook cuando se ejecute el liferay. Otros ejemplos de Hook (como el de inicio de sesión) se puede encontrar en Adictosaltrabajo.com: http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=LiferayHookPlugin

En varios tutoriales explican que debería bajarse el Kit de desarrollo (SDK) de Complementos de Liferay. Pero no se preocupen, NetBeans con el PortalPack ya nos ahorra bastante este trabajo. Así que manos a la obra.

Requisitos

Para este tutorial utilicé lo siguiente:

NetBeans 6.9.1 con JDK 6.0u21
PortalPack 3.0.4 (Descargable desde aquí: http://contrib.netbeans.org/portalpack/pp30/download304.html)
Liferay 6.0.5 en Tomcat 6.0 (Descargable desde aquí: http://sourceforge.net/projects/lportal/files/Liferay%20Portal/6.0.5/liferay-portal-tomcat-6.0.5.zip/download)

Si quieres saber cómo configurar el Liferay con el NetBeans, te recomiendo mi anterior post: Nuestro primer portlet en Liferay. Aunque se explica utilizando el Liferay + GlassFish, el agregar el servidor Liferay al NetBeans es el mismo procedimiento.

Creando el proyecto Hook

La creación de un proyecto hook en NetBeans es bien simple: consiste en crear un proyecto web común y corriente. A este le llamaremos "CrearUsuarios-hook"

Luego, escogemos el tipo de servidor que queremos utilizar. Naturalmente debemos escoger el Liferay, ya que con esto el NetBeans nos agregará las bibliotecas necesarias para nuestro proyecto.

Y en este paso, hacer clic en "Finish" sin crear ningún portlet.. porque lo que vamos a hacer es un Complemento Hook, no un Portlet.

Creando el complemento Hook

Bien, hasta ahora solo hemos creado el espacio de trabajo. Ahora crearemos el Hook como si fuera un archivo más. Entramos a File > New File y seleccionamos en la categoría "WebSpace/Liferay Plugins" el tipo de archivo "Hook Plugin"

Después de hacer clic en "Next", especificamos qué tipo de Hook es el que vamos a crear. Como queremos que se ejecute al inicio del Portal, seleccionamos en "Event Type" el valor "application.startup.events". El nombre de la clase será CrearUsuariosHookAction en el paquete hook.

Clic en Finish y listo.. ya tenemos nuestra clase en blanco listo para llenar.

Registrando los usuarios

Como les comenté al inicio, la documentación es bastante pobre. Creo que es por la cantidad de clases que contiene. Pero no hay problema. Ya existe un ejemplo (también, sin documentación) de cómo utilizar el API de Liferay. Su nombre es sevencogs-hook y está disponible en la página del proyecto Liferay en sourceforge.net. Aquí están los archivos:

Ejemplo para Liferay 5.2.x: http://sourceforge.net/projects/lportal/files/Liferay%20Plugins/5.2.2/sevencogs-hook-5.2.2.1.war/download
Ejemplo para Liferay 6.0.x: http://sourceforge.net/projects/lportal/files/Liferay%20Plugins/6.0.5/sevencogs-hook-6.0.5.1.war/download

Mi opinión es que el ejemplo de Liferay 5.2 es el más claro.

Por si causa confusión donde encontrar el ejemplo exacto, el código fuente del Hook son los siguientes:

El código es bastante entendible. Basta entender las variables utilizadas. Aquí muestro mi código que es compatible con Liferay 6


    private void doRun(long companyId) {

        try {
            String firstName = "Diego";
            String lastName = "Silva";
            boolean male = true;
            String jobTitle = "Consultor Java";
            String screenName = "diego.silva";
            long creatorUserId = 0;
            long facebookId = 0;
            boolean autoPassword = false;
            String password1 = screenName;
            String password2 = password1;
            boolean autoScreenName = false;
            String emailAddress = screenName + "@apuntesdejava.com";
            String openId = StringPool.BLANK;
            Locale locale = new Locale("ES", "PE");
            String middleName = StringPool.BLANK;
            int prefixId = 0;
            int suffixId = 0;
            int birthdayMonth = Calendar.MARCH;
            int birthdayDay = 27;
            int birthdayYear = 1976;
            Country country = CountryServiceUtil.getCountryByA2("PE");
            long countryId = country.getCountryId();
            long regionId = 0;
            Group guestGroup = GroupLocalServiceUtil.getGroup(companyId, GroupConstants.GUEST);
            long[] groupIds = new long[]{guestGroup.getGroupId()};
            long[] userGroupIds = null;
            boolean sendEmail = false;
            Role adminRole = RoleLocalServiceUtil.getRole(
                    companyId, RoleConstants.ADMINISTRATOR);

            Role powerUserRole = RoleLocalServiceUtil.getRole(
                    companyId, RoleConstants.POWER_USER);
            long[] roleIds = new long[]{
                adminRole.getRoleId(), powerUserRole.getRoleId()
            };
            int statusId = GetterUtil.getInteger(PropsUtil.get("sql.data.com.liferay.portal.model.ListType.organization.status"));
            String comments = null;
            ServiceContext serviceContext = null;
            System.out.print("Creando organización...");
            //creando la organización
            long userId=UserLocalServiceUtil.getDefaultUserId(companyId);
            long parentOrganizationId =
   OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID;
            boolean recursable = true;
            Organization apuntesOrganization = OrganizationLocalServiceUtil.addOrganization(userId, parentOrganizationId, "Apuntes de Java",
                    OrganizationConstants.TYPE_REGULAR_ORGANIZATION,
                    recursable, regionId, countryId, statusId,
                    comments, serviceContext);
            long[] organizationIds = new long[]{apuntesOrganization.getOrganizationId()};
            System.out.println("... registrado con ID:"+apuntesOrganization.getOrganizationId());
            //registrando el usuario
            System.out.print("Creando usuario...");
            User user = UserLocalServiceUtil.addUser(creatorUserId, companyId,
                    autoPassword, password1, password2,
                    autoScreenName, screenName, emailAddress, facebookId,
                    openId, locale,
                    firstName, middleName, lastName,
                    prefixId, suffixId, male, birthdayMonth,
                    birthdayDay, birthdayYear,
                    jobTitle, groupIds, organizationIds,
                    roleIds, userGroupIds, sendEmail, serviceContext);
            System.out.println("... creado con ID:"+user.getUserId());
        } catch (PortalException ex) {
            LOGGER.log(Level.SEVERE, null, ex);
        } catch (SystemException ex) {
            LOGGER.log(Level.SEVERE, null, ex);
        }
    }

Aquí se ve que se ha creado una organización nueva llamada "Apuntes de Java" y el usuario que es perteneciente a ella.

La diferencia con Liferay 5, es que en el 6 hay un nuevo parámetro llamado facebookId. Todos los demás campos son iguales. Así que considere esta característica cuando hagas un Hook de crear usuarios en Liferay 5 o 6.

Ejecutando el proyecto

Desde nuestro IDE bastará con ejecutar el proyecto y esperar que se despliegue en el servidor local.

Y aquí vemos la organización creada...

Y el usuario creado...

Para crear varios usuarios, bastará con repetir la misma operación con cada uno de ellos. O si se desea importar de una tabla preexistente, consideren hacer una conexión por JDBC a la base de datos donde se tienen los usuarios a cargar, y dentro de un while (rs.next()) llamar al método UserLocalServiceUtil.addUser()

Desplegando en servidor de producción

Para ponerlo en producción, primero debemos construir el .war. Esto es simple, basta con darle clic derecho al ícono del proyecto y seleccionar build. Con esto nos generará el archivo .war listo para desplegarlo en el servidor.

Hay dos maneras para desplegarlo en un servidor en producción. Una es utilizando el ControlPanel de Liferay y utilizar la opción "Instalar complemento", seleccionamos el archivo .war e instalarlo.

La otra es copiar el archivo .war en el directorio deploy que se encuenrta dentro del directorio instalado de Liferay.

Código fuente

Y no podía faltar el código fuente del proyecto utilizado para este tutorial:
http://kenai.com/projects/apuntes/downloads/download/ejemplos%252Fliferay%252FCrearUsuarios-hook.tar.gz

¡Que les sea de utilidad!