Primeros pasos con graniteDS y java

La tecnología Flex usa 3 métodos para la comunicación con el servidor o un servicio : HTTP, Servicios web y objetos remotos sobre el protocolo AMF3.

Si bien los 3 tienen su utilidad y beneficios, es necesario tener claro la diferencia de ambas.

Usando HTTPService podemos interactuar con todo lo que maneje el protocolo HTTP (paginas jsp, aspx, archivos ,REST, etc) pero el incoveniente es que nunca sabremos exactamente el formato preciso ni la codificación usada. Es mas usada para obtener archivos y con REST (aunque este ultimo tiene sus problemas).

Ahora los 2 servicios restantes tienen mejores cualidades que el servicio HTTP pero también involucra mas complejidad y configuración. En el caso de los servicios web es necesario tener en cuenta todos los métodos a usar, la autentificación y también el famoso archivo crossdomain.xml que es el que nos permite saber que servicios se puede responder y cuáles no. Dicha complejidad resulta un dolor de cabeza cuando se quiere usar distintos servicios en distintos servidores que tengan dominios distintos ya que una de las razones de ser del archivo crossdomain.xml es el “informar” que dominio está disponible o no. Es decir que el archivo crossdomain.xml debe estar en los servidores a usar.

Ahora bien para solucionar el problema de comunicación y de interaoperabilidad se creo el protocolo AMF para el uso de aplicaciones que usen el motor de Flash. Dicho protocolo ayuda a la transmisión de los denominados objetos remotos entre el front y el back end. Actualmente existe una solución denominada LiveCycle de Adobe (mas informacion sobre sus detalles tecnicos aqui) pero es comercial (y estamos hablando de muchos $$$) y es por eso que se crearon soluciones gratuitas como son el BlazeDs y GraniteDS.

Para no hacerla mas larga y comenzar a trabajar con Granite resaltare las direcencias mas importantes y por las cuales me han hecho elegir dicho framework :

  • Granite tiene mas de 10 tipos de integración con las tecnologías mas resaltantes como son : POJOs, Guice, OpenJpa, jboss seam, toplink,maven, ant , etc. Blaze tiene para spring , ant y maven por resaltar las mas importantes.
  • · Granite puede trabajar con pojos directamente sin afectar su performance, en cambio Blaze es usado mas que todo con Spring.
  • El uso de Externalizers , es decir, actualmente usando la serializacion estándar de AMF3 (tanto en Blaze como en LCDS) solo las propiedades no-transient ni static public podrían ser serializadas. Adicional se puede evitar enviar información de las propiedades prívate pero para eso es necesario implementar las clases (tanto en java como en as3) como Externalizable. Esta es una tarea larga y tediosa y propensa a errores. Con Granite solo nos preocupamos por la parte flex y dejamos en paz la parte java usando los Externalizers.
  • BlazeDs en realidad es una versión lite de LCDS, es decir, solo tiene algunas de su funcionalidades como vemos en la imagen. Una de ellas el data management (el manejo de las relaciones entre los objetos de negocio en la bd cortesía de Hibernate). Granite soporta dicha funcionalidad.

dibujo

Ahora si por fin vamos a meternos de llenos. Para crear nuestro primer proyecto necesitamos estar herramientas

  • · Granite DS 2.0 Beta : Dentro de las carpetas encontraremos la carpeta build con los archivos granite.jar para java y granite.swc para flex.
  • · Flex Builder 3(o el eclipse con el plugin).
  • · Eclipse 3.x (el que mas te guste.
  • · Y nada mas.. manos a la obra

Creando nuestro ejemplo


1. Creamos nuestro proyecto en flex ( sin mayores configuraciones puro NEXT noma a todo).

    2. En eclipse creamos un proyecto web dinamico y en dicho proyecto copiamos las librerías granite.jar. Adicionalmente creamos los archivos WEB-INF/flex/services.config.xml y WEB-INF/granite/granite-config.xml a nuestro proyecto (también pueden copiarlo directamente del descargable en la ubicación examples/graniteds_pojo).

3. Luego que tenemos la librería y los archivos creados modificamos nuestro web.xml

<filter>
<filter-name>AMFMessageFilter</filter-name>
<filter-class>org.granite.messaging.webapp.AMFMessageFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>AMFMessageFilter</filter-name>
<url-pattern>/graniteamf/*</url-pattern>
</filter-mapping>
<servlet>
<servlet-name>AMFMessageServlet</servlet-name>
<servlet-class>org.granite.messaging.webapp.AMFMessageServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>AMFMessageServlet</servlet-name>
<url-pattern>/graniteamf/*</url-pattern>
</servlet-mapping>

Con esto tenemos la url para  la comunicación via AMF desde flex con java.

4. Creamos una clase java denominada LoginUser con un método que use como argumentos 2 cadenas para simular un logeo de un usuario y que devuelva el mensaje correspondiente.

package test.granite.login;

import java.io.Serializable;

public class LoginUser implements Serializable {

private static final long serialVersionUID = 1L;

private static final String USER_CORRECT = “Ricardo”;

private static final String PASS_CORRECT = “1234”;

public String login(String user, String pass) {

String mensaje = “”;

if(user.equals(USER_CORRECT) && pass.equals(PASS_CORRECT))

{

mensaje = “Bienvenido Ricardo”;

}else{

mensaje = “Su usuario es incorrecto, vuelvalo a intentar”;

}

return mensaje;

}

}

Luego de crear nuestra clase iremos a registrarla.

5 . El archivo que nos importa por ahora en el service-config.xml que si lo haz copiado del ejemplo que viene en granite te daras cuenta de ciertas partes resaltantes. Aca esta el código final para este ejemplo.

<services-config>
<services>
<service
id=“granite-service”
class=“flex.messaging.services.RemotingService”
messageTypes=“flex.messaging.messages.RemotingMessage”>
<destination id=“login”>
<channels>
<channel ref=“my-graniteamf”/>
</channels>
<properties>
<scope>session</scope>
<source>test.granite.login.LoginUser</source>
</properties>
</destination>
</service>
</services>
<channels>
<channel-definition id=“my-graniteamf” class=“mx.messaging.channels.AMFChannel”>
<endpoint
uri=http://{server.name}:{server.port}/{context.root}/graniteamf/amf”
class=“flex.messaging.endpoints.AMFEndpoint”/>
</channel-definition>
</channels>
</services-config>

Como vemos registramos tantos destination como clases vamos a exponer. Luego dichos destinos usan el mismo canal definido abajo que es la ruta para la comunicación con el servidor (el cual apuntaremos desde flex).

Luego en la clase granite-config.xml lo dejamos solo con este par de líneas

<granite-config>
</granite-config>

Por ahora no se necesita mas configuración para poder trabajar con nuestras clases.

Nota : La ubicación de estos 2 archivos por defecto son las explicadas arriba pero si se desea cambiar dicha ubicación se puede lograr mediante el siguiente código en el web.xml :

<context-param>
<param-name>servicesConfigPath</param-name>
<param-value>/WEB-INF/flex/services-config.xml</param-value>
</context-param>
<context-param>
<param-name>graniteConfigPath</param-name>
<param-value>/WEB-INF/granite/granite-config.xml</param-value>
</context-param>

Listo! Levantamos nuestro proyecto usando tu contenedor favorito (el mio sigue siendo el tomcat ) y ahora avanzamos la parte flex.

6. En el mxml generado creamos nuestro RemoteObject para la comunicación con el servidor

<mx:RemoteObject id=”loginUser” destination=”login” result=”resultado(event)” concurrency=”single” fault=”error(event)” showBusyCursor=”true”>

<mx:channelSet>

<mx:ChannelSet>

<mx:channels>

<mx:AMFChannel id=”my-graniteamf”

uri=”http://localhost:8080/GraniteTest/graniteamf/amf”/&gt;

</mx:channels>

</mx:ChannelSet>

</mx:channelSet>

</mx:RemoteObject>

Usamos la ruta que fue especificada en nuestro service-config.xml y también cambiamos el destination al registrado por nosotros ( en este caso login).

7. Agreamos un panel con 2 cajas de texto , un label y un botón para una minima pantalla del login.

login

8. Implementamos los métodos resultado(event) y error(event) para manejar las respuesta del servidor

<mx:Script>
<![CDATA[
import mx.collections.ArrayCollection;
import mx.rpc.events.ResultEvent;
import mx.controls.Alert;
import mx.rpc.events.FaultEvent;
public function error(e:FaultEvent):void
{
msj.text = e.message.toString();
}
public function resultado(e:ResultEvent):void
{
msj.text = e.result as String ;
}
]]>
</mx:Script>

El error sera llamado cuando exista un problema de conexión como timeout, servidor caído, etc. Implementamos el método click para el botón con el siguiente código

<mx:Button x=”155″ y=”86″ label=”Enviar” click=”{loginUser.login(user.text,pass.text)}”/>

Esta es la manera simple de llamar al metodo.

Ahora a probar!

login1

login2

Como vemos funciona a la perfeccion y sin demora alguna. Podemos también manejar sesiones con dichos objetos en el caso que queramos manejar el login para que almacene el usuario.

Mas adelante posteare sobre las configuraciones y el manejo de sesiones usando Granite. Cualquier pregunta me la hacen llegar. Adjunto el código del proyecto en flex y en el de java.

Advertisements

3 Responses to Primeros pasos con graniteDS y java

  1. Jorge A. says:

    Saludos muy buen ejemplo para empezar a utilizar granite, actualmente utilizo blaze, pero no soporta trabajar con hibernate, por lo cual decidi cambiar a granite, solo que al intentar realizar el ejemplo que expones, me sale un error en la siguiente linea del mxml:

    Sysntax error: espectin semicolon before minus

    me gustaria saber si puedes enviar el codigo del ejemplo a mi correo, t agardesco por tu ayudo saludos bye

    • ricdex says:

      Gracias por tu comentario. Actualmente me encuentro en un nuevo blog:

      http://blog.govisualperu.com/?p=3

      si puedes revisalo ya que he formateado mejor el codigo y si aun necesitas ayuda te envio el codigo para tu correo.
      Gracias!

    • ricdex says:

      Y tienes mucha razon , BlazeDS no soporta el lazy loading que ofrece Hibernate . Actualmente estoy en un proyecto que si o si se necesitaba JPA con Hibernate asi que tube que usar una libreria adicional : dphibernate para poder soportar el lazy. Pero aun asi ofrece ciertos incovenientes.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: