Conversion de données XML en type Flex fort

Question

Un projet sur lequel je travaille tire du code XML d'un serveur Web et en construit un magasin de données. Les données auront certains champs de base, mais doit être extensible ... par exemple, j'ai un et plus tard voudra avoir qui ajoute des champs supplémentaires.

Dans l'application Flex, je ne souhaite pas que le magasin de données central fonctionne sur des objets XML ou qu'il mette simplement les propriétés dans Objets. Je veux avoir des types forts, par exemple une classe Person, qui sont créés/remplis à partir du XML.

Comment cela peut-il être fait de manière flexible? Est-ce que Flex est capable de créer automatiquement une personne à partir d'un XML si les noms d'attribut correspondent, ou dois-je écrire des fonctionnalités de conversion pour, etc.?

Answer 1

Je ne pense pas que cela puisse être fait automatiquement. Je crée généralement la classe a pour refléter la structure XML que j'ai et ensuite créer une méthode de classe statique pour créer une instance de l'objet donné un nœud XML. Par exemple:

package { 

    public class Foo{ 

    public function Foo(barparam1:String, barparam2:uint, barparam3:String, barparam4:Number){ 
     this._bar1 = barparam1; 
     this._bar2 = barparam2; 
     this._bar3 = barparam3; 
     this._bar4 = barparam4; 
     } 

    protected var _bar1:String; 
    protected var _bar2:uint; 
    protected var _bar3:String; 
    protected var _bar4:Number; 

    public function get bar1():String{ return this._bar1; } 
    public function get bar2():uint { return this._bar2; } 
    public function get bar3():String { return this._bar3; } 
    public function get bar4():Number { return this._bar4; } 

    public function toString():String{ 
     return "[Foo bar1:\"" + this.bar1 + "\", bar3:\"" + this.bar3 + "\", bar2:" + this.bar2 + ", bar4:" + this.bar4 + "]"; 
     } 

    public static function createFromXml(xmlParam:XML):Foo{ 

     /* XML Format: 
      <foo bar1="bar1value" bar2="5"> 
      <bar3>bar3 data</bar3> 
      <bar4>10</bar4> 
      </foo> 
     */ 

     return new Foo(xmlParam.@bar1, xmlParam.@bar2, xmlParam.bar3[0], xmlParam.bar4[0]); 
     } 
    } 
    } 

Answer 2

Si vous n'êtes pas lié à XML (par exemple vous avez un serveur d'applications au lieu d'un serveur de fichiers), vous pouvez envisager d'utiliser AMF (Action Message Format) pour transférer les données. Il existe quelques projets qui exposent AMF à des serveurs, y compris Blaze DS propres à Adobe et des variantes de source ouverte de la communauté tels que OpenAMF, AMFPHP, PyAMF et ainsi de suite. Cela vous donnera la possibilité de transférer des objets personnalisés du serveur vers Flex, l'analyse automatique des types de données et le type de sécurité. Jetez un oeil à this comparison of data transfer options pour avoir une idée des mérites relatifs. Cela étant dit, XML peut être très utile pour des choses comme les données de configuration de l'application et dans ces cas, vous n'exécutez pas un serveur d'applications. Je suis d'accord avec l'autre poster où je vais immédiatement analyser le xml dans les structures appropriées à la main. Je les stocke habituellement avec le VO post-correctif (pour l'objet de valeur) et je laisse les membres comme public. Je le fais souvent hiérarchiquement. J'ai vu des systèmes dans le passé qui lieront les noms d'éléments XML aux définitions de classes. Ceux-ci utilisent généralement une sorte d'introspection sur la classe pour déterminer les propriétés à lire sur le xml ou ils auront des propriétés de classe statique qui mappent les propriétés d'une instance à des balises xml ou des attributs. Dans mon expérience, ils sont beaucoup plus de problèmes que ce qu'ils valent. Il faut 2 secondes pour ajouter une nouvelle propriété publique et une seule ligne pour lire les données d'un attribut ou d'une balise enfant. C'est ma suggestion d'éviter de tels schémas complexes mais je donnerai un exemple simple pour l'exhaustivité.

package model 
{ 
    public class XMLReader 
    { 
     // maps <tagname> to a class 
     private static var elementClassMap:Object = 
     { 
      "section": SectionVO, 
      "person": PersonVO 
     }; 

     public var parsedElements:Array; 

     public function XMLReader(xml:XML) 
     { 
      parsedElements = []; 
      parseXML(xml); 
     } 

     private function parseXML(xml:XML):void 
     { 
      var voClass:Class; 
      for each(var element:XML in xml.children()) 
      { 
       voClass = elementClassMap[element.name().localname]; 
       if(voClass) 
       { 
        parsedElements.push(new voClass(element)); 
       } 
      } 
     } 
    } 
} 

Answer 3

converting xml to objects using the flex simplexmldecoder class @flexExamples

Answer 4

Il y a quelque temps que je travaille sur une bibliothèque Flex qui contribuera à la sérialisation et de désérialisation objets Action Script et à partir de XML. Tout ce que vous avez à faire est de créer vos objets modèles, de mettre des annotations sur les champs pour indiquer au sérialiseur comment vous voulez que le champ soit sérialisé (élément, attribut, quel nom, etc.) et appelez le processus de (sérialisation).

Je pense que cela répond à vos besoins. Si vous le souhaitez, vous pouvez le vérifier à http://code.google.com/p/flexxb/.

Espérons que cela s'avérera utile.

Answer 5

La création de types de données robustes présente plusieurs avantages, l'achèvement du code et la vérification de la syntaxe de compilation étant les plus importants.Les mappages manuels peuvent être faits, mais devraient être générés (et ne sont plus vraiment manuels après tout) pour éviter d'être désynchronisés tôt ou tard.

Les bibliothèques de conversion générale basées sur l'introspection sont polyvalentes, faciles à utiliser et devraient suffire dans la plupart des cas d'utilisation. JAXB est la norme pour Java. ASXB fournit une implémentation légère de cette idée pour le monde Actionscript. Il utilise des objets AS explicites avec des annotations aux objets (un) marshalts de et vers XML.

Si vous êtes obligé d'utiliser XML sur le réseau, je suggère de regarder ASXB de plus près. Si vous êtes libre de choisir votre format et que vous avez un serveur de soutien, le format AMF propre à Adobes devrait être votre choix, car il est directement pris en charge dans la langue et a un temps système beaucoup plus faible pendant le transport.

Dans notre projet actuel, nous avons écrit des petits générateurs de code qui prennent l'API externe du côté Java (source introspection, pour également copier le Javadoc) et en génèrent les classes AS pendant notre processus de construction. Il était donc facile de passer de l'AMF à XML lorsque des exigences externes nous y obligeaient.

PS: pensez à ajouter les paramètres du compilateur à votre fichier de configuration flexible pour garder les annotations

Answer 6

AsBeanGen peut le faire. Il génère des objets de valeur pour les fichiers XML pilotés par DTD.