Mapper intelligemment un XSD avec des Objets Java
Bonjour...
Je repose une question précédente en essayant de préciser.
Imaginons que j'ai une structure de données Java, déjà écrite, qui me représente des objets. Pour simplifier dans mon exemple, considérons un jeu d'expressions arithmético-booléennes simples :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
public interface IExpression{}
public interface IValue{
public IType getType();
public Object getValue();
}
public interface IValueExpression extends IExpression {
public IValue getValue();
public IType getType();
}
public interface IVariableExpression extends IExpression {
public IType getType();
public String getName();
}
public interface IUnaryExpression extends IExpression {
public IExpression getExpression();
public IOperator getOperator();
}
public interface IBinaryExpression extends IExpression {
public IExpression getLeftExpression();
public IExpression getRightExpression();
public IOperator getOperator();
}
public enum IOperator {...}
public enum IType {
NATURAL, BOOLEAN
} |
En d'autres termes, je dispose d'un jeu d'expression que l'on pourrait définir avec la grammaire suivante :
Code:
1
2
3
4
5
6
7
8
9
|
Expression ::= Value | Variable |
| Unary | Binary
Value ::= Val Type
Variable ::= Name Type
Unary ::= Operator Expression
Binary ::= Operator Expression Expression
Operator ::= PLUS | ...
Type ::= BOOLEAN | NATURAL |
Maintenant, imaginons que pour des raisons indépendantes de notre volonté (le chef de projet, des contraintes d'ordre financières, tout ça) nous impose d'utiliser, pour communiquer, le format XML. Il faut donc écrire un schéma qui puisse représenter une expression de la manière adéquate.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
<xsd:complexType name="Expression" abstract="true"/>
<xsd:simpleType name="Type">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="Boolean"/>
<xsd:enumeration value="Natural"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="value">
<xsd:complexContent>
<xsd:extension base="target:Expression">
<xsd:attribute name="type" type="xsd:string"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="variable">
<xsd:complexContent>
<xsd:extension base="target:Expression">
<xsd:attribute name="type" type="target:Type"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="unary">
<xsd:complexContent>
<xsd:extension base="target:Expression">
<xsd:sequence>
<xsd:element name="Expression"/>
</xsd:sequence>
<xsd:attribute name="operator" type="target:Operator"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="binary">
<xsd:complexContent>
<xsd:extension base="target:Expression">
<xsd:sequence>
<xsd:element name="Expression"/>
<xsd:element name="Expression"/>
</xsd:sequence>
<xsd:attribute name="operator" type="target:Operator"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:simpleType name="Operator">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="PLUS"/>
<xsd:enumeration value="SUB"/>
<xsd:enumeration value="TIMES"/>
<xsd:enumeration value="DEVIDE"/>
<xsd:enumeration value="EQUALS"/>
<xsd:enumeration value="GREATER"/>
<xsd:enumeration value="LESS"/>
<xsd:enumeration value="NOT"/>
<xsd:enumeration value="OR"/>
<xsd:enumeration value="AND"/>
</xsd:restriction>
</xsd:simpleType> |
Mon gros problème est le suivant. Lorsqu'on utilise JaxB pour mapper le XML avec des objets Java, JaxB produit sa propre hiérarchie d'objets qui ne correspond pas du tout à ce que j'ai déjà écrit. Du coup, tous les traitements déjà écrits sur la structure de données sont à refaire sur cette nouvelle structure de données. En outre, la structure générée par JaxB est "plate" : les objets sont encapsulés, au lieu d'être disposés de manière hiérarchique comme je le fais dans l'exemple, et du coup, tous les traitements sont à refaire sur cette nouvelle structure, mais en utilisant des algorithmes complètement récursifs alors que la structure hiérarchique permet d'utiliser des algorithmes adaptés (visiteurs, etc.)
Pour l'exemple sur les expressions, les traitements seraient de ce type :
- Typechecker Vérifier que les expressions sont correctement écrite du point de vue des types (e.g vérifier qu'une expression ne contient pas "3 + TRUE" ;
- Evaluateur Evaluer la valeur d'une expression (classiquement, renvoyer "5" pour l'expression binaire "3 + 5" ;
- Pretty-Printer Ecrire de manière particulière une expression ; par exemple en choisissant la manière d'écrire : post (3 5 +), pré (+ 3 5), infixe (3 + 5), etc...
L'exemple donné est assez simple, et on peut aisément le réécrire en quelques minutes... Mais imaginons que la structure représente un programme d'un langage maison, avec la vérification syntaxique, la vérification sémantique, la procédure de compilation, etc... Tous ces algorithmes s'écrivent aisément avec des Design Patterns... mais avec la structure générée par JaxB, c'est impossible de les réutiliser...
Des idées de comment "guider", paramétrer le mapping pour envoyer aux bons objets ?? Des idées de "contournement" du problème ?
Oui, je sais, j'ai pas choisi : XML est à la mode, et les chefs de projets veulent toujours faire ce qui est fun, pas forcément faire ce qui est intelligent... Mais bon ! J'ai pas choisi !!!!
Merci en tous les cas à ceux qui pourraient me débloquer !
JibX : Une bonne solution
Bonjour...
Merci de votre solution... Je regarde : ça a l'air de correspondre à ce que je cherche... Il est apparemment possible de définir précisément comment chaque type XML se mappe à une classe Java, de manière récursive en définissant cela même au niveau des attributs...
Je dois encore creuser comment le mapping des structures de données bas niveau est réalisée, mais en tous les cas merci !!!
Je déclare le fil résolu, et je posterai d'autres questions le cas échéant !
M.A
