FlexRest

Es gibt mehrere benutzerdefinierte Serialisierungsfilter, die Ihr Leben erleichtern können (erfordert Flex 4).

CompositeSerializationFilter

Implementierung des zusammengesetzten Entwurfsmusters für HTTP -Serialisierungsfilter. Überschreiben Sie eine von 5 Serialisierungsfilter -Methoden unter Verwendung verschiedener Filterinstanzen:

 <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>

SerializationFilter -Methoden, die überschrieben werden können:

• deserializeResult
• getRequestContentType
• serializeParameters
• serializeBody
• serializeURL

Methoden, die nicht überschrieben werden, werden mit einem regulären Serialisierungsfilter behandelt.

RESTSERIALISIONFILTER

Implementiert serializeParameters , contentTypeProvider und serializeURL -Methoden.

Ermöglicht Ihnen, benutzerdefinierte HTTP -Verben zu senden, außer dass Sie standardmäßig vom Flash -Player nicht erhalten oder posten werden . Sie können eine der drei möglichen Möglichkeiten angeben:

• Senden Sie es in einem X- HTTP -Methode-Override-Header ( methodOverride="header" ). Vergessen Sie nicht, Ihre Crossdomain.xml -Datei zu aktualisieren, damit Header an andere Domänen gesendet werden können.
• Gehen Sie einen _method -Parameter an alle URLs an ( methodOverride="url" ).
• Senden Sie ihm einen Anforderungskörper als _method -Parameter ( methodOverride="variable" ). Dies erzwingt, dass Ihre Anfrage als application/x-www-form-urlencoded serialisiert wird.

Dieser Serialisierungsfilter kann auch verwendet werden, um dynamische URLs zu erstellen, die sich mit Parametern (in quadratischen Klammern eingeschlossen) ankleiden.

 <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" });
}

JsonSerializationFilter

Implementiert deserializeResult , contentTypeProvider und serializeBody -Methoden.

Serialisieren Sie Anfragen und Deserialize -Antworten in JSON mit einem schnellen JSON -Parser (nur in der FP11 -Version; FP9 -Version stützt sich auf den JSON -Parser von As3Corelib). Anfragen und Antworten können von und in stark typische Objekte im laufenden Fliegen umgewandelt werden. Die folgenden Objektzuordnungsfunktionen sind verfügbar:

• Eingehende Arrays können an stark typische Vektoren oder Arrays von typisierten Objekten abgebildet werden.
• ArrayElementType -Metatag kann verwendet werden, um Arrays von typisierten Objekten zu kartieren.
• Transient Metatag wird sowohl in Anfragen als auch in Antworten respektiert.
• Datum Zeichenfolgen im JSON -Format /Date(1325376000000)/ können bis Date konvertiert werden und umgekehrt.

Zum Beispiel, wenn Sie dies erhalten:

 {
	"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 } }
	]
}

Es kann in diese umgewandelt werden:

 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;
}

Verwenden Sie den folgenden Code:

 <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;
}

Wenn Sie eine Reihe von Objekten haben…

 [
	{ "x":1, "y":5 },
	{ "x":2, "y":4 },
	{ "x":3, "y":3 },
	{ "x":4, "y":2 },
	{ "x":5, "y":1 }
]

… Sie können es als Array von stark typischen Objekten erhalten, indem Sie resultFormat="array" und resultElementType="{ElementClass}" einstellen. Standardmäßig sind alle Arrays in eine ArrayCollection eingewickelt. Um dieses Verhalten zu vermeiden, setzen Sie einfach makeObjectsBindable="false" in der Operationsinstanz.

 <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 ist eine Implementierung eines abstrakten TypedSerializationFilter , der die Transformation der Typen umgeht, während eine konkrete Klasse die tatsächliche Datenserialisierung und Deserialisierung umgeht.

Das Einstellen resultFormat auf einen anderen Wert neben array und object (Standard) führt dazu, dass ein JSONSerializationFilter (oder eine andere TypedSerializationFilter ) in einer ausgewählten HTTPOperation unterdrückt wird.

XMLSerializationFilter

Implementiert deserializeResult , contentTypeProvider und serializeBody -Methoden.

Handelt genauso wie der JSONSerializationFilter . Sie können die optionalen Eigenschaften xmlEncode und xmlDecode verwenden, um benutzerdefinierte Serialisierungsmethoden zuzuweisen:

 <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 };
}

BasicAuthenticationSerializationFilter

Erweitert den CompositeSerializationFilter mit zwei neuen Eigenschaften: username und password . Fügt allen Anfragen einen grundlegenden HTTP -Authentifizierungsheader hinzu.

 <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>

OAuthSerializationFilter

Erweitert den CompositeSerializationFilter . Kann verwendet werden, um Ihren Anfragen einen OAuth -Header zu erstellen und zuzuweisen.

 <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();
}

---

Statische Klasse mx.utils.TypeUtil kann für alle oben aufgeführten Typgüsse verwendet werden.

mx.rpc.OperationResponder kann verwendet werden, um den Betriebshandlern unkomplizierter zu gestalten. Es ahmt die AsyncResponder -Klasse von Flex nach, jedoch mit anderen Ergebnissenkendelementen. Eine gültige Ergebnis -Handler -Signatur ist function(valueObject:Object):void . Eine Ergebnis -Handler -Funktion erhält ein ResultEvent.result Reseult -Wert, sodass Sie Ihren Ergebnistyp einfach in einem Handler: function(valueObject:MyResultClass):void . Eine gültige Fehlerhandler -Signatur ist 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);
}