Guadalajara JUG adopta tres JSRs

En agosto de este año, durante una de las sesiones mensuales de Guadalajara JUG se dió una charla sobre lo que es el programa Adopta un JSR y los beneficios que otorga a un JUG que se adhiere al programa. Como resultado la comunidad decidió entrar al programa. Con base en esto, se creó una lista de distribución exclusiva para el tema de adoptar un JSR.
A los miembros de la lista se les envió una encuesta para saber que JSRs adopta. Estaban listados todos los JSRs activos al momento y enseguida cuatro opciones:

1. No me interesa adoptar este JSR
2. No conozco el JSR pero no me gustaría adoptarlo
3. No conozco el JSR aunque sí me gustaría adoptarlo
4. Si me gustaría adoptar este JSR

La razón para no poner una respuesta binaria es que era muy probable que los miembros no conocieramos todos los JSRs (Cuarenta y dos en total de JSRs activos), pero quizá si se tuviera la intención de adoptarlo y precisamente conocerlo mejor.

Los resultados de la encuesta aquí:

Los Tres JSRs que obtuvieron más votos por el SI son (resaltados en amarillo en la imagen):

1. JSR 310: Date and Time API
2. JSR 339: JAX-RS 2.0: The Java API for RESTful Web Services
3. JSR 346: Contexts and Dependency Injection for Java EE 1.1

Resalté en azul en la imagen dos JSRs más que reflejan también la intención de adoptarlos aunque no se conozca mucho de ellos: JSR 206: Java API for XML Processing (JAXP) 1.3 y JSR 351: Java Identity API. En un futuro se podrían adoptar estos dos más.

La impresión que tengo en base a los resultados es que como programadores buscamos meternos a fondo con tecnologías muy usadas o con perspectivas a usarse cada vez más, como son JAX-RS y CDI. Y ni que decirse de un API de fechas y tiempo que es el pan de cada día de los programadores.

Pues ahí los resultados. Ahora vienen actividades muy interesantes para conocer más a fondo practicando estos tres JSRs, estén al pendiente en http://www.meetup.com/gdljug/.

Construyendo una aplicación desktop cliente con JavaFX 2.0 y Java EE 7

Ya hay un tutorial disponible en la Oracle Learning Library donde se muestra el uso de dos APIs nuevas en Java EE 7, además de la tecnología JavaFX.

Java Enterprise Edition (EE) 7 incluye dos nuevas APIs: la Java API para procesamiento JSON y un cliente de RESTful web services (JAX-RS). Estas dos APIs vienen incluidas en los servidores de aplicaciones que sean compatibles con la especificación de Java EE 7.
Sin embargo en la aplicación desarrollada en este tutorial, estas nuevas APIs de Java EE 7 son utilizadas por una aplicación standalone JavaFX 2.0. La Java API para procesamiento JSON se utiliza para procesar la información obtenida de un servicio web RESTful y el cliente de JAX-RS 2.0 para hacer las llamadas al servicio web.

El tutorial se encuentra aquí en su versión en Inglés.
En él se muestra cómo construir paso a paso una aplicación de listado de clientes, además de búsqueda por nombre:

En el tutorial se muestra además, el cómo levantar un servicio web RESTful que accese a una BD.

Happy JavaFX y JavaEE7 coding!

Java Day Guadalajara 2013

Java Day Guadalajara 2013

Habrá un evento de la comunidad Java en Guadalajara, México. Será el Sábado 27 de Julio. Para mayor información está la siguiente página web: http://www.gdljug.mx/ .

Habrá dos conferencias, por Bruno Borges y Jorge Vargas. Además de cuatro talleres, donde se podrán practicar los nuevos APIs de Java EE 7: WebSocket, JSON Processing, JAX -RS 2 o JMS 2.0; así como HTML5 y  JSF 2.2. Habrá más talleres para practicar la migración de una aplicación existente de Java EE 4/5 a Java EE 6/7. O cómo construir una aplicación empresarial de escritorio con Java FX y Java EE 6/7. El último taller será de expresiones Lambdas en Java SE 8, desarrollando casos prácticos.

Java EE 7 - Embracing HTML5

En la última edición de la Oracle Java Magazine de Mayo/Junio tuve la oportunidad de escribir en coautoría sobre uno de los temas que más llaman la atención de los programadores actualmente con el lanzamiento de Java EE 7, que es el cómo Java EE 7 soporta e integra a HTML5.
En el artículo, y en base al desarrollo de una aplicación llamada "Sticker Story" - en la cual los niños crean historias colaborativamente arrastrando "stickers" hacia el canvas al mismo tiempo que los otros niños lo hacen también - se muestran las nuevas características de JSF 2.2 para el soporte de HTML5, así como el uso de WebSocket y JSON Processing (JSON-P), APIs nuevos en Java EE 7.
Te invito a leer la revista y el artículo. La aplicación Sticker Story está disponible para bajarla en el artículo.
Happy Coding!

Construyendo un flujo con Faces Flows en JSF 2.2, Java EE 7

Dentro de lo nuevo que trae JSF 2.2 en Java EE 7, es poder encapsular conjuntos de páginas de nuestra aplicación web en flujos.Los flujos los podemos encontrar en procesos que requieren que sigamos paso a paso un proceso hasta finalizarlo. Un ejemplo es el flujo de un Checkout, cuando compramos algo: Después de seleccionar los artículos procedemos a, por ejemplo:

1. Introducir los datos de la tarjeta de crédito
2. Introducir datos de a dónde se va a enviar el o los artículos
3. Confirmar los datos del pedido

Este flujo es un ejemplo, siempre se puede optimizar un flujo (solo basta con leer este blog sobre cómo se mejoró la experiencia de usuario en un proceso de compra).

Otro flujo relacionado al Checkout en el proceso de compra es el seleccionar los productos a comprar e irlos agregando al carrito de compra: Seleccionar productos, Ver detalles, agregarlo al carrito y así hasta proceder al Checkout.

Una de las ventajas de encapsular los flujos es que se pueden reusar. Faces Flows te permite empaquetar los flujos en JARs y reutilizarlos al colocar el JAR debajo de WEB-INF/classes, por ejemplo.

Construyendo un Flujo Básico con Faces Flows

En este ejemplo utilizo NetBeans para Java EE 7, que puede obtenerse aqui. Además de Glassfish 4.0 b86, que puede obtenerse aquí. Recordemos que tanto Glassfish 4 como NetBeans para Java EE 7 están aún en desarrollo.

1. Registrar Glassfish 4 en NetBeans.
2. Abrir un nuevo proyecto de Aplicación Web: File->New Project -> Java Web -> Web Application
3. Dar el nombre que querramos al proyecto -> Next -> Seleccionar JavaServer Faces como el framework que queremos usar -> Finish
4. Reemplazar el contenido dentro de <h:body> en index.xhtml con lo siguiente:
    <h:form prependId="false">
     <p><h:commandButton id="start" value="Entrar al flujo A"   
        action="flowA" /></p>
    </h:form>
5. Crea una nueva carpeta debajo de Web Pages llamada FlowA. Por convención sobre configuración el nombre de la carpeta es el identificador del flujo.
6. Crea un nuevo archivo JSF: Clic derecho sobre la carpeta FlowA -> New JSF Page -> File Name = flowA -> Finish.
7. Esta será nuestra primer página en el flujo. Reemplaza el actual contenido dentro de <h:body> en el archivo recién creado con el siguiente:
<h:form prependId="false">
      <p>Primer pagina del flujo</p>
      <p><h:commandButton id="next_a2" value="Siguiente                                       pagina" action="flowA2" /></p>      
</h:form>


8. Ahora creamos la segunda página del flujo. Clic derecho sobre la carpeta FlowA -> New JSF Page -> File Name = flowA2 -> Finish.
9. Reemplaza el actual contenido dentro de <h:body> en el archivo recién creado con el siguiente:
      <h:form prependId="false">
        <p>Segunda pagina en el flujo</p>
        
        <p>value: <h:inputText id="input" value="#    
           {flowScope.value}" /></p>
        
        <p><h:commandButton id="back" value="back" 
           action="flowA" /></p>
        <p><h:commandButton id="next_a3" value="next" 
            action="flowA3" /></p>
      </h:form>


En esta segunda página de nuestro flujo resalta flowScope, que es un mapa <key, 
value> y estará accesible durante todo el ciclo de vida del flujo. En esta página a un  
inputText se le asocia el key flowScope.value, para, en la siguiente página,    
acceder a este valor.


10. Ahora creamos la tercera y última página del flujo. Clic derecho sobre la carpeta FlowA -> New JSF Page -> File Name = flowA3 -> Finish.
11. Reemplaza el actual contenido dentro de <h:body> en el archivo recién creado con el siguiente:
          <p>Ultima pagina en el flujo</p>
    <p>FlowBean name: #{flowBean.name}</p>
        
    <p>value: #{flowScope.value}</p>
        
    <h:form prependId="false">
          <p><h:commandButton id="back_a2" value="back" 
              action="flowA2" /></p>
          <p><h:commandButton id="return" value="return" 
              action="taskReturn1" /></p>
    </h:form>

En esta página se hace uso de otro recurso en Faces Flows que es el bean que estará disponible durante la vida del flujo, una vez que se sale del flujo, los valores del bean se resetean.
En esta última página ya sólo le ofrecemos al usuario el ir hacia la página anterior o ir hacia afuera del flujo. La página fuera del flujo se construirá a continuación.


12. Clic derecho sobre la carpeta Web Pages -> New JSF Page -> File Name = return1 -> Finish.
13. Reemplaza el actual contenido dentro de <h:body> en el archivo recién creado con el siguiente:
         <h1>Pagina fuera de flowA</h1>
    <h:form prependId="false">
      <p>flowScope value, es vacio: #{flowScope.value}</p>
      <h:commandButton id="index" value="Home Page" 
                            action="/index" />
    </h:form>
        
 En esta página fuera del flujo tan sólo imprimimos el valor de flowScope.value, para asegurarnos de que el valor es vacío una vez que se está fuera del flujo.
Le damos tambien opción al usuario de ir a Home, para iniciar nuevamente el flujo.

El FlowBean


14. Resta construir el bean que va a almacenar valores durante la vida del flujo. Clic derecho sobre la carpeta Source Packages  ->  New JSF Managed Bean  -> Class Name = FlowBean  -> Scope = flow   ->  Package = org.example.blog.flows -> Finish
15. Una vez creado el Managed Bean, dentro de la anotación @FlowScoped, que es una nueva anotación introducida en Faces Flows, darle el nombre de flowA, (f minúscula), que quiere decir que este bean va a persistir durante el tiempo de vida del flujo flowA.
16. Agregar los siguientes dos métodos a este bean:
             public String getName() {
       return "FlowBasico";
     }
   
     public String getReturnValue() {
       return "/return1";
     }


 getName() tan sólo regresa el nombre del bean. Y el segundo método se utilizará al crear el  
 archivo de configuración XML del flujo (también puede crearse via Anotaciones), que a 
 continuación se muestra.

El Archivo de Configuración del Flujo


17. Clic derecho en el proyecto -> JSF Faces Configuration -> File Name = flowA-flow -> Finish.
 Nota: El nombre del archivo de configuración, por convención, es <nombre del flujo>-flow.

18. Arrastre el archivo creado bajo WEB-INF hacia debajo de la carpeta flowA.
19. Dentro del tag faces-config, en el archivo de configuración, agregar lo siguiente:
      <flow-definition id="flowA">
     <flow-return id="taskReturn1">
       <from-outcome>#{flowBean.returnValue}</from-outcome>
      </flow-return>
   </flow-definition>

Lo configurado aquí se referencía en el paso 11.
En este archivo se pueden declarar paso de parámetros entre flujos, así como definir más "nodos", que es como se les llama a los elementos de un flujo en Faces Flows, como switch-call (como un switch en Java), o method-call (como una llamada a una función en Java).
20. Los archivos quedan configurados de esta manera:

    
Finalmente. Click Derecho sobre el proyecto -> Run

JSF 2.2 en Java EE 7: Integración con HTML5

Componente JSF o HTML5?

JavaServer Faces es un framework orientado a componentes. Si necesitas algún componente lo puedes obtener de alguna libreria como MyFaces, ICEFaces, RichFaces o el popular PrimeFaces,

Por otro lado las últimas tecnologías de marcado, como HTML5, proveen funcionalidad a los componentes HTML en el browser sin necesidad de agregar código extra. Un ejemplo son los nuevos controles de HTML5 para calendar, date, time, email, url, etc. Tan sólo agregas el tag correspondiente y el browser sabrá interpretarlo.

Hasta ahora, si sale algun nuevo elemento de HTML se tiene que esperar a que exista algún componente de JSF por parte alguna de las librerías arriba mencionadas y así poder usarlo con el resto de mi código (Facelets, clases Java, Managed Beans, etc).

JSF 2.2 abre una puerta enorme a la integración con los tags que constantemente emergen de marcado con lo que le ha llamado HTML Friendly Markup.
Ed Burns, el spec lead de JSF 2.2 lo detalla muy bien en su artículo aquí.

HTML5 Friendly Markup

Con el friendly markup se hace más fácil la división de roles entre los que diseñan la estructura de la página web -comúnmente los diseñadores web hacen esta parte-, y quienes programan lo lógica de la aplicación web.
Los diseñadores web muy probablemente querrán diseñar su página con tecnologías como HTML5, CSS3, Sin embargo, al momento de integrar la vista o páginas web con la lógica del negocio haya mucho trabajo por hacer, y quizá hasta echar para atrás algunos cambios

Cómo aprovechar las ventajas de HTML5 y JSF?

El concepto básico de HTML5 es el de "dejar pasar" atributos en mi vista o página JSF o HTML5.

Por ejemplo, si se quiere utilizar el tag progress de HTML5 y que se modifique mientras se vayan completando los campos requeridos en una forma:

Lo que se hace es aprovechar los tags de HTML5 input y progress para renderear estos campos. Pero aún hace falta la lógica para ligar estos campos con el progress bar. Aquí entra JSF con el tag <f:ajax> y combinar el código HTML5 con JSF para lograrlo:


<label jsf:for="name">Name</label>
<input jsf:id="name" type="text" jsf:value="#{blogBean.name}">
  <f:ajax execute="@this" render="progress"/>
</input><br/>
<label jsf:for="address">Address</label>
<input jsf:id="address" type="text" jsf:value="#{blogBean.address}">
  <f:ajax execute="@this" render="progress"/>
</input><br/>
<label jsf:for="company">Company</label>
<input jsf:id="company" type="text" jsf:value="#{blogBean.company}">
  <f:ajax execute="@this" render="progress"/>
</input><br/>
<label for="progress">Progress</label>
<progress jsf:id="progress" max="3" value="#{blogBean.progress}" />



En el código, blogBean es tan sólo un bean con getters y setters y una función para incrementar en 1 cuando el campo ya no está vacio:


public String getProgress() {
        int progress = 0;
        if(name != null) {
            progress++;
        }
        if(address != null) {
            progress++;
        }
        if(company != null) {
            progress++;
        }
        return progress + "";
    }



Que hace el prefijo jsf: en un tag HTML5? 

Aqui es donde ocurre el "dejar pasar". Se está ocupando un elemento HTML5 (label,input, progress) y en los atributos con jsf: JSF le está diciendo al browser que "deje pasar" ese atributo a JSF.
jsf: es un nuevo namespace que se declara en la página con:

xmlns:jsf="http://xmlns.jcp.org/jsf"

Este prefijo se utiliza para dejar pasar atributos en HTML para JSF. Pero también hay un prefijo para dejar pasar un atributo HTML en un componente JSF: xmlns:p="http://xmlns.jcp.org/jsf/passthrough".

Este ejemplo fue tan sólo una combinación de HTML5 con JSF gracias a los pass-through elements y attributes en JSF 2.2.

Basta echar un ojo a los nuevos elementos que trae HTML5 para imaginarse cómo sacar provecho de la funcionalidad ya embebida en el browser con el poder de JSF.

Expression Language 3.0 en Java EE 7. Segunda Parte

2.- Expresiones Lambda
     Las expresiones lambda de EL 3.0 son más simples que en JDK 8 pero tendrán compatibilidad entre ambas.
Algunos ejemplos:

${((x,y) -> x + y )(5,9)}  , que imprime 14

${(()->100)()}, que imprime 100

${incrementaEnUno = x->x+1; incrementaEnUno(100)} , que imprime 101

Si deseas conocer a detalle los tipos de expresiones, ve a la sección 1.20 de la especificación.

3.- Operaciones a Colecciones

     Los tipos de coleccones soportados son Set, List y Map.

     Para construir un Set:

     ${{"uno", "dos", "tres"}}

     List:

${["uno", "dos", "tres"]}    , con corchetes en vez de llaves.

     Map:

  ${{"uno": 1, "dos": 2, "tres": 3}} , como en JSON.

    Una vez construida la colección se pueden hacer operaciones sobre ella, y con ayuda de expresiones lambda, como por ejemplo:

${["uno","dos","tres","cuatro"].stream().filter(i -> i != "cuatro").toList()} , 

que regresa ["uno,""dos","tres"]. Nótese que la lista se convierte a stream primero, y después se le aplica la función filter(), y al final el resultado se convierte a lista de nuevo, con la función toList().

El capítulo 2 de la especificación esta dedicado a las colleciones. Hay muchas más operaciones para trabajar con colecciones.

Nota: Los ejemplos de colecciones sólo conseguí correrlos en un JSP, no así en un JSF. En JSF obtuve errores de compilación.

4.- Una API para EL en modo stand-alone

     Puedes correr expresiones EL en un archivo Java sin ser precisamente orientado a web (JSP, JSF). Se importa la la clase javax.el.ELProcessor y se ejecuta de esta manera, por ejemplo:

ELProcessor el = new ELProcessor();

        Object result = el.eval("'Java Rocks' += 100");

        System.out.println(result);

ELProcessor cuenta con muchas más funciones, como, por ejemplo definir un bean y utilizarlo dentro del ambiente EL.

Detalles de este API se encuentran no en la especificación pero si en el javadoc que viene con la especificación.

     

Expression Language 3.0 en Java EE 7

Dentro de las mejoras a Java EE 7 a varios de sus JSRs está Expression Language (EL), que es el JSR 341. Expression Language viene en su edición numero 3 en Java EE 7.
Si quieres conocer más sobre el Expression Language puedes consultar el tutorial de Java Enterprise 6.
Expression language ha resultado muy útil al momento de comunicar la Vista (View en una arquitectura MVC) con la lógica del negocio (Model o Controller según convenga). Con él puedes llamar funciones de tus Managed Beans.

En EL 3.0, EL es ya un lenguaje independiente y se saca del JSR de JSP.
Dentro de lo que le han agregado a EL 3.0 destacan cuatro cambios:

1. Nuevos Operadores: Concatenación (+=), Asignación(=) y el operador punto y coma (;). Este último para concatenar expresiones.
2. Expresiones Lambda. Si, Lambda, y estarán en Java EE 7 con el JDK 7.
3. Soporte (operaciones) a Colecciones
4. Y un API para evaluar expresiones de EL en ambientes stand-alone, es decir, dentro de clases de Java normales, sin ser un JSP o una página JSF.

Show me Code!

1. Para los nuevos operadores:

• Concatenación: Es válido en EL concatenar cadenas de la siguiente manera:

${"Java" += " Rocks"}  Para JSP

#{"Java" += " Rocks"}  Para JSF

         Se pueden concatenar otros tipos de datos que no sean String, se intentará convertirlo a String.

• Asignación: Igual a la asignación en Java. Una de las ventajas es que ya no se tendrá que usar el setValue para asignarle un valor a un bean:

          ${MyBean.value = "100"}               

• Punto y coma (;): Igual que en Java, con la excepción de que sólo se pueden poner expresiones, no sentencias. Una de las características de este operador es que siempre regresará el resultado de la expresión de más a la derecha, la última de la cadena. En el siguiente ejemplo:

         ${x = 30;50;x}       

          El valor que se regresará de esta expresión es 30.

En el siguiente post vendrán los demás cambios a EL 3.0