Al parecer hay buenas noticias, porque Oracle ha reafirmado su compromiso por mejorar el lenguaje Java en todas sus ediciones, cosa que ya le hacía falta a Java, porque para mi gusto se ha quedado muy rezagada en comparación a C#. Ahora lo que falta es ver que lo cumplan, aunque yo creo que así será ya que a Oracle le conviene seguir impulsando la plataforma Java, ya que la mayoría de sus productos dependen directamente de ella.

Respecto a MySQL, Glassfish, Netbeans, VirtualBox y OpenOffice, igual anunciaron que seguirán dando soporte y haciéndolos cada vez mejores productos.

Supongo que a la mayoría de los desarrolladores que trabajamos con Java, nos gustaría que la estrategia de Oracle siga siendo en favor del Open Source. Que sigan manteniendo la portura que Sun tenía respecto a sus productos. No nos gustaría tener un segundo Microsoft en el mundo de la tecnología.

Sin embargo, sí se podría convertir en la principal competencia de Microsoft en el mundo empresarial respecto a ofrecer soluciones integrales. Al igual que Microsoft, Oracle podrá ofrecer ahora una solución que incluya sistema operativo (Solaris), base de datos (Oracle o MySQL), plataforma de desarrollo (Java), suite de oficina (OpenOffice) y entorno de desarrollo (JDeveloper o Netbeans). Además podrá ofrecer el hardware y la plataforma de virtualización (VirtualBox). Definitivamente estará al nivel de competir contra Microsoft en rubros donde antes no podía.

Lo bueno es que la competencia siempre trae cosas buenas para nosotros los desarrolladores y para los clientes finales.

• Soporte para la edición empresarial de Java 6 (recién liberada también)
• Proyectos web con Java Server Faces (JSF) 2.0
• Soporte mejorado para JavaFX
• Soporte para kenai.com (página para colaboración entre desarrolladores)
• Soporte para PHP 5.3
• Ruby 1.9 y Rails 2.3.4
• Mejor soporte para Groovy y Grails
• Entre otras…

Así que no esperen más y descárguenlo para obtener los beneficios de esta nueva versión. Yo por mi parte ya lo tengo instalado en ambas particiones, en Ubuntu y Windows 7 y lo utilizo para proyectos de java y php principalmente.

Con todo y la buena noticia, nada es perfecto. También se anunció que la siguiente versión será lanzada hasta finales del año 2010, lo cual significa un retraso de más de seis meses respecto a la fecha indicada anteriormente. Esto no creo que sean buenas noticias para Java, porque siento que le puede ocasionar pérdida de terreno frente a otros lenguajes o plataformas. A principios del próximo año sale la versión 2010 de Visual Studio y con esto el .NET Framework 4 con muchas mejoras. También los lenguajes dinámicos como Ruby, Python, PHP e incluso Groovy siguen mejorando y ganando terreno. Definitivamente Java seguirá siendo usado por las grandes empresas que requieren todo el conjunto de componentes que conforman la edición empresarial de Java JEE, pero para otro tipo de aplicaciones cada vez hay más opciones que se ve un futuro incierto para Java.

Mi experiencia fue que instalé el Tomcat mediante el Synaptic y al parecer a Netbeans no le gusta este tipo de configuración, porque al tratar de configurar un nuevo servidor web Tomcat desde el IDE me marcaba un error de que el archivo “(catalina_home)/conf/server.xml” no es válido. El problema es que Ubuntu instala el archivo server.xml en la carpeta /etc/tomcat6, por lo que tenemos que ejecutar el siguiente comando para corregirlo:

sudo ln -s /etc/tomcat6 /usr/share/tomcat6/conf

Ahora dentro de Netbeans le podemos dar la ruta correcta del tomcat que es

/usr/share/tomcat6

Espero que este pequeño tip les ayude a resolver este problema.

El objetivo del framework Play es facilitar el desarrollo de aplicaciones web sin tener que abandonar la plataforma Java. En teoría suena muy bien, habría que probarlo para saber si cumplen con lo que prometen.

Entre las características que anuncian se encuentran las siguientes:

Un framework Java sin tantas complicaciones
Play es un framework desarrollado completamente en Java y te permite continuar con tus herramientas de desarrollo y librerías favoritas. Si ya utilizas Java como plataforma de desarrollo entonces no tienes porque cambiarte a otro lenguaje, otro IDE o a otras librerías.

Corrige el error y presiona F5
La plataforma Java siempre ha sido famosa por su baja productividad para aplicaciones web, principalmente debido a la necesidad de compilar para poder realizar actualizaciones.
En Play esto ya no es necesario, ya que el mismo framework realiza la compilación directamente de los archivos .java y los carga en tiempo de ejecución directamente a la máquina virtual (JVM) sin necesidad de reiniciar el servidor web.
Con esta característica el ciclo de desarrollo se asemeja mucho a la programación en PHP o Ruby on rails en cuanto a agilidad. Incluso ya no necesitarías un IDE, ya podrías trabajar con cualquier editor de texto si quisieras.

Arquitectura MVC
Las arquitecturas que se basan en la sesión para guardar el estado hacen que sea fácil cierto tipo de programación, pero a la vez nos ocasionan varios problemas. Por eso la tendencia actual es eliminar cualquier capa de complejidad y apegarnos lo más posible al modelo de petición-respuesta HTTP.
Para esto, Play utiliza la misma arquitectura MVC que utilizan frameworks como Rails, Django o CakePHP; modelo que ha tenido mucho éxito y ha permitido facilitar la programación de sitios web dinámicos y la inclusión de Ajax en los mismos.

Mapeo de HTTP a código
A diferencia de otros frameworks que intentan abstraer el modelo HTTP del programador, en Play se le presenta al desarrollador todo el poder de accesar al protocolo HTTP y sus conceptos mediante el framework. Por ejemplo, para vincular un URI (identificador de recurso único) a un método de Java, sólamente es necesaria la siguiente línea.

GET    /clientes/{id}        Clientes.show

Plantillas eficientes
La idea detrás de JSP y el lenguaje de expresiones (EL) es muy buena. Pero el problema es que se complica con todas las configuraciones que hay que hacer y más aun con el uso de librerías de etiquetas (tag libraries). JSP tiene algunas limitantes, es por eso que los creadores del framework decidieron programador su propia librería de plantillas, inspirada por JSP pero sin sus limitantes.

Por ejemplo, en lugar de escribir esto:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
 
<c:choose>
<c:when test="${correos.sinLeer != null && fn:size(correos.sinLeer)}">
Tienes ${fn:size(correos.sinLeer)} correo(s) sin leer!
</c:when>
<c:otherwise>
No tienes correos sin leer!
</c:otherwise>
</c:choose>

Es mucho más fácil entender esto:

Tienes ${correos.sinLeer ?: 'no'} ${correos.sinLeer?.pluralize('correo')} !

El lenguaje de expresiones utilizado por Play es Groovy que proporciona una sintaxis consistente con Java.

JPA mejorado
JPA es una de los mejores ORM que existen para Java. Play ofrece una integración muy sencilla y sin configuraciones con JPA.

Desarrollo orientado a pruebas (Test driven development)
Play trae un módulo integrado para ejecutar las pruebas. Puedes escribir todo tipo de pruebas, desde pruebas unitarias hasta pruebas de aceptación y ejecutarlas directamente con Selenium.

Completo ambiente de desarrollo
El framework Play cuenta con todo lo necesario para crear aplicaciones web modernas:

• Soporte a bases de datos relacionales mediante JDBC.
• Mapeo relacional-objetos (ORM) mediante Hibernate (con JPA).
• Soporte de cacheo integrado.
• Consumo de web services con JSON o XML.
• Soporte de autentificación distribuida con OpenID.
• API para manipulación de imágenes.
• Entre otros…

Si quieres probar el framework, puedes descargarlo desde su página web.

http://www.playframework.org/

Para los que no conozcan GWT, es una librería desarrollada por Google que te permite programar tu código en Java y diseñar tus interfaces de usuario como si fuera Swing, y al momento de compilarla te la convierte a Javascript muy optimizado. Después de ser compilada, sólo necesitas colocarlo en el servidor web y listo!. De esta forma obtenemos la ventaja de poder editar nuestro código con algún IDE como NetBeans o Eclipse. Google actualmente está utilizando GWT para desarrollar su más reciente proyecto Google Wave.

Opinando acerca de este tema, yo considero que la librería GWT es adecuada para ciertas tareas y lo hace muy bien. Por ejemplo, si necesitas desarrollar algún sistema basado en web que sea muy interactivo como algún sistema de inventario, un ERP o GRP, entonces GWT sí podría ser la mejor opción; pero si lo que necesitas es un sitio web con sólo ciertas partes interactivas y que se requiera mucho diseño gráfico en la interfaz, entonces sería mejor otra opción.

GWT trae una librería de widgets o componentes algo limitada, pero permite crear los tuyos propios. También existen componentes de terceros que traen gran cantidad de elementos para todas las tareas posibles (Grids, Tabs, Árboles, Manejo de formularios, etc). La que más me ha gustado es SmartGWT, pero también existe ExtGWT (aunque tavez su licencia no sea la más adecuada).

En conclusión, podemos decir que GWT tiene un gran futuro y por ser un proyecto de Google igual sabemos que tendrá mucha atención por parte de los desarrolladores. Actualmente la mayoría de los IDEs ya cuentan con algún tipo de soporte para la librería, pero sería bueno ver en un futuro alguna opción Open Source de algún editor gráfico para desarrollar la interfaz y no tener que hacerlo con puro código. Otro punto importante sería que Oracle o IBM invirtieran recursos para mejorar la librería, lo cual sería muy bueno para todos nosotros.

En esta ocasión platicaremos de GrailsFlow, que es una librería para control de procesos y flujos de trabajo (workflows), que puede ser integrada fácilmnte a aplicaciones de Groovy, Grails o incluso Java.

GrailsFlow ofrece las siguientes ventajas:

• Sistema completo de control de procesos y flujos de trabajo.
• Estructura muy simple y fácil de entender.
• Lenguaje específico de dominio (DSL) basado en Groovy en lugar de XML para definir los procesos.
• Interfaz de usuario para definir los procesos, administrar las listas de trabajo y monitoreo de procesos.

La versión actual es la 1.0 RC1 y ya está completamente estable como para ser usada en producción. Puedes descargarla o también obtener más información en su página web: http://www.grailsflow.org/

Con este lanzamiento se une a NetBeans y Eclipse en el campo de IDEs open source enfocados principalmente a Java pero con soporte para varios lenguajes como PHP, Ruby, Python, etc. Es bueno tener una opción más para nosotros los programadores.

Si deseas descargar el programa, lo puedes hacer mediante el siguiente enlace.

NetBeans
Oracle intenta proporcionar NetBeans como una opción adicional de código abierto para complementar a JDeveloper y el paquete empresarial de Oracle para Eclipse. Sin embargo, Oracle deja en claro que JDeveloper seguirá siendo su herramienta estratégica para Oracle Fusion y futuras aplicaciones empresariales.

Glassfish
Oracle dice que “invertirá lo necesario para alinear una infraestructura común de componentes e innovaciones” entre Oracle WebLogic y Glassfish. Planean continuar el desarrollo de Glassfish como la implementación de referencia de las especificaciones Java EE (Edición empresarial). También comentó que continuará dando soporte activamente a la comunidad Glassfish.

VirtualBox
Comentaron que “esperan” continuar dando soporte a las diversos herramientas de virtualización que actualmente tiene Sun. Incluyen VDI, Secure Global Desktop, Sun Ray y VirtualBox.

OpenOffice
Oracle seguirá desarrollando y dando soporte a OpenOffice como open source. Pero también incluirá una licencia comercial para aquellos clientes que requieran soporte y herramientas de nivel empresarial.

Respecto a sus planes de SPARC, Solaris y MySQL no hay novedades. También hay que aclarar que Oracle puso una nota en su FAQ donde comentan que estos comentarios están sujetos a cambios. Aun así, es bueno tener noticias para estar preparados con respecto al futuro de todos estos componentes tan utilizados en el mundo de Java y fuera de él.

Últimamente han estado muy de moda los lenguajes dinámicos e interpretados, ya que se combinan muy bien con  la programación ágil que tan necesaria es en estos días. En esta ocasión, nos centraremos en conocer el lenguaje Groovy y más concretamente, el framework Grails.

Groovy es un lenguaje de programación orientado a objetos que está implementado sobre la plataforma de Java, y por lo tanto para su ejecución necesita de una máquina virtual de Java (JVM). Tiene características muy parecidas a Perl, Ruby y Python, aunque su sintaxis es muy similar a la de Java, y una de las principales ventajas es que puede tener acceso a todas las librerías existentes de Java (que son muchísimas). La versión estable más reciente al momento de escribir este artículo es la 1.6.

Grails por su parte, es un framework para aplicaciones web desarrollado sobre Groovy orientado al patrón de diseño MVC (Modelo-Vista-Controlador). Es un marco de trabajo muy productivo y se basa en paradigmas como la convención sobre configuración y no te repitas (DRY por sus siglas en inglés), y proporciona un entorno de desarrollo estandarizado y oculta gran parte de los detalles de configuración al programador. Es un marco de trabajo muy estable ya que se está construido a partir de librerías ampliamente utilizadas en el mundo de Java, como son Hibernate y Spring.

En el siguiente tutorial crearemos un proyecto muy sencillo con Grails para mostrar la funcionalidad básica.

Instalando Groovy y Grails

Para instalar Groovy es necesario realizar los siguientes pasos:

1. Primero, es necesario descargar una distribución binaria y luego descomprimirla en alguna carpeta.
2. Establecer la variable de ambiente GROOVY_HOME hacia la carpeta donde lo descomprimimos.
3. Agregar GROOVY_HOME/bin a la variable de ambiente PATH del sistema operativo.
4. Establecer la variable JAVA_HOME al directorio de instalación del JDK. En Windows esto es normalmente en c:\Archivos de Programa\Java\jdk[versión instalada], en el OS X se instala normalmente en /Library/Java/Home y en Linux en /usr/java.

Posteriormente, necesitaremos instalar Grails siguiendo estas instrucciones:

• Descarga la versión más reciente de Grails.
• Extrae los archivos en alguna carpeta del sistema.
• Crea la variable de ambiente GRAILS_HOME que apunte a la carpeta donde se descomprimieron los archivos.
• Anexa GRAILS_HOME\bin al PATH del sistema.
• Teclea “grails” en la línea de comandos y si sale un mensaje de ayuda, ya todo estará instalado correctamente.

Es importante notar que como se mencionó anteriormente, Groovy se ejecuta sobre la plataforma de Java, por lo tanto es necesario tener instalado el JDK que puede ser descargado desde la página de Sun.

Creando el proyecto

Una vez que ya está instalado todo, podemos empezar a programar con Grails. Para crear un proyecto, primero nos situamos en la carpeta donde queremos crearlo mediante la línea de comandos y luego tecleamos lo siguiente:

grails create-app

Se te preguntará por el nombre del proyecto y se generará un proyecto con la siguiente estructura:

%CARPETA_PROYECTO%
    + grails-app
       + conf                 --- Archivos de configuración
           + hibernate              --- Configuración opcional de Hibernate
           + spring                 --- Configuración opcional de Spring
       + controllers          --- Directorio para los controladores
       + domain               --- Directorio para los objetos de dominio (modelo)
       + i18n                 --- Directorio para los mensajes para localizar la aplicación
       + services             --- Directorio para los servicios
       + taglib               --- Directorio para las librerías de etiquetas
       + util                 --- Directorio para utilerías diversas
       + views                --- Directorio para las vistas
           + layouts              --- Directorio para las vistas maestras
   + lib
   + scripts                  --- Directorio para scripts
   + src
       + groovy               --- Opcional: archivos de Groovy adicionales.
       + java                 --- Opcional: archivos Java
   + test                     --- Clases generadas para realizar pruebas
   + web-app
       + WEB-INF

Configurando un Origen de Datos (opcional)

El script “create-app” creó un archivo de configuración del origen de datos en el directorio “/grails-app/conf” con el nombre de DataSource.groovy con closures (link para más información en inglés) para cada uno de los ambientes estándar: Desarrollo (Development), Pruebas (TestData) y Producción (Production). Todos los ejemplos de este artículo utilizan el ambiente de Desarrollo.

Por defecto, todos los orígenes de datos están configurados para utilizar la base de datos HSQLDB (excelente para realizar pruebas, pero talvez no tan útil para producción).

dataSource {
  pooled = false
  driverClassName = "org.hsqldb.jdbcDriver"
  username = "sa"
  password = ""
}
// environment specific settings
environments {
  development {
    dataSource {
      dbCreate = "create-drop" // one of 'create', 'create-drop','update'
      url = "jdbc:hsqldb:mem:devDB"
    }
  }
  test {
    dataSource {
      dbCreate = "update"
      url = "jdbc:hsqldb:mem:testDb"
    }
  }
  production {
    dataSource {
      dbCreate = "update"
      url = "jdbc:hsqldb:file:prodDb;shutdown=true"
    }
  }
}

Para configurar otro origen de datos sólo se necesita cambiar los valores de “url” para seleccionar la base de datos deseada y poner el archivo jar del driver en la carpeta “lib”.

Creando una clase de Dominio

Asegúrate de estar en el directorio raíz del proyecto y teclea lo siguiente:

cd tutorial1
grails create-domain-class

El comando nos preguntará el nombre de la clase que será creada. Respondamos al comando con “libro”, lo que nos generará el archivo Libro.groovy en el directorio “Domain” del proyecto. Es un archivo de texto plano, por lo que puede ser editado con cualquier editor de texto.

Nota: Para nombrar tus clases de dominio, no se deben utilizar nombres de palabras clave de la base de datos. Tampoco se deben utilizar nombres como por ejemplo MILibro (que tengan dos o más letras mayúsculas al inicio), pero MiLibro es completamente permitido. Aparentemente Grails tiene problemas con ese tipo de nombres, ya que a veces se generan errores 404 (página no encontrada).

Una clase de dominio es un elemento persistente y todas sus propiedades son guardadas automáticamente a la base de datos.
Pongamos lo siguiente en el archivo Libro.groovy:

class Libro {
  String titulo
  String autor
}

En este punto, probablemente sea buena idea tener datos para poder realizar pruebas. Una forma fácil de hacerlo es utilizando el método “init” del archivo “conf/BootStrap.groovy” como se muestra a continuación:

class BootStrap {
  def init = { servletContext ->
    new Libro(titulo:'100 años de soledad', autor:'Gabriel García Márquez').save()
    new Libro(titulo:'La casa de los espíritus', autor:'Isabel Allende').save()
  }
  def destroy = { }
}

Creando un Controlador

Los controladores son la parte central de las aplicaciones de Grails, ya que ellos controlan las peticiones que reciben de parte de los navegadores y los mapean a las clases y métodos correspondientes.

En este paso es necesario que ejecutes el comando “grails create-controller” y de nuevo se te pedirá un nombre para el controlador a crear. En nuestro caso tecleamos “Libro” lo que nos generará el archivo “grails-app/controllers/LibroController.groovy”.

Como siguiente paso, abrimos el archivo recién generado y utilizaremos una característica de Grails llamada Scaffolding para generar parte de la aplicación dinámicamente en tiempo de ejecución.

class LibroController {
  def scaffold = Libro
}

Nota:Es necesario quitar o comentar el código “def index = {}” que existe en el archivo para que funcione correctamente el Scaffolding.

También podriamos haber hecho uso del comando “grails generate-all” (recuerda que siempre se deben ejecutar en el directorio raíz del proyecto), el cual crearía todos los archivos necesarios por ti (controlador, vistas).

Resultado final

Por último, sólo nos resta ejecutar el servidor integrado de rails para ver el resultado final de nuestra aplicación web:

grails run-app

Esto iniciará una instancia del servidor web integrado y que escuchará las peticiones en el puerto 8080. Si deseas que escuche en otro puerto, necesitas indicarle la configuración al momento de ejecutarlo:

grails -Dserver.port=8090 run-app

Para visualizar la lista de libros escribe en tu navegador la siguiente dirección:

http://localhost:8080/tutorial1/libro/list

O como el método “list” es el que se llama por defecto, también lo podemos omitir:

http://localhost:8080/tutorial1/libro

Hasta aquí con este tutorial sencillo de Grails, más adelante analizaremos más a fondo otros aspectos que lo hacen un gran entorno de desarrollo.