Download FDS2 en ejemplos

MIFMadeInFlex
Online I
“Título de la Charla”
FDS2 en ejemplos
Autor
Correo del Autor
Por Carlos Rovira
[email protected]
¿Qué es Flex Data Services 2?
• Es el “esqueleto” de una RIA Flex 2 que nos da
funcionalidades avanzadas para comunicar
distintos clientes Flex con la lógica de negocio.
• Aplicación Web Java (.war).
• Soporta la mayoría de servidores Java actuales
(JBoss, Tomcat, Weblogic,…)
• Facilita enormemente la producción de una RIA.
• Existen versiones gratis y empresariales.
¿Qué ofrece?
• Corazón -> Bus de Mensajería
• Remote Objects:
– RPC a objetos Java (AMF3).
• Flex Message Service:
– Aplicaciones colaborativas.
– Mensajería en tiempo real con “push” de datos al cliente
(RTMP).
• Flex Data Management:
– Orientación al dato vs Orientación al RPC
– Gestión, sincronización y persistencia de los datos (a nivel de
cliente).
– Paginación, resolución de conflictos,…
• Otros: Flex Proxy Service, Seguridad y mucho más
Arquitectura FDS2
RemoteObjects
Características
• Similar a Web Services
• Llamadas remotas(RPC) a Objetos Java
• Protocolo AMF3 (binario, basado en SOAP,
sobre HTTP)
• Serialización/Deserialización transparente para
el desarrollador
• Mejor rendimiento que un Web Service.
Ejemplo
• Declaración:
– <mx:RemoteObject id="countrys_ro" destination="userService“ result="
countriesResultHandler(event)“ fault=“countriesFaultHandler(event)”/>
• Inicialización:
– creationComplete="countrys_ro.getAllCountries()“
• Resolución:
– import mx.rpc.events.ResultEvent;
– private function countriesResultHandler(event:ResultEvent):void {
countries_cmb.dataProvider = event.result as ArrayCollection
}
• Fallo:
– import mx.rpc.events.FaultEvent;
– private function countriesFaultHandler(event:ResultEvent):void {
Alert.show (event.fault.faultCode, event.fault.faultString);
}
Configuración
Configuración en el servidor (remoting-config.xml):
<destination id="countryService">
<properties>
<source>com.mif.fds.CountryService</source>
<scope>application</scope>
</properties>
</destination>
Flex Message Service
Flex Message Service
• Corazón de FDS2
• Intercambio de mensajes en tiempo real
• Protocolo RTMP(Real Time Message Protocol).
Solo datos (ver FMS2 para streaming audio/video).
• “Push” de datos a los clientes conectados
(comunicación Servidor -> Cliente)
• Creación de aplicaciones colaborativas (ejemplo
básico: Chat)
Adaptadores
• Determinan que aplicaciones cliente participan en la
mensajería.
• 2 tipos:
– Actionscript. Para aplicaciones en las que solo intervienen
clientes Flex. (es el usado por defecto)
– JMS. Permite usar clientes Flex y JMS (clientes java con
SWING, AWT,…)
• Se configura en messaging-config.xml
– <adapters>
<adapter-definition id="actionscript…
• Usado en destinations:
– <adapter ref=“jms”/>
Canales
• Deciden como se formatean y circulan los mensajes por
la red
• 2 tipos de protocolos sobre los que se construyen los
canales:
– RTMP: “push” de datos desde el servidor.
– AMF: Mensajes por sondeo o petición
(existen canales securizados y encripatados basados en estos
protocolos).
• Usado en destinations:
<channels>
<channel ref=“my-rtmp”/>
<channels>
Ejemplo
•
•
•
•
Declaración:
– <mx:Producer id="producer" destination="chatDestination"/>
– <mx:Consumer id="consumer" destination="chatDestination”
message="messageHandler(event)"/>
El consumidor se suscribe:
– consumer.subscribe();
El Productor manda mensajes
– import mx.messaging.messages.AsyncMessage;
– var message:AsyncMessage = new AsyncMessage();
– message.headers.user = userlist.selectedItem.name;
– message.body = msg_ta.text;
– producer.send(message);
El Consumidor gestiona los mensajes que le llegan:
– import mx.messaging.events.MessageEvent;
– private function messageHandler(event:MessageEvent):void {
If(data.data.name == event.message.headers.user)
msg_ta.text = "" + event.message.body;
}
Configuración
Configuración en el servidor (messaging-config.xml):
<destination id="chatDestination">
<channels>
<channel ref="my-rtmp"/>
</channels>
</destination>
(Nota: usa el adaptador de actionscript por defecto)
Flex Data Management Service
Carácteristicas
• Basado en Flex Message Service (Permite
actualizar los datos de los clientes conectados)
• Sincronización
• Persistencia
• “Orientación a Datos” vs “Orientación a RPCs”
• APIs en cliente y servidor que manejan
automática operaciones CRUD.
Adaptadores
• Determinan la persistencia de los datos.
• Se incluyen 2:
– Java (java-dao): Usa clases java para transferir los datos con
una fuente de datos (BD, XML, ...)
• Por ejemplo se puede usar un driver JDBC para conectar a una
base de datos
– Actionscript: Guarda los datos en la memoria del servidor. Estos
persisten mientra FDS esté levantado.
• Configuración en “data-management-config.xml”
– <adapters>
<adapter-definition id="actionscript
• Usado en destinations:
– <adapter ref=“java-dao”/>
Configuración
<destination id="users">
Clase Assembler de destino
<adapter ref="java-dao" />
Garantiza que los elementos de la
<properties>
Colección son únicos
<source>com.mif.fds.UserAssembler</source>
<scope>application</scope>
<metadata><identity property="userId"/></metadata>
<network>
<session-timeout>20</session-timeout>
<paging enabled="false" pageSize="10" />
<throttle-inbound policy="ERROR" max-frequency="500"/>
<throttle-outbound policy="REPLACE" max-frequency="500"/>
</network>
<server>
métodos del Assembler:
<fill-method><name>getUsers</name></fill-method>
*fill
<fill-method>
*sync
<name>getUsersByCountry</name>
*count
<params>java.lang.String</params>
*get
</fill-method>
<sync-method><name>syncUsers</name></sync-method>
</server>
</properties>
</destination>
Assembler
Assembler
Cliente
Flex
VO
FDS2
DAO
BD
Patrón Assembler
• Es el encargado de “ensamblar” El API
de FDS con nuestro DAO:
fill (Assembler)  getUsers (DAO)
• La información entre las capas viaja a
través de Vos (mapeo de POJOs)
Value Object (o DTO)
Representación de los datos en ambas capas (cliente y servidor):
package com.mif.fds {
*Implementa mx.data.IManaged
*automáticamente [Bindable]
[Managed]
[RemoteClass(alias="com.mif.fds.User")]
public class User {
public var userId:String;
public var name:String;
VO Equivalente en Java
public var email:String;
public var country:String;
}
}
Ejemplo FILL
• Declaración
– <mx:DataService id="users_ds" destination="users“
result="graphOperations(event)"/>
– <mx:ArrayCollection id="users_ac"/>
• Uso
– import mx.rpc.AsyncToken;
– private function getUsers():void {
var token:AsyncToken = users_ds.fill(users_ac);
token.operation = "fill";
}
• Asociar comportamientos adicionales al Resultado:
– private function graphOperations(event:ResultEvent):void {
if (event.token.operation == "fill") { …
Operaciones CRUD
• <sync-method><name>syncUsers</name></sync-method>
• public List syncUsers(List changes) {
Iterator iterator = changes.iterator();
ChangeObject co;
while (iterator.hasNext()) {
co = (ChangeObject)iterator.next();
if (co.isCreate()) {
co = createUser(co);
} else if (co.isDelete()) {
deleteUser(co);
} else if (co.isUpdate()) {
updateUser(co);
}
}
return changes;
}
• Añadir y Borrar datos
• Editar
– <mx:DataGrid dataProvider="{users_ac}
… editable="true“
• autoCommit=“false”
• TraceTarget
– <mx:TraceTarget />
– Muestra el contenido de los mensajes cuando
depuramos.
Características Avanzadas
• Paginación: Podemos configurar el tamaño del conjunto
de datos que pidamos, de forma que FDMS se encarga
de enviar automáticamente la porción de datos
apropiada en cada momento según operemos con los
componentes en cliente.
– <paging enabled=“true" pageSize=“20" />
• Resolución de conflictos: Estos se generan cuando
dos o mas usuarios están editando los mismos datos
simultáneamente. FDMS nos permite decidir que hacer
en estas situaciones. (DataConflictEvent)
• Relación de datos anidados: Es decir la gestión
automática de relaciones "1 a 1", "1 a muchos" y
"muchos a muchos". Configurado dentro del destination
en <metadata>
FIN
Carlos Rovira
http://www.madeinflex.com
http://www.carlosrovira.com
[email protected]