Tratamiento de excepciones de Java en Flex utilizando el paquete de integración de Spring con BlazeDS


  1. Introducción
  2. Desarrollo
  3. Conclusiones

Spring tiene un proyecto, denominado Spring BlazeDS Integration, cuyo objetivo es facilitar el desarrollo de aplicaciones ricas de internet que utilicen java y Spring en el back end y Adobe Flex en el front end. Con este proyecto podemos exponer como destinos remotos objetos gestionados por el contenedor, de modo que podamos invocar desde Flex sus métodos, hacer uso de las facilidades del Data Centric Development de Flash Builder 4 y dar tratamiento personalizado a las excepciones de Java, entre otras cosas.

Introducción

Normalmente en el código Java, y más frecuentemente en la capa de acceso a datos, se pueden generar excepciones que se propagan hasta la interfaz de usuario. Si por ejemplo utilizamos un componente RemoteObject para invocar un método de una clase Java, y éste genera una excepción durante su ejecución, podemos acceder a la información de ésta si hemos definido un manejador para el evento “fault” del componente.

Como sabemos, las excepciones de Java pueden ser disímiles, y atendiendo a la condición que las causa la cantidad de información que portan es variable. Las excepciones generadas por las operaciones de acceso a datos son por lo general muy explicativas, e incluyen prácticamente un reporte detallado de la causa, que puede ser una violación de integridad referencial, una violación de llave duplicada, etc. Esta información por lo general se encuentra fuera de dominio de los usuarios finales de la aplicación y además de abrumarlos no les aporta información útil. En estas condiciones es cuando puede ser útil un mecanismo que traduzca esas excepciones en otras que porten información útil para el usuario final.

Desarrollo

Para mostrar el funcionamiento del mecanismo de traducción de excepciones del paquete de integración de Spring con BlazeDS, desarrollaremos una pequeña aplicación de ejemplo en la que desde Flex invoquemos un método de Java que genere una excepción y veremos cómo se maneja, luego incorporaremos el mecanismo de traducción de excepciones, invocaremos nuevamente el método y compararemos los resultados.

Como entorno de trabajo utilizaremos Flash Builder 4 plug-in instalado sobre el paquete galileo del Eclipse IDE for Java EE Developers, BlazeDS 4, spring-framework-3.0.2.RELEASE y spring-flex-1.0.3.RELEASE.

Comenzaremos por crear un proyecto combinado Flex/Java:

Clipboard01
Clipboard02

A continuación añadiremos todo lo que tiene que ver con Spring al proyecto.

  1. Una vez descargado el framework spring extraemos en la carpeta ExceptionTranslationDemo\WEB-INF\lib\ el contenido de la carpeta “dist” del archivo previamente descargado.
  2. Descargamos “cglib-nodep-2.2.jar” y lo copiamos en ExceptionTranslationDemo\WEB-INF\lib\
  3. Descargamos “backport-util-concurrent.jar” y lo copiamos en ExceptionTranslationDemo\WEB-INF\lib\
  4. Descargamos “aopalliance.zip” y copiamos el archivo “aopalliance.jar” en ExceptionTranslationDemo\WEB-INF\lib\
  5. Descargamos “spring-flex-1.0.3.RELEASE.zip” y copiamos los archivos de la carpeta “dist” en ExceptionTranslationDemo\WEB-INF\lib\

Para configurar la integración de Spring con BlazeDS, modificamos el archivo “web.xml” que se encuentra en ExceptionTranslationDemo\WEB-INF para que quede de la siguiente manera:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
  3. <web-app>
  4.  
  5.     <display-name>BlazeDS</display-name>
  6.     <description>BlazeDS Application</description>
  7.  
  8.     <listener>
  9.         <listener-class>flex.messaging.HttpFlexSession</listener-class>
  10.     </listener>
  11.    
  12.     <servlet>
  13.         <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
  14.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  15.         <init-param>
  16.             <param-name>contextConfigLocation</param-name>
  17.             <param-value>/WEB-INF/spring/web-application-config.xml</param-value>
  18.         </init-param>
  19.         <load-on-startup>1</load-on-startup>
  20.     </servlet>
  21.  
  22.     <servlet-mapping>
  23.         <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
  24.         <url-pattern>/messagebroker/*</url-pattern>
  25.     </servlet-mapping>
  26.  
  27.     <servlet>
  28.         <servlet-name>RDSDispatchServlet</servlet-name>
  29.         <display-name>RDSDispatchServlet</display-name>
  30.         <servlet-class>flex.rds.server.servlet.FrontEndServlet</servlet-class>
  31.         <init-param>
  32.             <param-name>useAppserverSecurity</param-name>
  33.             <param-value>false</param-value>
  34.         </init-param>   
  35.         <init-param>
  36.             <param-name>messageBrokerId</param-name>
  37.             <param-value>_messageBroker</param-value>
  38.         </init-param>    
  39.     <load-on-startup>10</load-on-startup>
  40.     </servlet>
  41.  
  42.     <servlet-mapping id="RDS_DISPATCH_MAPPING">
  43.         <servlet-name>RDSDispatchServlet</servlet-name>
  44.         <url-pattern>/CFIDE/main/ide.cfm</url-pattern>
  45.     </servlet-mapping>
  46.  
  47.     <welcome-file-list>
  48.         <welcome-file>index.html</welcome-file>
  49.         <welcome-file>index.htm</welcome-file>
  50.     </welcome-file-list>
  51.  
  52. </web-app>

Seguidamente modificamos la sección “<services></services>” del archivo “services-config.xml” que se encuentra en ExceptionTranslationDemo\WEB-INF\flex\, y que originalmente viene así:

PLAIN TEXT
XML:
  1. <services>
  2.     <service-include file-path="remoting-config.xml" />
  3.     <service-include file-path="proxy-config.xml" />
  4.     <service-include file-path="messaging-config.xml" />       
  5.  </services>

Para que quede de esta manera:

PLAIN TEXT
XML:
  1. <services>
  2.     <default-channels>
  3.         <channel ref="my-amf"/>
  4.     </default-channels>
  5. </services>

Dentro de ExceptionTranslationDemo\WEB-INF creamos la carpeta “spring” y en ella creamos el archivo web-application-config.xml con el siguiente contenido:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:flex="http://www.springframework.org/schema/flex"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="
  6.     http://www.springframework.org/schema/beans
  7.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8.     http://www.springframework.org/schema/flex
  9.     http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
  10.  
  11.     <flex:message-broker/>
  12. </beans>

Lo próximo que haremos será crear una clase con un método donde se realice una operación que genera una excepción. Dentro de la carpeta “src” del proyecto crearemos el paquete “com.et.services” y dentro crearemos la clase “ExceptionTranslationService.java” con el siguiente código:

PLAIN TEXT
JAVA:
  1. package com.et.services;
  2.  
  3. public class ExceptionTranslationService {
  4.  
  5.     public void generateException(){
  6.         Object x = new Integer(0);
  7.         ((String)x).concat("123");
  8.     }
  9. }

Como vemos, la línea “((String)x).concat("123");“ generará una excepción de tipo “ClassCastException”. Ahora crearemos una interface de usuario sencilla que invoque el método a través de un objeto “RemoteObject” y veremos lo que ocurre, pero primeramente registramos un objeto de tipo “ExceptionTranslationService” en Spring y lo publicamos como destino remoto. El archivo “web-application-config.xml” queda ahora de la siguiente manera:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:flex="http://www.springframework.org/schema/flex"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="
  6.     http://www.springframework.org/schema/beans
  7.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8.     http://www.springframework.org/schema/flex
  9.     http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
  10.  
  11.     <flex:message-broker/>
  12.  
  13.     <bean id="ExceptionTranslationBean" class="com.et.services.ExceptionTranslationService">
  14.         <flex:remoting-destination/>
  15.     </bean>
  16.    
  17. </beans>

Nuestra interfaz de usuario, definida en el archivo “ExceptionTranslationDemo.mxml” en la carpeta “flex-src” queda así:

PLAIN TEXT
MXML:
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
  3.             xmlns:s="library://ns.adobe.com/flex/spark"
  4.             xmlns:mx="library://ns.adobe.com/flex/mx"
  5.             minWidth="955" minHeight="600">
  6.     <s:layout>
  7.         <s:VerticalLayout/>
  8.     </s:layout>
  9.    
  10.     <fx:Script>
  11.         <![CDATA[
  12.             import mx.controls.Alert;
  13.         ]]>
  14.     </fx:Script>
  15.    
  16.     <fx:Declarations>
  17.         <s:RemoteObject
  18.             id="ExceptionTranslationRO"            
  19.             destination="ExceptionTranslationBean"
  20.             showBusyCursor="true"            
  21.             fault="Alert.show(event.fault.faultString + '\n' + event.fault.faultDetail)"/>
  22.        
  23.         <!-- Place non-visual elements (e.g., services, value objects) here -->
  24.     </fx:Declarations>
  25.    
  26.     <s:Button label="Genera Excepcion"
  27.         click="ExceptionTranslationRO.generateException()"/>
  28. </s:Application>

Compilamos el proyecto, desplegamos la aplicación en Tomcat y cuando la corremos y oprimimos el botón obtenemos este mensaje de error:

Clipboard03

La información de la excepción generada por el método Java llegó a Flex a través de las propiedades “faultString” y “faultDetails” del objeto “event.fault” del manejador del evento “fault” del componente “RemoteObject”. Estas propiedades contienen la misma información que las propiedades del mismo nombre del objeto “event.message”, que es de tipo “mx.messaging.messages.ErrorMessage”, la propiedad “rootCause” de esta clase contiene toda la información del objeto “Throwable” de Java.

Lo que haremos será interceptar el objeto “Throwable” de Java (del cual heredan las excepciones) en su tránsito hacia Flex y en su lugar generar un objeto de tipo “flex.messaging.MessageException” con la información personalizada, para lo cual nos auxiliaremos del mecanismo de traducción de excepciones del paquete spring-flex.

Comenzamos por crear el paquete “com.et.exceptions” dentro de la carpeta “src” del proyecto y dentro creamos la clase “CustomExceptionTranslation.java” que implementa la interface “org.springframework.flex.core.ExceptionTranslator”:

PLAIN TEXT
JAVA:
  1. package com.et.exceptions;
  2.  
  3. import org.springframework.flex.core.ExceptionTranslator;
  4.  
  5. import flex.messaging.MessageException;
  6.  
  7. public class CustomExceptionTranslation implements ExceptionTranslator {
  8.  
  9.     @Override
  10.     public boolean handles(Class<?> arg0) {
  11.         // TODO Auto-generated method stub
  12.         return false;
  13.     }
  14.  
  15.     @Override
  16.     public MessageException translate(Throwable arg0) {
  17.         // TODO Auto-generated method stub
  18.         return null;
  19.     }
  20. }

El método “handles” indica cuándo se invoca al método “translate” ante una excepción dada, en nuestro caso el método “handles” queda así:

PLAIN TEXT
JAVA:
  1. public boolean handles(Class<?> arg0) {
  2.     if(arg0.isInstance(new ClassCastException())){
  3.         return true;
  4.     }
  5.     return false;
  6. }

Y el método “translate” así:

PLAIN TEXT
JAVA:
  1. public MessageException translate(Throwable arg0) {
  2.     if(arg0 instanceof ClassCastException){
  3.         MessageException result = new MessageException();
  4.         result.setDetails("No se puede convertir un Integer en un String");
  5.         result.setMessage("Error de conversion de tipo");
  6.         return result;
  7.     }
  8.     return null;
  9. }

Finalmente registramos el objeto de tipo “CustomExceptionTranslation” en Spring e informamos al “MessageBroker” que lo use como traductor de excepciones, el archivo “web-application-config.xml” queda finalmente de la siguiente manera:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:flex="http://www.springframework.org/schema/flex"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="
  6.     http://www.springframework.org/schema/beans
  7.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8.     http://www.springframework.org/schema/flex
  9.     http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
  10.  
  11.  
  12.     <bean id="CustomExceptionTranslation" class="com.et.exceptions.CustomExceptionTranslation"/>
  13.    
  14.     <flex:message-broker>
  15.         <flex:exception-translator ref="CustomExceptionTranslation"/>
  16.     </flex:message-broker>
  17.  
  18.     <bean id="ExceptionTranslationBean" class="com.et.services.ExceptionTranslationService">
  19.         <flex:remoting-destination/>
  20.     </bean>
  21.    
  22. </beans>

Compilamos el proyecto, redesplegamos la aplicación y cuando la corremos nuevamente obtenemos lo siguiente:

Clipboard04

Como vemos, la excepción original fue interceptada y en su lugar llegó a Flex un objeto de tipo MessageException con información personalizada, el código Flex no sufrió ninguna alteración. El proyecto final (sin el contenido de ExceptionTranslationDemo\WEB-INF\lib\) se puede bajar aqui.

Conclusiones

Hemos visto como utilizar el mecanismo de traducción de excepciones de Java a Flex que incorpora spring-flex y su utilidad utilizando una excepción “sencilla”, pero si en vez de ser una excepción de este tipo hubiera sido alguna de las generadas por la capa de acceso a datos (utilizando Hibernate, iBatis o JPA), la cantidad de información que llega al cliente es considerablemente mayor y carente de sentido para el usuario final. Por ejemplo, el siguiente mensaje se obtiene ante una excepción generada por la capa de acceso a datos en una aplicación que no usa el mecanismo de traducción:

Clipboard05

Luego de incorporar el mecanismo de traducción de excepciones el mensaje obtenido es el siguiente:

Clipboard06

El código Flex no fue modificado en absoluto.

Comparte:



4votos  Vota!!

Acerca de esta entrada

Usted está leyendo “Tratamiento de excepciones de Java en Flex utilizando el paquete de integración de Spring con BlazeDS,” una entrada de MadeInFlex

Autor: Nono F. Carballo Escalona
Ver
otras entradas del autor
Publicada:
04.06.10 / 1am
Categorías:
Artículos
Entradas relacionadas:
  • BlazeDS más cerca de Spring
  • Clear Toolkit ahora con soporte para Spring
  • Granite Data Services 1.0.0
  • Clear Toolkit para el desarrollo de aplicaciones Flex
    • Número de visitas:
    4128