Apuntes de Java

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

noreply@blogger.com (Diego Silva) — Thu, 29 Dec 2011 10:20:00 PST

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

noreply@blogger.com (Diego Silva) — Mon, 26 Sep 2011 05:00:00 PDT

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

noreply@blogger.com (Diego Silva) — Wed, 21 Sep 2011 08:17:00 PDT

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.

Libro: Java EE 6 Development with NetBeans 7

noreply@blogger.com (Diego Silva) — Tue, 20 Sep 2011 07:45:00 PDT

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

Probando RESTful con Poster

noreply@blogger.com (Diego Silva) — Tue, 13 Sep 2011 15:36:00 PDT

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

Contraseñas encriptadas con Java

noreply@blogger.com (Diego Silva) — Sat, 04 Jun 2011 15:27:00 PDT

¿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

noreply@blogger.com (Diego Silva) — Tue, 08 Mar 2011 15:26:00 PST

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

Driver de Oracle dentro de NetBeans 7.0

noreply@blogger.com (Diego Silva) — Fri, 18 Feb 2011 12:58:00 PST

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 :)

JComboBox de Objetos

noreply@blogger.com (Diego Silva) — Thu, 03 Feb 2011 10:48:00 PST

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 4: Actualizando y eliminando elementos de una colección.

noreply@blogger.com (Diego Silva) — Sat, 15 Jan 2011 18:47:00 PST

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

RESTful parte 3: Manejando colecciones de objetos y objetos complejos

noreply@blogger.com (Diego Silva) — Tue, 04 Jan 2011 16:52:00 PST

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

noreply@blogger.com (Diego Silva) — Thu, 09 Dec 2010 08:05:00 PST

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

noreply@blogger.com (Diego Silva) — Thu, 25 Nov 2010 02:15:00 PST

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

noreply@blogger.com (Diego Silva) — Mon, 15 Nov 2010 21:00:00 PST

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!!

RESTful... la forma más ligera de hacer WebServices (Parte 1)

noreply@blogger.com (Diego Silva) — Wed, 03 Nov 2010 15:29:00 PDT

Quienes hayan usado SOAP para WebService, sabrán que es bien fácil de diseñar, pero algo complicado de consumir: se necesita toda una API para construir los clientes utilizando el WSDL. Por ejemplo, para PHP se necesita de la biblioteca NuSOAP. Entonces, para lograr el concepto de "lenguaje único XML" es un dolor de cabeza. Y más aún si el cliente es tan simple como JavaScript, manejar XML de SOAP provocaría suicidos masivos... o no usar WebServices.

Además, con SOAP se permite crear un solo servicio y ponerle varios métodos. Esto puede llevar a un mal diseño del servicio ya que podría tener un servicio que haga de todo: por ejemplo, un servicio de manejo de Clientes que permita también manejar Proveedores.

RESTful es una propuesta muy interesante de Roy Fielding que permite manejar los servicios web con métodos definidos, manteniendo la simpleza del protocolo como XML, pero que cada servicio sea identificado únicamente con un solo URI.

En este post veremos cómo crear un Servicio RESTful usando NetBeans, y haremos crecer de poco a poco nuestro ejemplo... desde hacer operaciones sencillas, hasta manejar estructuras complejas.

Cabe destacar que los servicios de las redes sociales como Flickr, Twitter, Facebook, etc son basados en RESTful.

Para este ejemplo usaremos NetBeans 6.9.1, y GlassFish v3.0.1, ya que usaremos las características de Java EE6. Con GlassFish v.2 igual funciona, y NetBeans ayuda en ello,

Para comenzar, debemos entender que necesitamos de una clase para manejar un servicio. En esta clase solo pueden haber máximo cuatro métodos públicos que son ejecutados por los cuatro métodos HTTP disponibles para RESTful:

GET
POST
DELETE
PUT

Los métodos GET y POST son conocidos en los formularios (<form method="post" />) ¿Tienen algo que ver? Sí, y lo veremos poco a poco. Cada uno de estos métodos determina la acción que hará el REST sobre nuestra aplicación. No deben haber más de un GET o POST o DELETE o PUT, solo tiene que haber uno de cada método. Cada uno tiene una tarea especifica:

GET: Para obtener un valor. Puede ser un listado de objetos
POST: Para guardar un nuevo objeto (instancia de identidada) en la aplicación
DELETE: Para eliminar un objeto (instancia de identidad)
PUT: Para actualizar un objeto.

¿Suena a un mantenimiento CRUD? Sí, exacto. Eso es lo que es: los métodos para hacer mantenimiento a una entidad de la aplicación. Entonces, la clase que deberá tener estos métodos es como una clases EJB Facade de una aplicación Java EE. Por tanto, esta clase se llamará "Recurso", funcionará como un EJB, solo manejará la persistencia de una etndiad, pero será accedido desde la web. ¿Cómo se hace? Bueno, iremos de poco a poco conociendo cómo hacer un mantenimiento complejo usando únicamente RESTful.

Creando proyecto y configurando REST

Crearemos un proyecto web común y silvestre en NetBeans. Yo crearé uno llamado SimpleRESTweb. Este proyecto hará un simple cálculo de factorial. (Aunque a muchos no les guste, comenzaré siempre con una calculadora ya que es el clásico ejemplo de Entrada->Procesamiento->Salida.. lo demás, usando entidades, bases de datos, etc.. es lo mismo, solo que utiliza más variables)

Luego, crearemos una clase común y silvestre, llamada FactorialResource. Tendrá (por ahora) un método llamado factorial()


public class FactorialResource {

    public long factorial(long base) {
        if (base >= 1) {
            return factorial(base - 1) * base;
        }
        return 1;
    }
}

A esta clase se puede crear su TestCase para asegurarnos que funciona correctamente. Notemos que hasta ahora no hemos hecho nada REST. La diversión comienza aquí:

Agreguemos la notación @Stateless al inicio de la clase. Esto convierte automáticamente a nuestra clase en un EJB

Luego, seguido al @Stateless agregamos la anotación @Path("/factorial") Esto indica que este recurso será accedido desde la ruta "/factorial" via web. Ahora, guardemos el archivo... y en ese mismo momento, el NetBeans detectará de que se ha creado un recurso REST, entonces pedirá activar esta característica en la aplicación... por tanto pedirá dónde estará activado todos los recursos REST.

Utilizaremos el dado por defecto (/resources). Clic en Ok.

Nota: En GlassFish v2 (Java EE 5) solo existirán dos opciones

Y con esto, nuestra clase ya es un recurso REST.

Pero aún este recurso no tiene métodos. Ahora veremos cómo convertir nuestro método convencional en un método REST.

Creando un método REST

Recordemos que solo podemos crear un método de tipo GET,POST,PUT y DELETE. Y como el método factorial nos deberá devolver un solo valor según el parámetro que le especificamos, usaremos el tipo GET.

Para ello agregamos la anotación @GET antes del método.

Y con esto, nuestro recurso ya tiene un método.

Antes de continuar, los valores que se reciben desde el recurso REST deben ser objetos. Por tanto, nuestro método debe cambiar un poco para que no devuelva un long, sino un java.lang.String.

Además, debemos indicar que el parámetro base del método Java factorial será recibido via URL con el nombre base. Es decir, se llamará al URL así

..../factorial?base=5

Para ello usaremos la notación @QueryParam antes de la declaración del parámetro y ponemos el nombre de la cadena query.


@Stateless
@Path("/factorial")
public class FactorialResource {

    @GET
    public String factorial(@QueryParam("base") long base) {

        return Long.toString($factorial(base));
    }

    long $factorial(long base) {
        if (base >= 1) {
            return $factorial(base - 1) * base;
        }
        return 1;
    }
}

El nombre del parámetro de la cadena query podría ser diferente al del método java.


//....
    @GET
    public String factorial(@QueryParam("numero") long base) {
//....

Pero si se hace eso, se debería recordar que para accederlo via URL debe ser con ese mismo nombre

..../factorial?numero=5

Pero para evitar problemas, usaremos el mismo nombre. Y en caso de ser necesario, podemos cambiar el nombre. Eso ya queda a criterio del diseñador de la aplicación.

Probando la aplicación

Pues bien, ahora guardemos el proyecto, hagamos clic derecho sobre el ícono de proyecto y seleccionamos "Deploy". Esperamos a que se compile el proyecto, se ejecute el GlassFish y se despliegue.

Aquí propondré tres maneras de probar el recurso REST. El primero es el más fácil, usando el URL. Bastará con abrir nuestro navegador y escribir el URL del proyecto:

http://localhost:8080/SimpleRESTweb/resources/factorial?base=10

Este URL está compuesto de lo siguiente:

SimpleRESTweb: El contexto de la aplicación. Que generalmente es el nombre del proyecto.
resources: Ubicación de los recursos REST de la aplicación. Este nombre nos lo pidió el NetBeans cuando guardamos la clase Java por primera vez con la notación @Path ya que detectó que tenía recursos REST. Si se desea cambiar esta ruta, hagamos clic derecho en el nodo "RESTful Web Services" del proyecto y seleccionando "REST Resources Configuration"
factorial: Es el nombre de nuestro recurso (Definido por la anotación @Path)
base: Es el parámetro del recurso. Justamente es una cadena Query.

El resultado debe mostrarse tan simple como una web sin formato ni nada

Y ese es el resultado. Quizás me digan "hey, pero esto también lo puedo hacer con un servlet". Pues sí, pero no es lo mismo, ya que el Servlet puede guardar variables de sesión, y aquí en REST no... en Servlet se puede formatear en un HTML, pero aquí en REST no, porque lo que debe devolver es solo dato.

La segunda manera que muestro cómo probar este recurso REST es usando un formulario HTML. Escribamos lo siguiente en el index.jsp


 <body>
        <h1>Calculando factorial</h1>
        <form action="resources/factorial">
            Base: <input name="base" type="text" />
            <button>Calcular</button>
        </form>
    </body>

El resultado saldrá en otra página.

Y la tercera forma (que es la más profesional) es usando el NetBeans.

Hacemos clic derecho sobre el ícono del proyecto y seleccionamos "Test RESTful WebService".

Con esto, el IDE creará una página local que accederá al WADL de la aplicación y se mostrará en el navegador web.

El WADL es análogo al WSDL de SOAP

Luego, podemos seleccionar del panel izquierdo el recurso que está disponible (en este caso "factorial")...

... y vemos que nos muestra cuales son los parámetros (solo base) que están disponibles para este recurso. Probamos escribiendo valores en el parámetro, y hacemos clic en "Test".

Consumiendo REST

Todo servicio web no es útil si no se sabe cómo consumir. En este post mostraremos cómo consumir este simple REST. En los siguientes post realizaremos recursos que utilizan objetos complejos.

Usando JavaScript

Para consumir desde JavaScript, se debería utilizar la técnica AJAX. Y en vez de hacer toda la biblioteca de consumir AJAX con JavaScript, mejor usamos algo ya hecho... como el jQuery.

Crearemos una página html al que llamaremos test-jquery.html. Y ahí pondremos lo siguiente.


<html>
    <head>
        <title></title>
        <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js">
        </script>

        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    </head>
    <body>
        <h2>Calcular factorial</h2>
        Número:<input type="text" name="base" id="base"/>
        <button type="button" id="calcularBtn">Calcular</button>
        <div id="resultado">
            Resultado: <span></span>
        </div>
        <script type="text/javascript">
            jQuery("#calcularBtn").click(function(){
                var base = jQuery("#base").val();
                jQuery.get("http://localhost:8080/SimpleRESTweb/resources/factorial",{
                    base:base
                },function(resultado){
                    jQuery("#resultado span").text(resultado)
                })
            })
        </script>
    </body>
</html>

Esta HTML funciona desde Firefox cuando se ejecuta desde el NetBeans,

y funciona en IExplorer si se ejecuta localmente (o sea, abriéndolo desde el explorador de archivos y activar el filtro de ActiveX que advierte el IE).

Usando Java

Con NetBeans más el complemento Jersey, se nos hace muy fácil consumir servicios REST. Para integrarlo con el IDE, necesitamos registrar el WADL. Esta URL lo podemos obtener así: http://host:puerto/contexto-web/resources/application.wadl

Para nuestro ejemplo, este es

http://localhost:8080/SimpleRESTweb/resources/application.wadl

Podemos abrirlo desde el navegador y se nos mostrará un XML que contiene la definición de los recursos (/factorial) y los parámetros de cada método. En este caso hay un método GET y tiene como parámetro un long.

Ahora bien, este URL del WADL lo vamos a necesitar para registrarlo en el NetBeans. En el IDE vayamos al panel de servicios (Ctrl+5) y hacemos clic derecho sobre el nodo "Web Services" y seleccionamos "Add Web Service..."

Luego, en la entrada de URL, pegamos la dirección del WADL. Y como nombre de paquete ponemos simplerest.

Y listo, ya tendremos registrado el WebService en nuestro IDE.

Esto nos permitirá utilizar este servicio en cualquiera de nuestras aplicaciones. Por ejemplo, ahora, en Java.

Hagamos un nuevo proyecto llamado SimpleRESTClientJavaApp.

Ahora, crearemos un nuevo archivo (Ctrl+N) y seleccionamos la categoría "Web Services" y el tipo de archivo "RESTful Java Client"

Luego, en el siguiente paso, pongamos como nombre de la clase FactorialClient, dentro de la opción "Select the REST resource" seleccionemos la opción "IDE Registered"

... y hagamos clic en "Browse" para seleccionar el WebService que acabamos de registrar.

y clic en "Finish". Listo, el IDE nos creará la clase FactorialClient que contendrá los recursos necesarios para acceder al servicio REST.

Ahora, ¿cómo se consume esto?... en nuestra clase Java solo debemos instanciar la clase, pasarle el parámetro y recibir el valor. Fácil


        FactorialClient client = new FactorialClient();
        long base = 15;
        String resultado = client.factorial(String.class, String.valueOf(base));
        System.out.println("Resultado: " + resultado);

Código fuente

El ejemplo del servidor REST se encuentra aquí
http://kenai.com/projects/apuntes/downloads/download/Simple%2520RESTful%252FSimpleRESTweb.tar.gz

y el ejemplo de cliente REST en Java se puede descargar de aquí

http://kenai.com/projects/apuntes/downloads/download/Simple%2520RESTful%252FSimpleRESTClientJavaApp.tar.gz

Preparando capacitación virtual en NetBeans Platform

noreply@blogger.com (Diego Silva) — Wed, 27 Oct 2010 10:07:00 PDT

A Geertjan Wielenga (considerado como el maestro de NetBeans Platform) le he propuesto hacer un entrenamiento virtual sobre NetBeans Platform para Latinoamerica. Le agradó la idea, y me dice que reuna al menos a cinco o seis participantes.

NetBeans Platform es una plataforma completa que permite desarrollar aplicaciones desktop (swing) proporcionándonos varias funcionalidades "rutinarias" que se necesitan al momento de hacer una aplicación swing, tales como manejo de ventanas, árboles, ventanas de diálogos, opciones, manejo de archivos, etc. También se pueden desarrollar complementos que permitan ampliar la funcionalidad del mismo NetBeans IDE. Para tener una idea de lo que se puede hacer: NetBeans IDE y iReport están hechos sobre NetBeans Platform.

¿Quienes se apuntan para este entrenamiento? Si estás interesado, llena tus datos aquí :

<p>&amp;amp;amp;lt;p&amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;lt;p&amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;p&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;p&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;p&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;Loading...&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/p&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/p&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/p&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;lt;/p&amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;lt;/p&amp;amp;amp;gt;</p>

Swing: Componentes enlazados a un bean

noreply@blogger.com (Diego Silva) — Mon, 25 Oct 2010 22:00:00 PDT

La mejor manera de tener sincronizado un control swing con un javabean es utilizando enlaces (binding). La manera común y poco profesional es utilizar los set y gets de cada atributo de un bean para asociar a cada componente.

//...
nombreTF.setValue(persona.getNombre());
edadTF.setValue(persona.getEdad());
//... etc

y si son 80 campos, nadie querra hacerle mantenimiento.

Aquí es donde entran los enlaces. Mostraremos un ejemplo con NetBeans para enlazar los componentes de un formulario con un JavaBean.

Este tip es aporte de Fernando Rodelo Mármol, seguidor de este blog, y amigo.

Creando el JavaBean

Primero debemos crear una clase Java. La llamaremos Persona.

Luego, crearemos tres propiedades llamadas nombre, edad y sexo. Pero lo haremos utilizando NetBeans de la siguiente manera.

Clic derecho sobre el código del editor, justo dentro de la clase Persona y seleccionar "Insert code"
Seleccionar "Add property".
Con esto se mostrará un editor para crear una nueva propiedad, al cual haremos los siguientes cambios
- En el campo name escribimos el nombre de la nueva propiedad: nombre
- En el campo type indicamos el tipo de la propiedad: String
- Activamos la opción "Bound". En ese momento se mostrará el campo la declaración de una constante llamada PROP_NOMBRE con el valor "nombre". Esto es para asociar la variable "nombre" con el escuchador (listener) del JavaBean.
Clic en "ok" para aceptar esta propiedad. Repetir la misma operación con los demás campos.

Para el caso de la propiedad "sexo", consideremos utilizar dos propiedades de tipo boolean llamadas "hombre" y "mujer".

Veamos el código generado. De no existir el IDE, deberiamos escribir todo el código. Bastante ¿no?

Enlazando JavaBean con formulario swing

Ahora que ya tenemos el JavaBean con su respectivo manejador de cambios de propiedades, debemos crear en el formulario swing una propiedad de tipo Persona. Además, esta propiedad debe tener sus respectivos get/set.

En el panel de diseño del formulario vamos a enlazar cada control con cada propiedad de la propiedad persona.

Hacemos clic-derecho en el control donde irá el nombre, y seleccionamos "bind > Text" que significa "enlazar el texto del control"

El IDE nos mostrará una ventana de diálogo para configurar el enlace del control. Aquí primero seleccionamos en la opción "Binding Source" de dónde se va a tomar el campo a enlazar. Como hemos declarado nuestra propiedad "persona" dentro del formulario, entonces seleccionamos "Form"

En la parte inferior se mostrará un listado de los componentes del formulario. Buscamos a "persona", abrimos el nodo y seleccionamos (en este caso) la propiedad "nombre".

Hacemos clic en "OK" y repetimos la acción en las demás propiedades.

Es importante recalcar que la propiedad del JavaBean debe tener el mismo tipo del que maneja el control. El tipo de control lo podemos ver en la parte superior de la ventana de diálogo. Por ejemplo, el del JTextField dice "Bind property text (java.lang.String) to:"

Probando guardar el JavaBean

Ahora, cada vez que escribamos algo en los controles, se guardarán directamente en el JavaBean. ¿No me creen? Bueno, hagamos la siguiente prueba: después de escribir los valores, guardemos los valores del JavaBean en un archivo XML.

Para ello, programaremos el siguiente código en el botón "Guardar".


XMLEncoder encoder = new XMLEncoder(
                         new BufferedOutputStream(
                             new FileOutputStream(ARCHIVO_XML)));
encoder.writeObject(persona);
encoder.close();

Donde la variable ARCHIVO_XML es un String que contiene el nombre del archivo a guardar.

Ahora, hagamos la prueba: llenemos el formulario, y hagamos clic en Guardar.

Y veamos el archivo XML que guardó.

Usé el XMLEncoder para evitar todo un manejo de base de datos para este ejemplo.

Probando mostrar controles actualizados

Me dirán "ok Diego, ya sé que el bean está asociado a los controles.. escribo en el control y lo guarda en el JavaBean.. hice hasta un debug y me funciona.. pero si modifico el JavaBean ¿cómo refresco el contenido de los controles? "

Bueno, esto es automático. Basta que se haga un cambio en el JavaBean Persona, los controles se actualizan automáticamente.

Hagamos esta prueba: en el botón "Nuevo" escribimos el siguiente código:


persona.setNombre("");
persona.setEdad(0);
persona.setMujer(false);
persona.setHombre(false);
buttonGroup1.clearSelection();

Funciona...!!

Nota: no intentar hacer

persona=new Persona();

porque se crearía otro objeto y el enlace con el control se pierde. Entonces, si hay 80 campos ¿tengo que hacer esto por todos los campos? Uhmm.... sí.

Cuando usamos enlaces (bindings) debemos considerar que el formulario tiene un objeto JavaBean asociado al mismo formulario... es como el "alma" del formulario.... funciona como el "objeto actual" del formulario. Lo que podemos hacer es usar una variable temporal para copiar sus valores al JavaBean del formulario. Así manejamos el temporal, creamos, alteramos etc.. pero solo le damos una copia de este temporal al JavaBean.

Cargando el JavaBean guardado

Volviendo a nuestro ejemplo.. si ya hemos guardado el JavaBean en un XML, hemos cerrado y volvemos a ejecutar el formulario... y ahora queremos cargar lo que hemos guardado ¿qué hacemos? Bueno, usamos el XMLDecoder, cargamos el valor en un objeto temporal y copiamos los valores al JavaBean persona.

"Pero Diego.. ¿si son 80 campos?" Ok ok.. vamos a valernos de una biblioteca de Apache Commons para copiar las propiedades de un objeto a otro. Esta biblioteca se llama BeanUtils y el método se llama BeanUtils.copyProperties().


XMLDecoder decoder = new XMLDecoder(
                         new BufferedInputStream(
                             new FileInputStream(ARCHIVO_XML)));
Persona $persona = (Persona) decoder.readObject();
decoder.close();
BeanUtils.copyProperties(persona, $persona);

Ahora sí.. ya funciona....

¿Y para el botón "Nuevo"?.. lo mismo, solo que no cargaremos un XML, sino copiaremos las propiedades de un objeto nuevo.


Persona $persona = new Persona();
BeanUtils.copyProperties(persona, $persona);
buttonGroup1.clearSelection();

Proyecto de ejemplo

Y no iba a faltar el proyecto utilizado en este post.

http://kenai.com/projects/apuntes/downloads/download/ejemplos%252Fswing%252FSwingListenerApp.tar.gz

Espero que les sea de utilidad.

Compilando y ejecutando una clase java.... desde java

noreply@blogger.com (Diego Silva) — Mon, 18 Oct 2010 22:00:00 PDT

El JDK 6 viene con varias funcionalidades interesantes, entre ellas la compilación de clases java desde el mismo java.

La instancia que se encarga de tal tarea es JavaCompiler pero su instancia se obtiene desde el método ToolProvider.getSystemJavaCompiler().

La compilación se resume a una simple instrucción:

JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
int resultado = javaCompiler.run(null, null, null, "Factorial.java");

Hay más opciones de compilación, como por ejemplo obtener los errores de compilación, y compilación en memoria. Para más opciones de la clase, revisar el API de javax.tools.JavaCompiler.

Ahora bien, ¿cómo se puede ejecutar una clase compilada? Pues se necesita cargarlo en la memoria del JVM. Fácil.... pero el reto es hacerlo en ejecución, ya que si no está en el classpath de la aplicación nunca se podrá ejecutar. Y como sabía que alguien me haría esta pregunta, hice aquí un ejemplo de ello: compilar y luego ejecutar el compilado.

Lo que hice fue redefinir el método loadClass() de la clase java.lang.ClassLoader, cargarlo en bytes el archivo binario .class y luego convertirlo en una clase java.

Aquí les dejo el ejemplo para que se diviertan un rato.

Código ejemplo
http://kenai.com/projects/apuntes/downloads/download/ejemplos%252Fjdk%252FCompilandoJava.tar.gz

CouchDB, base de datos orientada a documentos

noreply@blogger.com (Diego Silva) — Fri, 15 Oct 2010 12:54:00 PDT

Desde Panamá, nuestro amigo Arístides Villareal, ha publicado algunos post referente a esta base de datos orientada a documentos llamada CouchDB.

CouchDB proporciona un API JSon para que puede ser accdido desde cualquier entorno, incluyendo peticiones HTTP. Fue escribo en Erlang, un lenguaje de programación funcional ideal para sistemas distribuidos concurrentes.

EJB 3.1 en Porlets de Liferay

noreply@blogger.com (Diego Silva) — Mon, 11 Oct 2010 22:00:00 PDT

Ya que GlassFish v3 es compatible con Java EE6, y permite módulos web con componentes EJB (por la característica propia de EJB 3.1).. y además Liferay puede ser instalado sobre GlassFish v3... y... los portlets son módulos web con otro archivo de despligue ¿los portlets para Liferay/GFv3 deberían permitir EJB 3.1?

Pues la respuesta es sencilla: Sí. Pero cuando uno desarrolla un portlet con EJB 3.1 y lo trata de desplegar sobre Lfieray 6.0, no funciona. Por alguna razón no despliega correctamente la aplicación, lanza errores de clases de SpringFramework faltantes, etc. Lo curioso es que si se despliega sobre Liferay 5, sí funciona correctamente. Entonces ¿qué pasa?. Pues bien, leyendo un poco los mensajes de error y después de varias pruebas.. pude dar con la solución.

Para comenzar, el error que lanza es el siguiente:

Error in annotation processing: java.lang.NoClassDefFoundError: org/springframework/transaction/PlatformTransactionManager

Pero si examinamos la carpeta lib del módulo de liferay, sí están las bibliotecas de Spring.

La solución a este problema es el siguiente: debemos copiar ciertas bibliotecas de Spring a la carpeta lib del dominio donde está instalado el Liferay. Para evitar conflictos de versión del Spring, copiemos los siguientes archivos .jar del .war de Liferay a $GLASSFISH_HOME/domains/domain1/lib.

aopalliance.jar
aspectj-rt.jar
aspectj-weaver.jar
commons-logging.jar
spring-aop.jar
spring-asm.jar
spring-beans.jar
spring-context.jar
spring-core.jar
spring-expression.jar
spring-transaction.jar

Ahora sí, podemos desplegar portlets que contienen EJB con total normalidad.

Pero! (no tan rápido), como las clases portlets (descendientes de javax.portlet.GenericPortlet) no son parte del estándar de un módulo web, entonces no podrá utilizarse un EJB con la notación @EJB (lo que sí funciona en un Servlet). Entonces ¿cómo instanciar EJB?:

Pues habrá que utilizar el JNDI dentro del módulo, de la siguiente manera:


Context c = new InitialContext();
EjbFacade facade= c.lookup("java:global/NombrePorlet/NombreEjbFacade!paquete.ejb.NombreEjbFacade");

Algo más explicado sobre cómo acceder a las clases EJB 3.1 se encuentra en este post: Cliente remoto de EJB 3.1

Espero que les sea de utilidad.

Liferay: Recursos necesarios

noreply@blogger.com (Diego Silva) — Fri, 08 Oct 2010 10:22:00 PDT

Para poner en producción un servidor web con Liferay, en base a la experiencia, sugiero lo siguiente:

Memoria: 2GB. Recomendable: 4GB
CPU: 2 Core. Recomendable 4
Arquitectura: 32bits, Recomendable 64 bits.

¿Por qué tanto? Recordemos que este Liferay es para portales serios, para una empresa u organización seria. Si quieren algo más simple, y más barato, usen Joomla o algo parecido.

Otro post más sobre Liferay y hago mi blog "Apuntes de Liferay" :). También hablaré de otros contenedores de portlets, por si liferay parece muy costoso poner en producción.

NetBeans 7.0

noreply@blogger.com (Diego Silva) — Thu, 07 Oct 2010 11:51:00 PDT

La versión NetBeans 6.10 cambia de numeración para ser la 7.0.
Será lanzada en marzo de 2011 y tendrá importantes cambios. Ojo a la nota:

Será compatible con el JDK 7 (beta). Cuando esté terminado el JDK 7, habrá un parche para NB 7.0 que permitirá ser compatible 100% con JDK 7 (o, me imagino, saldrá NB 7.1)
No se seguirá dando soporte al Lenguaje JavaFX. Por tanto, no se podrá crear proyectos JavaFX en NB 7.0.
Tendrá compatibilidad con GlassFish 3.1, WebLogic, Maven 3 y Oracle DB (no sé si MySQL aún seguirá siendo parte de NB)

Más características del futuro NetBeans 7.0 aquí: http://wiki.netbeans.org/NewAndNoteworthyNB70

Liferay: Registrando varios usuarios (usando complemento Hook)

noreply@blogger.com (Diego Silva) — Tue, 21 Sep 2010 23:51:00 PDT

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!

mysqldump: ignorando el tag DEFINER

noreply@blogger.com (Diego Silva) — Thu, 16 Sep 2010 15:16:00 PDT

Este es otro no-apunte-de-java. Se trata del MySQL.
Resulta que he tratado de hacer un dump de un servidor a otro. Pero como tienen usuarios restringidos por host, y el mysqldump me genera el script con el tag


/*!50013 DEFINER=`root`@`10.%` SQL SECURITY DEFINER */

... pensé que debería haber algún parámetro de mysqldump para ignorar estos tags. Pero según el mismo MySQL dicen que tendría problemas de seguridad (vamos: darle derechos de pasar un VIEW o STORED PROCEDURE a alguien que no le corresponde).

Así que tuve que valerme de un comando de unix/linux para ignorar estos tag:

Este comando es el famoso grep.

Y aquí está mi mysqldump modificado:


mysqldump -u root -p -B  db100 | grep -v 'DEFINER' > dump.sql

Espero que les sea de utilidad.

Enmulando EJB en Web usando Spring

noreply@blogger.com (Diego Silva) — Tue, 14 Sep 2010 08:33:00 PDT

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

Apuntes de Java

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

AOP con Java EE 6

Premios Open Source 2011

Libro: Java EE 6 Development with NetBeans 7

Probando RESTful con Poster

Ejecutando Poster

Create

Read

Update

Delete

Cambiando el objeto resultado

Recursos

Contraseñas encriptadas con Java

Commons Codec

MD5

SHA-HEX

SHA-256 / 512

Upload en JSF 2.0

Código fuente

Driver de Oracle dentro de NetBeans 7.0

JComboBox de Objetos

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

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

Reemplazar objeto y borrar objeto de la colección

Código fuente del proyecto

RESTful parte 3: Manejando colecciones de objetos y objetos complejos

Manejo de colecciones

Guardando objetos en la colección

Obteniendo objetos en la colección

Objetos complejos

El código fuente

Delay

RESTful - Parte 2: Manejando un solo objeto

Manos a la obra...

Creando un javaBean

Creando recurso manejador de Persona

Leer valor del objeto

Guardar valor al objeto

Modificando el tipo de formato para leer el objeto

Modificando la estructura de los datos

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

Código del proyecto

Lo que se viene con JDK 7 & NetBeans 7

Descargando e instalando JDK 7

Descargando e instalando NetBeans 7.0

Características nuevas de JDK 7 en NetBeans 7.0

switch con cadenas

Operador "diamante": anulando Genericos redundantes

Multicatch

RESTful... la forma más ligera de hacer WebServices (Parte 1)

Creando proyecto y configurando REST

Creando un método REST

Probando la aplicación

Consumiendo REST

Usando JavaScript

Usando Java

Código fuente

Preparando capacitación virtual en NetBeans Platform

Swing: Componentes enlazados a un bean

Creando el JavaBean

Enlazando JavaBean con formulario swing

Probando guardar el JavaBean

Probando mostrar controles actualizados

Cargando el JavaBean guardado

Proyecto de ejemplo

Compilando y ejecutando una clase java.... desde java

CouchDB, base de datos orientada a documentos

EJB 3.1 en Porlets de Liferay

Liferay: Recursos necesarios

NetBeans 7.0

Liferay: Registrando varios usuarios (usando complemento Hook)

Requisitos

Creando el proyecto Hook

Creando el complemento Hook

Registrando los usuarios

Ejecutando el proyecto

Desplegando en servidor de producción

Código fuente

mysqldump: ignorando el tag DEFINER

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

`switch` con cadenas