FlexRest
1.5
Existem vários filtros de serialização personalizados que podem facilitar sua vida (requer Flex 4).
Implementação do padrão de projeto composto para filtros de serialização HTTP . Substitua qualquer um dos 5 métodos do Filter de Serialização usando diferentes instâncias de filtro:
<mx:HTTPService>
<mx:serializationFilter>
<rest:CompositeSerializationFilter>
<!-- Serialize requests in JSON -->
<rest:bodySerializer>
<rest:JSONSerializationFilter />
</rest:bodySerializer>
<!-- Deserialize replies in JSON -->
<rest:resultDeserializer>
<rest:JSONSerializationFilter />
</rest:resultDeserializer>
<!-- Build REST-style URLs dynamically -->
<rest:urlSerializer>
<rest:RESTSerializationFilter />
</rest:urlSerializer>
<!-- Use custom HTTP methods -->
<rest:parametersSerializer>
<rest:RESTSerializationFilter />
</rest:parametersSerializer>
<!-- Set request content type to application/json -->
<rest:contentTypeProvider>
<rest:RESTSerializationFilter requestContentType="application/json" />
</rest:contentTypeProvider>
</rest:CompositeSerializationFilter>
</mx:serializationFilter>
</mx:HTTPMultiService>Os métodos do Filter de Serialização que podem ser superestimados:
deserializeResultgetRequestContentTypeserializeParametersserializeBodyserializeURLOs métodos que não são substituídos são tratados usando um filtro de serialização regular.
Implementa os métodos serializeParameters , contentTypeProvider e serializeURL .
Permite enviar verbos HTTP personalizados, além de obter ou postar , o que não é suportado pelo flash player por padrão. Você pode especificar uma das três maneiras possíveis de fazer isso:
methodOverride="header" ). Não se esqueça de atualizar seu arquivo crossDomain.xml para permitir que os cabeçalhos sejam enviados para outros domínios._method a todos os URLs ( methodOverride="url" )._method ( methodOverride="variable" ). Isso forçará sua solicitação a ser serializada como application/x-www-form-urlencoded .Esse filtro de serialização também pode ser usado para criar URLs dinâmicos que contribuem parâmetros tokenizados (entre colchetes quadrados).
<fx:Declarations>
<rest:RESTSerializationFilter
id="restSerializer"
methodOverride="variable"
requestContentType="application/x-www-form-urlencoded" />
<mx:HTTPMultiService
id="service"
baseURL="http://example.com/api/"
>
<mx:serializationFilter>
<!-- contentTypeProvider is required in order to convert custom HTTP verbs to POST
and to set content type to 'application/x-www-form-urlencoded'. -->
<!-- urlSerializer will replace square bracket tokens in URLs. -->
<!-- parametersSerializer will add a '_method' variable to your requests, if needed. -->
<rest:CompositeSerializationFilter
contentTypeProvider="{restSerializer}"
urlSerializer="{restSerializer}"
parametersSerializer="{restSerializer}" />
</mx:serializationFilter>
<mx:operationList>
<!--
[ID] and any other token will be automatically
replaced by variables from operation arguments object
-->
<mx:HTTPOperation
name="getUser"
url="User/[ID]" />
<!--
Request will be sent as a POST request
with a "_method"="DELETE" variable
-->
<mx:HTTPOperation
name="deleteUser"
url="User/[ID]"
method="DELETE" />
</mx:operationList>
</mx:HTTPMultiService>
</fx:Declarations> import mx.rpc.AbstractOperation;
import mx.rpc.AsyncToken;
import vo.User;
private function getUser(userId:uint):AsyncToken
{
var operation:AbstractOperation = service.getOperation("getUser");
operation.arguments = { ID: userId }; //replace URL tokens
return operation.send();
//You can also add your variable to requests:
//return operation.send({ varname: "varvalue" });
} Implementa os métodos deserializeResult , contentTypeProvider e serializeBody .
Solicitações serializadas e Desserialize Responses in JSON com um analiser JSON nativo rápido (apenas na versão FP11; a versão FP9 está dependendo do analisador JSON do AS3Corelib). Solicitações e respostas podem ser convertidas de objetos fortemente ticados em tempo real. Os seguintes recursos de mapeamento de objetos estão disponíveis:
ArrayElementType Metatag pode ser usado para mapear matrizes de objetos digitados.Transient é respeitado em solicitações e respostas./Date(1325376000000)/ pode ser convertido em objetos Date e vice -versa. Por exemplo, quando você recebe isso:
{
"owner":{
"birthday":"/Date(1325376000000)/",
"firstName":"John",
"lastName":"Smith"
}
"wheels":[
{ "position": { "x":1, "y":1 } },
{ "position": { "x":1, "y":-1 } },
{ "position": { "x":-1, "y":1 } },
{ "position": { "x":-1, "y":-1 } }
]
}
public class User
{
public var birthday:Date;
public var firstName:String;
public var lastName:String;
}
public class Car
{
public var owner:User;
[ArrayElementType("vo.Wheel")]
public var wheels:Array;
//You can just use vectors instead
//public var wheels:Vector.<Wheel>
}
import flash.geom.Point;
public class Wheel
{
public var position:Point;
} <fx:Declarations>
<mx:HTTPMultiService
id="service"
baseURL="http://example.com/api/"
>
<mx:serializationFilter>
<rest:CompositeSerializationFilter>
<!-- Serialize requests from objects to JSON. -->
<rest:bodySerializer>
<rest:JSONSerializationFilter />
</rest:bodySerializer>
<!-- Deserialize replies from JSON to strongly-typed objects. -->
<rest:resultDeserializer>
<rest:JSONSerializationFilter />
</rest:resultDeserializer>
<!-- Forces requests content type to be 'application/json'.
This is required in order to encode requests in JSON.
If content type is not changed either this way,
or manually on an operation, Flex will handle
request body encoding by itself. -->
<rest:contentTypeProvider>
<rest:RESTSerializationFilter requestContentType="application/json" />
</rest:contentTypeProvider>
<!-- This serializer is required for JSON requests. -->
<rest:parametersSerializer>
<rest:RESTSerializationFilter />
</rest:parametersSerializer>
</rest:CompositeSerializationFilter>
</mx:serializationFilter>
<mx:operationList>
<!--
Note that there is a resultElementType
property set on the operation
-->
<mx:HTTPOperation
name="getCar"
url="Car/[ID]"
method="GET"
resultElementType="{Car}"
result="onCarLoaded(event)" />
</mx:operationList>
</mx:HTTPMultiService>
</fx:Declarations> import mx.rpc.events.ResultEvent;
import vo.Car;
import vo.User;
import vo.Wheel;
private function onCarLoaded(event:ResultEvent):void
{
var car:Car = Car(event.result);
var wheels:Vector.<Wheel> = car.wheels;
var owner:User = car.owner;
var birthday:Date = owner.birthday;
} Se você tem uma variedade de objetos ...
[
{ "x":1, "y":5 },
{ "x":2, "y":4 },
{ "x":3, "y":3 },
{ "x":4, "y":2 },
{ "x":5, "y":1 }
]resultFormat="array" e resultElementType="{ElementClass}" . Por padrão, todas as matrizes são embrulhadas em um ArrayCollection . Para evitar esse comportamento, basta definir makeObjectsBindable="false" na instância de operação. <mx:HTTPOperation
name="getPoints"
url="Points/[FROM]/[TO]"
resultFormat="array"
makeObjectsBindable="false"
resultElementType="{Point}"
result="onPointsLoaded(event)" /> private function onPointsLoaded(event:ResultEvent):void
{
trace(event.result.length);
for each(var point:Point in event.result)
trace(point.x + point.y);
} JSONSerializationFilter é uma implementação de um filtro TypedSerializationFilter abstrato que lida com a transformação dos tipos, enquanto uma classe infantil concreta lida com a serialização e desesterização reais dos dados.
Configurar resultFormat para qualquer outro valor, além de array e object (padrão), resultará em um JSONSerializationFilter (ou qualquer outro TypedSerializationFilter ) para ser suprimido em uma HTTPOperation selecionada.
Implementa os métodos deserializeResult , contentTypeProvider e serializeBody .
Atua da mesma maneira que o JSONSerializationFilter . Você pode usar as propriedades opcionais xmlEncode e xmlDecode para atribuir métodos de serialização personalizados:
<mx:HTTPService>
<mx:serializationFilter>
<rest:CompositeSerializationFilter>
<!-- Serialize requests from objects to XML. -->
<rest:bodySerializer>
<rest:XMLSerializationFilter xmlEncode="{doXmlEncode}" />
</rest:bodySerializer>
<!-- Deserialize replies from XML to strongly-typed objects. -->
<rest:resultDeserializer>
<rest:XMLSerializationFilter xmlDecode="{doXmlDecode}" />
</rest:resultDeserializer>
<!-- Forces requests content type to be 'application/xml'. -->
<rest:contentTypeProvider>
<rest:RESTSerializationFilter requestContentType="application/xml" />
</rest:contentTypeProvider>
<!-- This serializer is required for XML requests. -->
<rest:parametersSerializer>
<rest:RESTSerializationFilter />
</rest:parametersSerializer>
</rest:CompositeSerializationFilter>
</mx:serializationFilter>
</mx:HTTPMultiService> private function doXmlEncode(body:Object):XMLNode
{
return new XMLNode(1, '<body id="' + body.id + '"/>');
}
private function doXmlDecode(node:XMLNode):Object
{
return { id: node.attributes.id };
} Estende o CompositeSerializationFilter com duas novas propriedades: username e password . Adicionará um cabeçalho básico de autenticação HTTP a todas as solicitações.
<mx:HTTPService>
<mx:serializationFilter>
<rest:BasicAuthenticationSerializationFilter username="admin" password="qwerty">
<rest:bodySerializer>
<rest:XMLSerializationFilter />
</rest:bodySerializer>
<rest:resultDeserializer>
<rest:XMLSerializationFilter />
</rest:resultDeserializer>
<rest:contentTypeProvider>
<rest:RESTSerializationFilter requestContentType="application/xml" />
</rest:contentTypeProvider>
<rest:parametersSerializer>
<rest:RESTSerializationFilter />
</rest:parametersSerializer>
</rest:BasicAuthenticationSerializationFilter>
</mx:serializationFilter>
</mx:HTTPMultiService> Estende o CompositeSerializationFilter . Pode ser usado para criar e atribuir um cabeçalho OAuth para suas solicitações.
<mx:HTTPService>
<mx:serializationFilter>
<rest:OAuthSerializationFilter id="oauthFilter" keySecret="kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw" tokenSecret="LswwdoUaIvS8ltyTt5jkRh4J50vUPVVHtR2YPi5kE">
<rest:bodySerializer>
<rest:XMLSerializationFilter />
</rest:bodySerializer>
<rest:resultDeserializer>
<rest:XMLSerializationFilter />
</rest:resultDeserializer>
<rest:contentTypeProvider>
<rest:RESTSerializationFilter requestContentType="application/xml" />
</rest:contentTypeProvider>
<rest:parametersSerializer>
<rest:RESTSerializationFilter />
</rest:parametersSerializer>
</rest:BasicAuthenticationSerializationFilter>
</mx:serializationFilter>
<mx:operationList>
<mx:HTTPOperation
name="getUser"
url="User/[ID]" />
</mx:operationList>
</mx:HTTPMultiService> import mx.rpc.AbstractOperation;
import mx.rpc.AsyncToken;
import mx.rpc.http.OAuthHeader;
import mx.rpc.utils.OAuthUtil;
import vo.User;
private function getUser(userId:uint):AsyncToken
{
var oauthData:OAuthHeader = new OAuthHeader();
oauthData.oauth_version = "1.0";
oauthData.oauth_consumer_key = "xvz1evFS4wEEPTGEFPHBog";
oauthData.oauth_token = "370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb";
oauthData.oauth_nonce = OAuthUtil.generateNonce();
oauthData.oauth_signature_method = OAuthHeader.SIGNATURE_METHOD_HMAC_SHA1;
oauthData.oauth_timestamp = OAuthUtil.getTimestamp();
var operation:AbstractOperation = service.getOperation("getUser");
operation.arguments = { ID: userId }; //replace URL tokens
oauthFilter.oauthData = oauthData;
return operation.send();
} A classe estática mx.utils.TypeUtil pode ser usada para todas as peças fundidas listadas acima.
mx.rpc.OperationResponder pode ser usado para tornar os manipuladores de operação mais diretos. Ele imita a classe AsyncResponder da Flex Flex, mas com uma assinatura de funções de resultado/falha diferente. Uma assinatura de manipulador de resultado válida é function(valueObject:Object):void . Uma função de manipulador de resultados receberá o valor ResultEvent.result function(valueObject:MyResultClass):void Uma assinatura de manipulador de falhas válida é function(fault:Fault):void .
import mx.rpc.OperationResponder;
import vo.User;
private function getUser():void
{
service.getOperation("getUser").send().addResponder(new OperationResponder(onResult, onFault));
}
private function onResult(user:User):void
{
trace(user.firstName);
}
private function onFault(fault:Fault):void
{
trace(fault.faultDetail);
}
