Mostrando las entradas con la etiqueta Desarrollo Java. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Desarrollo Java. Mostrar todas las entradas

jueves, 7 de octubre de 2010

Elementos Sintácticos de Java

He incluído para descarga en mi sitio web una guía de la mayor parte los elementos sintácticos de Java que servirá de ayuda para quienes programan en otros lenguajes y quisieran aprender Java. El link de descarga es el siguiente:


Espero se aproveche.

Saludos!

lunes, 20 de septiembre de 2010

Editor Visual para GWT

Hace poco me enteré que google compró la empresa instantiations (link a la noticia), esta empresa era la dueña del único diseñador gráfico decente para GWT, el cual era un plugin de eclipse y además privativo (había que comprarlo para usarlo). Hace poquito me entero que google publicó estos plugins gratis para todos! (link a la noticia).
Yo estuve probando este editor visual y he llegado a varias conclusiones:

Primero que nada, el plugin es genial! Las interfaces web diseñadas visualmente, o sea arrastrando componentes y realizando todo un manejo visual, terminan en código clásico de GWT, o bien con UI Binder!! El código que se genera es bastante limpio y fácil de entender, podemos utilizar todos los controles disponibles en GWT directamente de forma visual, podemos realizar cambios en el código y éstos se reflejan en el modo visual.

Además de todo esto, permite agregar fácilmente los frameworks de extensión mas populares como GWT-EXT y XGWT.

Acá les dejo un par de screenshots:

Vista de código:
Vista WYSIWYG:
Si combinamos esto con la funcionalidad que nos daba el plugin de google, nos queda como gran conclusión de todo que eclipse es la plataforma ideal e indiscutible para hacer aplicaciones en GWT.

Saludos!

domingo, 8 de agosto de 2010

Framework de WebSockets: websockets4j

Este fin de semana he estado trabajando duro en un framework para WebSockets que sea conectable a Glassfish 3 y Tomcat 7. Aunque no es solamente conectable a eso, sino que mientras el servidor tenga permitida la creación de hilos y levantar ServerSockets, esto va a andar. El framework es open source con licencia Apache 2, bien permisiva!!.

El framework puede ser descargado de: http://websockets4j.googlecode.com y tiene como interesante que soporta la versión 75 y 76 del borrador del estándar de WebSockets, trataré de irlo actualizando a medida que los browsers vayan soportando versiones nuevas del estándar. Por ahora Google Chrome soporta la versión 75 y Safari 5 la versión 76.
Les dejo acá un videito de una aplicación de chat de ejemplo que hice para demostrar el funcionamiento del framework. Está en inglés porque pertenece al sitio de mi proyecto.
Dicen.. que se puede ver en hd.




Un dato curioso es que el framework no está hecho para funcionar con servlets incluso cuando el handshaking del protocolo es parecido a una solicitud http, bien, la especificación de servlets dice claramente que los servlets son para protocolos de solicitud y respuesta, como el HTTP, pero los websockets se comportan de forma muy distinta. Espero que le sirva a alguno, y pronto estaré trabajando en agregarle soporte para TLS.

Saludos!!

viernes, 15 de enero de 2010

Google Guice, breve reseña.

Google Guice es un framework para inyección de dependencias. Cuando nos encontramos frente al desarrollo de aplicaciones grandes (o al menos potencialmente grandes) en las que distintos equipos de desarrolladores codifican distintos módulos de una misma aplicación es el caso donde se presenta como obvia la necesidad de un bajo acoplamiento entre dichos módulos. Normalmente se presenta la necesidad de realizar tests automatizados de una o mas clases, o colaboraciones y dicho código posiblemente dependa de código de otro módulo que ni siquiera se encuentre desarrollado, o que resulte extremadamente costoso en tiempo o en recursos realizar dichos test. Aquí es cuando entra en juego la inyección de dependencias. No pretendo en este post explicar la inyección de dependencias en sí, para mayor información sobre ésta ver el siguiente enlace.

Goolge Guice es un excelente framework, el cual implementa el standard JSR 330 para la inyección de dependencias. Posee entre otras las siguientes características:
  • Inyección de dependencias en constructor.
  • Inyección de dependencias utilizando setters.
  • Inyección de dependencias directamente en los atributos de la clase.
  • Intercepción de métodos con filtro por anotaciones (especialmente útil para AOP).
  • Configuración programática de los módulos de la aplicación.
  • Definición de Fabricas (proveedores) y ámbitos para las instancias inyectadas.
  • Otras.
Gracias a estas características, estre framework resulta especialmente útil, algunos de los beneficios de utilizarlo son:
  • Generalización de aspectos en las aplicaciones y su consiguiente reducción de errores.
  • Escribimos código mas mantenible.
  • Escribimos código mejor testeable.
  • Escribimos código mucho más reutilizable.
En el siguiente ejemplo demostramos el uso de Google Guice para el módulo de recordatorio de cumpleaños en el appspot de este blog.

Primero demostraré un framgento de la clase encargada de la lógica de negocio de esta pequeña aplicación:
@Singleton
public class BirthDateManager {

private EntityManager em;

@Inject
public BirthDateManager(EntityManager em) {
this.em = em;
}
...
}


Podemos observar 3 cosas:
  1. Utilizamos el annotation @Singleton para indicarle al inyector que esta clase deberá instanciarla una única vez.
  2. Definimos el constructor que recibe las dependencias de esta clase de reglas de negocio de acuerdo con el patrón inyección de dependencias.
  3. Con la annotation @Inject le indicamos al inyector que debe inyectar dependencias.
Ahora observamos la clase que define el módulo donde configuraremos el inyector:

public class BirthDateModule extends AbstractModule {

@Override
protected void configure() {
bind(EntityManager.class).toProvider(PersistenceFacade.class);
}

}


Con esta simple línea le indicamos al inyector que debe obtener la dependencia de un proveedor, en este caso una fachada de persistencia. A continuación el código interesante de dicha fachada:

public class PersistenceFacade implements Provider<EntityManager> {

@Override
public EntityManager get() {
return emf.createEntityManager();
}
...
}

Vemos que nuestra clase proveedora deberá implementar la interfaz Provider para que Guice sepa cual es el método que nos provee la dependencia.

Finalmente vemos el código que pone todo junto. Obtenemos la clase de las reglas del negocio con las dependencias ya satisfechas a través de un inyector:

        Injector in = Guice.createInjector(new BirthDateModule());
BirthDateManager bdm = in.getInstance(BirthDateManager.class);



Como se puede ver resulta bastante simple:creamos un inyector a partir del módulo y luego le pedimos la clase de reglas del negocio a dicho inyector. Toda la magia ocurre en estas 2 líneas.

Con eso concluyo esta breve demostración de Google Guice. Espero que sea de utilidad.

Saludos!

domingo, 3 de enero de 2010

Google AppEngine: Protegiendo el contenido web.

En un post anterior vimos como utilizar las cuentas de google para hacer login y logout en app engine. Ahora veremos una de las opciones para proteger contenido en nuestra aplicación, mediante la definición de reglas declarativas en el archivo web.xml. Para una referencia completa de las cosas que podemos hacer en el web.xml para app engine, ver el siguiente enlace.

AppEngine provee una forma estándar (llamando a estándar a compatible con JAAS) para proteger recursos declarativamente. Por ejemplo en la aplicación del appspot de este sitio se definió:

    <security-constraint>
<web-resource-collection>
<url-pattern>/seguro/*</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>*</role-name>
</auth-constraint>
</security-constraint>

Diciendo que lo que hay dentro de la carpeta "/seguro/" puede ser sólamente accedido por el rol "*".
AppEngine nos provee 2 roles distintos para nuestra aplicación:
  • El rol de cuenta de google: "*"
  • El rol de administrador: "admin"
El primero se aplica a cualquier persona logueada con su cuenta de google, y el segundo sólo a aquellas cuentas de google que definimos en la configuración de la aplicación como "admin".

Esta definición resulta suficiente para proteger cualquier contenido en nuestra aplicación, sin embargo cuando trabajamos con GWT, las consideraciones son un poco distintas, ya que debemos por un lado proveer una lógica que oculte o deshabilite opciones que no son accesibles y, debido a que se trata de código en el cliente, debemos proteger las llamadas remotas.

El escenario ideal para proteger las llamadas remotas es el de los servlets con programación orientada a aspectos o AOP y posiblemente anotaciones para asegurar métodos en forma declarativa. En un post futuro investigaremos estas posibilidades y utilizaremos filtros, algo realmente poderoso, para armar la seguridad de la forma menos trabajosa.

Saludos!

Google AppEngine: Acceso a las cuentas de google.

Una de las facilidades que nos provee Google AppEngine es la de acceder a las cuentas de google. He estado experimentando un poco con esto y puedo remarcar los siguientes puntos:
  • El acceso a la info del usuario logueado se realiza a través del mecanismo estándar de JAAS.
  • Pueden protegerse urls del sitio mediante el mecanismo estándar de la web tier, esto es definiéndolas en el archivo web.xml.
  • El mecanismo de login y logout es no estándar.
En este post demostraré el uso que le he dado a esta funcionalidad en el appspot del sitio. En próximos post demostraré alternativas para proteger urls del sitio.

El ejemplo es la implementación un servicio RPC de GWT. Primero echemosle una mirada a los import.
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import appspot.client.CommonService;
import com.google.appengine.api.users.UserService;
import com.google.appengine.api.users.UserServiceFactory;
import javax.servlet.http.HttpServletRequest;
Lo primero que vemos entonces son los import comunes de GWT para los servicios RPC, también vemos importada la interfaz necesaria para que la magia funcione "CommonService" (ese nombre lo elegí yo). Luego vemos las clases de google para acceder a sus cuentas, la "UserService" y "UserServiceFactory", de los nombres mismos ya se puede inferir el uso.

Lo próximo que veremos es la implementación de la clase de servicio, en la cual accedemos a las api.


public class CommonServiceImpl extends RemoteServiceServlet
implements CommonService {

@Override
public String getUserMail() {

UserService us = UserServiceFactory.getUserService();
if (!us.isUserLoggedIn()) {
return null;
}

HttpServletRequest req = getThreadLocalRequest();
String name = req.getUserPrincipal().getName();
return name;
}

@Override
public String getLoginUrl(String baseUrl) {
UserService us = UserServiceFactory.getUserService();
return us.createLoginURL(baseUrl);
}

@Override
public String getLogoutUrl(String baseUrl) {
UserService us = UserServiceFactory.getUserService();
return us.createLogoutURL(baseUrl);
}
}

Vemos que nuestro servicio tiene 3 métodos:
  • Obtener el usuario logueado.
  • Generar una URL que nos llevará a una pantalla de login.
  • Generar una URL que nos deslogueará del servicio.
En el primer método utilizamos el userService para preguntar si el usuario se encuentra logueado. Esta es una manera no estándar, pero realmente simpática y prolija.
Luego utilizamos una forma estándar para obtener el "User Principal", el cual traducido del lenguaje JAAS, es el usuario logueado.

Los métodos de generar urls son prácticamente iguales, en uno pedimos de una manera no estándar que nos entreguen una url de la página de login diciendo también la url a la cual queremos ir despues de estar logueados. Esto es realmente una ventaja comparado con la forma estándar en la cual definimos en web.xml un formulario de login al cual llegamos tratando de alcanzar una url no permitida, ya que la lógica de navegación para el login debe ser inferida y no puede leerse del propio código. Con eso le damos fin a nuestra demostración. Espero que haya sido de utilidad.

Saludos!

jueves, 31 de diciembre de 2009

UI Binding Con GWT 2.0

Una de las características nuevas de GWT es la posibilidad de crear interfaces de usuario definidas en un archivo XML, y luego vincular dicha definición con una clase, la cual incluirá el comportamiento de dicha interfaz, todo esto se realiza gracias al nuevo UiBinder.
En el siguiente ejemplo muestro como hacer una simple calculadora de enteros, definiendo la interfaz de usuario en un archivo xml y el comportamiento en una clase. Luego de todo eso podremos utilizar nuestra pantalla como si fuera un simple Widget de GWT.

El ejemplo funcionando se encuentra disponible bajo el enlace "Calculadora" del appspot de este blog.

Para empezar mostraré la pantalla definida en el xml. El archivo es "WebCalc.ui.xml"

<?xml version="1.0" encoding="UTF-8"?>
<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder' xmlns:g='urn:import:com.google.gwt.user.client.ui'>
<g:DockPanel>
<g:Dock direction="SOUTH">
<g:HorizontalPanel>
<g:Button text="Suma" ui:field="botonSumar" />
<g:Button text="Resta" ui:field="botonRestar" />
<g:Button text="Multuplicación" ui:field="botonMultiplicar" />
<g:Button text="División" ui:field="botonDividir" />
</g:HorizontalPanel>
</g:Dock>
<g:Dock direction="CENTER">
<g:HTMLPanel>
<p>Operador 1: <input type="text" ui:field="operador1" /></p>
<p>Operador 2: <input type="text" ui:field="operador2" /></p>
<p>Resultado: <span ui:field="resultado"/></p>
</g:HTMLPanel>
</g:Dock>
</g:DockPanel>
</ui:UiBinder>

Podemos ver que es bastante sencillo, primero definimos declarativamente un DockPanel, para la botonoera utilizamos un HorizontalPanel, el cual contiene 4 botones, vinculados por el atributo "ui:field" con ciertos métodos de la clase controladora que veremos más adelante.
Para la entrada, y en el centro del dock panel, utilizamos un panel html con tags html estándar (lo cual resalta el poder del UiBinder). Dandole el formato que a nosotros nos plazca y aún así pudiendo vincular elementos en la clase, de la misma forma que lo hicimos con los botones.

En este ejemplo no se muestra pero es posible también incluir estilos personalizados que se aplican sólo para el xml que estamos definiendo; otra muestra del gran poder de esta herramienta.

A continuación mostramos la clase que define el comportamiento de nuestra calculadora, el archivo "WebCalc.java".

public class WebCalc extends Composite {

interface Pantalla extends UiBinder<Widget, WebCalc> { }
private static Pantalla pantalla = GWT.create(Pantalla.class);

@UiField
InputElement operador1;
@UiField
InputElement operador2;
@UiField
SpanElement resultado;

public WebCalc() {
initWidget(pantalla.createAndBindUi(this));
}

@UiHandler("botonSumar")
public void sumar(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 + op2));
}

@UiHandler("botonRestar")
public void restar(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 - op2));
}

@UiHandler("botonMultiplicar")
public void multiplicar(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 * op2));
}

@UiHandler("botonDividir")
public void dividir(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 / op2));
}

private int leerOperador(InputElement tb) {

if (tb == null) {
Window.alert("No es posible leer un valor");
return 0;
}
try {
return Integer.parseInt(tb.getValue());

} catch (NumberFormatException ex) {
Window.alert("No es posible convertir a entero: " + tb.getValue());
}
return 0;
}
}

Como podemos ver es bastante simple:
Para realizar el vínculo con el archivo declaramos la interfaz interna, a la cual podemos ponerle el nombre que mas nos convenga, utilizando como sus parámetros de generics el tipo de componente resultante que deseamos y el tipo de componente que tiene el "dueño" de la interfaz generada.
Posteriormente creamos el componente utilizando el mecanismo de "Deferred Binding" que nos provee GWT.

En el constructor de nuestro manejador le indicamos a nuestro componente recien creado que se vincule con la instancia actual de la clase mediante el llamado al método "createAndBindUi".

Finalmente utilizamos los annotations @UiField y @UiHandler para vincular componentes y las acciones de los botones.
Los botones pueden vincularse con cualquier método que devuelva void, y reciba un ClickEvent.

Bueno, espero haber podido ilustrar un poco el uso de esta gran herramienta que nos provee GWT. Si se desea ampliar la lectura, recomiendo leer el siguiente tutorial.

Saludos!

Debugeando Proyectos con GWT 2 y EJB 3

Algo lindo de la forma nueva de debugear proyectos con gwt 2 es que ya no nos encontramos atados de pies y manos cuando queremos desarrollar con glassfish y ejbs. Una prueba de esto es el siguiente video.



Espero que lo disfruten.
Saludos!

lunes, 28 de diciembre de 2009

Google Web Toolkit 2.0

Acá les dejo un video que explica brevemente las características nuevas de GWT 2.0



Saludos!

Google App Engine

Recientemente me han activado mi cuenta de Google App Engine para complementar un poco con ejemplos en funcionamiento las cosas que voy publicando acá en este blog.

Para quienes no sepan lo que es, trataré de definirlo de la siguiente forma: Es un servicio de google, gratuito al principio (podemos pagar si necesitamos subir las prestaciones) donde podemos hostear nuestras aplicaciones web, sin publicidades, y con prestaciones como utilización de mails y bases de datos (entre muchas otras).

App engine permite cargar aplicaciones web hechas en python y en java. Es realmente simple de habilitar, necesitamos una cuenta de google (como todos los servicios de google) y un celular, ya que habilitamos el servicio a través de sms. En mi caso, mi proveedor de servicio no estaba soportado por google app engine, sin embargo llené un formulario y 1 semana después me lo habilitaron.

Para desarrollar en Netbeans con app engine, necesitamos instalar el plugin mediante esta guia, y además descargar el SDK para java de google app engine.



Con el plugin para netbeans podemos probar las aplicaciones, debugearlas, cargarlas dentro de google y además manejo gráfico de todas las configuraciones para app engine.

La dirección de app engine para este blog es http://juancavallotti.appspot.com e iré incluyendo ejemplos de cosas que desarrolle para este blog.

Espero que les sea de utilidad.

Saludos!

sábado, 5 de diciembre de 2009

Pruebas de Unidad: JUnit 4 y Netbeans IDE

Muchas veces en la incansable labor de desarrollo de software, nos vemos en la necesidad de probar lo que hemos hecho. La forma que primero se nos viene a la cabeza es correr la aplicación, cargar los datos, y ver que todo ande bien.
Eventualmente no tendremos la posibilidad de ejecutar la aplicación completa, o la ejecución de ésta es algo que consume mucho tiempo y es muy laborioso, sin contar que a veces dependemos de necesitar listo el trabajo de otras personas para probar nuestro código. Ahí es donde cobra sentido la automatización de las pruebas de unidad.

La herramienta propuesta por Netbeans IDE y que ciertamente es la más utilizada en el ambiente es jUnit. En este post presentaré las nociones básicas de uso de la versión 4 de jUnit, basado en Annotations.

Utilizar esta herramienta es realmente sencillo, utilizaré la siguiente clase (realmente trivial) como sujeto de pruebas:

public class Matematica {
public int dividir(int a, int b) {
return a / b;
}
}

Para comenzar, creo dentro de mi proyecto de netbeans, en test packages, mi clase que será la Suite de pruebas (o conjunto de pruebas seleccionadas). Cada prueba se realiza dentro de un método y este deberá estar anotado con @Test.

Nuestra primera clase de prueba es esta:

import org.junit.Test;
import org.junit.Assert;

public class PruebaMate {

@Test
public void pruebaCero() {
int valor = new Matematica().dividir(4, 2);
Assert.assertEquals(2, valor);
}

}

A esta clase le iremos agregando cosas a medida que vayamos avanzando.
Para comenzar la prueba en netbeans, click derecho a la clase de prueba dentro del explorador de proyectos y le damos la opción "Run".

Presentando la siguiente salida:

Testsuite: PruebaMate
Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0,089 sec

test:
BUILD SUCCESSFUL (total time: 1 second)

Esto nos dice que la prueba se ejecutó, y no sólo eso sino que se realizó correctamente y el tiempo que tardó.

Ahora agregaremos el siguiente método para probar como se comporta con la división por 0:

@Test
public void pruebaUno() {
new Matematica().dividir(4, 0);
}

Y al correrlo obtenemos la siguiente salida:

Testsuite: PruebaMate
Tests run: 2, Failures: 0, Errors: 1, Time elapsed: 0,061 sec

Testcase: pruebaUno(PruebaMate): Caused an ERROR
/ by zero
java.lang.ArithmeticException: / by zero
at Matematica.dividir(Matematica.java:3)
at PruebaMate.pruebaUno(PruebaMate.java:14)


Test PruebaMate FAILED
test:
BUILD SUCCESSFUL (total time: 0 seconds)

Ahora vemos que en realidad la segunda prueba no debió haber fallado ya que en java la división por cero causa esa ArithmeticException. Para decirle a jUnit que realmente esa excepción no es mala sino que debería considerarse como resultado exitoso de la prueba, lo hacemos a través de el annotation @Test, el método quedará de la siguiente forma:

@Test(expected=ArithmeticException.class)
public void pruebaUno() {
new Matematica().dividir(4, 0);
}

Y al ejecutar la prueba vemos lo siguiente:

Testsuite: PruebaMate
Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0,049 sec

test:
BUILD SUCCESSFUL (total time: 0 seconds)

Nota: En caso que nuestra excepción necesitara ser declarada, agregamos la cláusula throws a nuestro método de prueba.

Ahora posiblemente antes de cada prueba necesitemos realizar un setup del entorno para que se adapte al entorno de producción, esto lo realizaremos con métodos anotados con @After y @Before, por ejemplo realizaremos la instanciación de la clase matemática antes de cada prueba y sugeriremos la recolección de basura después. La clase de pruebas modificada se ve de la siguiente forma:

import org.junit.After;
import org.junit.Test;
import org.junit.Assert;
import org.junit.Before;

public class PruebaMate {

@Test
public void pruebaCero() {
int valor = m.dividir(4, 2);
Assert.assertEquals(2, valor);
}

@Test(expected=ArithmeticException.class)
public void pruebaUno() {
m.dividir(4, 0);
}

private Matematica m;

@Before
public void iniciar() {
System.out.println("Inicio la prueba");
m = new Matematica();
}

@After
public void terminar() {
System.out.println("Termino la prueba");
m = null;
System.gc();
}
}


Y al ejecutar la prueba vemos el resultado:


Testsuite: PruebaMate
Inicio la prueba
Termino la prueba
Inicio la prueba
Termino la prueba
Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0,1 sec

------------- Standard Output ---------------
Inicio la prueba
Termino la prueba
Inicio la prueba
Termino la prueba
------------- ---------------- ---------------
test:
BUILD SUCCESSFUL (total time: 0 seconds)


Ahora, instanciar la misma clase una y otra vez por cada prueba no es barato, como se puede observar en los tiempos de ejecución. Si queremos realizar algo antes de todo y luego algo después de todo utilizamos los annotations @AfterClass y @BeforeClass, modificamos la clase de pruebas de la siguiente forma:

private static Matematica m;

@BeforeClass
public static void iniciar() {
System.out.println("Inicio la prueba");
m = new Matematica();
}

@AfterClass
public static void terminar() {
System.out.println("Termino la prueba");
m = null;
System.gc();
}

Cambiando a static ya que las anotaciones requieren que los métodos sean static. Y los resultados de la ejecución son los siguientes:

Testsuite: PruebaMate
Inicio la prueba
Termino la prueba
Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0,073 sec

------------- Standard Output ---------------
Inicio la prueba
Termino la prueba
------------- ---------------- ---------------
test:
BUILD SUCCESSFUL (total time: 0 seconds)


Con lo que terminamos este tutorial introductorio para realizar pruebas de unidad, las cuales nos ahorran mucho tiempo de introducción de datos y a medida que pasa el tiempo y las pruebas se acumulan nos sirven para verificar que los cambios introducidos en el mantenimiento de las aplicaciones, no tengan efectos adversos sobre la funcionalidad existente.

Espero que les sirva. Saludos!

miércoles, 30 de septiembre de 2009

Hibernate Annotations - Guia Rápida

En este post planeo explicar un poco sobre cómo utilizar hibernate annotations para proyectos Java SE. Antes que nada aclaro que se puede usar hibernate a través de la jpa, pero personalmente tengo razones para pensar que la JPA está todavía un poco chica como para Hibernate.

Para una guia de mapeo les recomiendo bajar la documentación de Hibernate-Annotations

Para los que no sepan de que estoy hablando lo pongo con palabras simples, hibernate es una librería que se encarga de "conectar" el mundo de la programación orientada a objetos con el mundo de las bases de datos relacionales. Algunos conocen esto como ORM o para los mortales, mapeo objeto-relacional.

No voy a dar mucha introducción al tema, debido a que puede ser un poco largo y espero que quien me esté leyendo lo haga porque comprende el tema y quiera ir directo al grano.

Para empezar hibernate utiliza un archivo xml de configuración

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
<property name="hibernate.connection.url">jdbc:postgresql://localhost:5432/prueba</property>
<property name="hibernate.connection.username">prueba</property>
<property name="hibernate.connection.password">prueba</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.show_sql">true</property>
<mapping package="pruebahibernate.entidades"/>
</session-factory>
</hibernate-configuration>


Este archivo debe llamarse hibernate.cfg.xml y va ubicado en la raíz de nuestra estructura de paquetes.

Como nota recordar poner el driver jdbc de nuestra base de datos relacional entre las librerías (así como las de hibernate annotations, y core). En mi caso utilizo PostgreSQL con una base de datos "prueba" con usuario y clave también prueba.

Todas mis clases de entidad se encuentran en el paquete pruebahibernate.entidades y además de eso tengo habilitada la actualización automática y generación de las tablas en la base de datos.

¿Como se usa?

Necesitamos un objeto Session Factory, esto es lo principal para generar Sesiones de hibernate y con ellas hacer cosas locas con nuestra base de datos. La siguiente línea levanta las configuraciones de nuestro xml, las aplica y crea un session factory con ellas. (Las podemos toquetear por código antes de crear el session factory.
Notar que la diferencia con hibernate standard es que se usa el objeto AnnotationConfiguration en vez del Configuration.


SessionFactory sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();

...
Session sesion = sessionFactory.openSession();
Transaction t = sesion.beginTransaction();
....
List l = sesion.createQuery("FROM Persona").list(); //Generar un listado de personas por ejemplo.
....
t.commit();
....

Y eso es todo, con muy pocas líneas y un par de annotations, tenemos un sistema robusto y transaccional para trabajar con bases de datos.

Ahora muestro como está mapeada mi entidad persona:

@Entity
public class Persona implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO, generator="system-uuid")
    @GenericGenerator(name="system-uuid", strategy="uuid")
    @Column(length=36)
    private String id;

    private String nombre;
    private String apellido;
    private int dni;
    private int edad;

    ....... // aca van los getters y setters
}



Como se verá el mapeo por annotations es mucho mas simple y compacto que con xml.Por ahí pueden parecer muchas annotations para un solo id pero es simplemente para especificarle que me genere automáticamente los UUID, es una maña mia nomas el único annotation requerido es el @Id

Espero que les haya servido, cualquier cosa postear preguntas.

Saludos!

lunes, 28 de septiembre de 2009

Instalando Glassfish en Archlinux

Hace relativamente poco he empezado mi vida como desarrollador JavaEE, como servidor de desarrollo utilizo GlassFish simplemente porque es de sun y es el que viene con Netbeans, el cual también utilizo.
En mi pc habitual de desarrollo de JavaEE me he encontrado que correr el IDE y el servidor en el mismo lugar es contraproducente para la velocidad de desarrollo, digamos, todo se tarda muchísimo, por lo cual he instalado Glassfish en una pc aparte y acá comento mi experiencia.

Primero que nada, quiero decir que glassfish no viene en los repos asíque hay que instalarlo usando yaourt.
#yaourt -S glassfish
Hay que correrlo como root porque sino el script de instalación falla y nos quedamos con el servidor a medias.

Luego de instalarlo se puede arrancar. Los dominios de glassfish se colocan en el directorio domains de la instalación (yaourt lo pone en /opt/glassfish), estoy usando el dominio por defecto ya que trae todos los servicios en los puertos estándar asíque prácticamente sale corriendo "out of the box".
Algo que extrañé es un script en /etc/rc.d para controlarlo, igual nada me impide hacerlo y lo hice.

Glassfish tiene un workaround para que funcionen las conexiones al servicio jndi y es que el nombre de host debe resolver a la ip externa de la pc, por lo cual hay que manipular el archivo /etc/hosts para que quede similar a esto:
127.0.0.1 localhost.localdomain localhost
192.168.1.8 juan-desktop
Para Controlarlo se utiliza el binario asadmin que se encuentra en el directorio bin, entonces por ejemplo mi dominio se llama domain1 (el que viene por defecto, y estas son las opciones para controlarlo):

asadmin start-domain domain1 # Arrancar el domain1 y si dado el caso, servidor también
asadmin stop-domain domain1 # Parar el dominio1 en el servidor y dado el caso, el servidor tb.

Si le añandimos la opción --debug, podemos arrancar el servidor en modo debug (lo cual sirve para los ides, entoces acá les presento mi script de shell para controlar a glassfish.

#!/bin/bash


case "$1" in

start)
/opt/glassfish/bin/asadmin start-domain domain1
;;
stop)
/opt/glassfish/bin/asadmin stop-domain domain1
;;
debug)
/opt/glassfish/bin/asadmin start-domain --debug domain1
;;

debug-restart)
$0 stop
sleep 5
$0 debug
;;
restart)
$0 stop
sleep 5
$0 start
;;
*)
echo "usage $0 {start, stop, debug, restart, debug-restart}"
;;
esac


Los sleep se los pongo simplemente para darle un descanso a la pc entre parada y arrancada.

Conexión con Netbeans

La conexión con netbeans es ultra facil, uno se dirige a la pestaña de servicios, en el item de servidores, le da click derecho y le pone agregar nuevo servidor, aparecerá un asistente y hay que colocar los siguientes datos, aclarando que 4848 es el puerto de adminsitración por http de mi glassfish standalone.




Espero que les sirva, saludos!

jueves, 27 de agosto de 2009

JDK 7

Muy interesante video sobre la próxima versión de java con las cosas nuevas que va a tener.


Saludos!

domingo, 2 de agosto de 2009

Javascript Embebido

Muchas veces resulta práctico proveer a nuestras aplicaciónes de una funcionalidad de scripting, de forma que el usuario sea capaz de escribir sus propios plugins. Un ejemplo sería que escribimos una aplicación de reproducir canciones, entonces si agregamos un motor de scripts, nuestros usuarios serían capaz de escribir por dar un ejemplo una alarma que haga sonar música a una determinada hora.

Para embeber un motor de Javascript en nuestra aplicación java, podemos utilizar un motor de javacript desarrollado por Mozilla para el lenguaje java, Rhino

Rhino permite con muy pocas líneas hacer que nuestro programa compile y ejecute javascript.

Rhino implementa hasta la versión 1.7 de javascript, y una de las posibilidades que tiene es la de acceder a nuestros objetos java "transparentemente" desde nuestra aplicación java. También nos permite acceder a objetos javascript desde nuestra aplicación java.

Para ver un ejemplo de su uso les dejo un link de Wikipedia.

Saludos!

jueves, 16 de julio de 2009

Mi Juego de la Viborita

Hoy queria presentarles mi juego de la viborita que liberé bajo la licencia GPL v2.
Se trata de un juego para celulares y viene en 2 versiones, una no SVG y otra con gráficos SVG.
Gracias a mi amigo Diego Soppelsa por dibujar los gráficos!!









































En las figuras podemos ver las 2 versiónes del juego corriendo en el emulador.
Para quienes les guste el juego, pueden bajarselo de http://serpentina.googlecode.com/

Controles del Juego

Los controles del juego son los controles estándares para todos los juegos (las flechas de dirección del celular). Es posible habilitar el teclado numérico, 2, 4, 6, 9.

Para poner pausa es la tecla numeral (#) del celular y para terminar el juego es la tecla asterisco (*) .

Discusión sobre el proyecto.

Muchos pueden preguntarse ¿por qué hacer otro juego de la viborita cuando seguro existen muchos?
Bueno, primero que nada resultó ser un desafío o meta que había querido encarar sin éxito de diferentes maneras y en diferentes lenguajes, mas o menos desde que empezó mi vida de la programación hace como desde el año 1996. En sí el desafío es importante para programadores amateur/intermedios, en sí no es dificil de hacer para nada pero si requiere tener en claro los conceptos.
Sólo por comentar, traté de hacer el juego en Visual Basic, Flash, C y java antes de poder implementarlo con éxito.

Segundo porque es el juego que más me gusta, y esta versión tiene unos sonidos muy divertidos.

Participar en el Proyecto

Si a alguien le gustaría participar en el desarrollo del juego, puede escribirme un mail y yo le doy acceso al svn de google code. Principalmente sería importante que la versión no svg tenga alguien que la mantenga.

Espero que lo disfruten, saludos!.