[Java] binding objet JAVA -> XML pour Datasource GWT

binding objet JAVA -> XML pour Datasource GWT [Java] - Java - Programmation

Marsh Posté le 26-10-2009 à 15:47:43    

Bonjour,
 
j'ai besoin d'un petit coup de main sur un problème java :
 
En une phrase : Je cherche à présenter à l'utilisateur la structure d'un objet java, c'est à dire chacun de ses champs leurs valeurs (un toString() fera l'affaire :o), et la possiblité de parcourir les types complexes (listes, maps, etc.).
en gros, la vue "Variables" d'Eclipse ;)
 
J'ai des contraintes techniques :

  • objets JAVA (récupéré d'un référentiel tournant sur un jdk1.4)
  • rendu effectué dans un GUI GWT (jdk1.6)
  • mes objets sont assez complexes et leur structure n'est pas connue à l'avance


 
J'entame tout juste ma réflexion... et à première vue, je serai tenté d'aborder le problème sous cet angle :
1) GWT aime bien les datasources en XML... donc je verrai bien GWT manipuler un XML décrivant l'objet que je dois afficher (sous forme : clé=nom de l'attribut, valeur=toString() de l'attribut)
2) Je dois alors trouver une lib java me permettant de générer un XML à la volée à partir d'un objet java passé en paramètre, par introspection des attributs (ou éventuellement utilisation des getters).
 
 
Des idéees ? Des libs à conseiller ?
 
Merci d'avance :jap:


Message édité par cartemere le 26-10-2009 à 17:23:05
Reply

Marsh Posté le 26-10-2009 à 15:47:43   

Reply

Marsh Posté le 26-10-2009 à 16:01:54    

xstream, mais ca ne fonctionnera que coté serveur

Message cité 1 fois

---------------
Light is right
Reply

Marsh Posté le 26-10-2009 à 16:10:01    

nerisson a écrit :

xstream, mais ca ne fonctionnera que coté serveur


le fait que ça tourne coté serveur ne pose pas de souci... au contraire même :
 
La manip va nécessiter un appel coté serveur pour récupérer l'objet java complet, donc tant qu'à faire autant que la transco java->xml soit réalisée coté serveur. :jap:
 
merci en tout cas, je creuse de ce coté ;)

Reply

Marsh Posté le 26-10-2009 à 20:22:22    

XStream est pas mal, j'ai aussi utilisé JAXB 2 (inclus dans J2EE) et ça fonctionne très bien aussi.

Reply

Marsh Posté le 27-10-2009 à 09:20:57    

OK merci, j'ai commencé à regarder du coté de XStream :
 
C'est pas mal effectivement, et ça permet de ressortir assez facilement l'arboresence d'un objet java sous forme de XML.
 
Là par contre, je me heurte deux limitations de GWT :
 
1) le XML en entrée des grilles n'est pas un XML "standard" (avec n niveaux) imbriqués, mais un XML "à plat" avec pour chaque objet une foreign key vers son objet parent.
 

Code :
  1. <List>
  2. −
  3. <employee>
  4.   <EmployeeId>4</EmployeeId>
  5.   <ReportsTo>1</ReportsTo>
  6.   <Name>Charles Madigen</Name>
  7.   <Job>Chief Operating Officer</Job>
  8.   <Phone>x10962</Phone>
  9.   <Email>cmadigan@server.com</Email>
  10.   <OrgUnit>Management</OrgUnit>
  11.   <Salary>26200.00</Salary>
  12.   <Gender>male</Gender>
  13.   <MaritalStatus>married</MaritalStatus>
  14.   <EmployeeType>full time</EmployeeType>
  15.   <EmployeeStatus>active</EmployeeStatus>
  16. </employee>
  17. −
  18. <employee>
  19.   <EmployeeId>192</EmployeeId>
  20.   <ReportsTo>4</ReportsTo>
  21.   <Name>Ralph Brogan</Name>
  22.   <Job>Mgr Software Client Supp</Job>
  23.   <Phone>x32524</Phone>
  24.   <Email>rbrogan@server.com</Email>
  25.   <OrgUnit>Management</OrgUnit>
  26.   <Salary>13700.00</Salary>
  27.   <Gender>male</Gender>
  28.   <MaritalStatus>married</MaritalStatus>
  29.   <EmployeeType>full time</EmployeeType>
  30.   <EmployeeStatus>active</EmployeeStatus>
  31. </employee>
  32. −
  33. <employee>
  34.   <EmployeeId>295</EmployeeId>
  35.   <ReportsTo>192</ReportsTo>
  36.   <Name>Bhushan Sambhus</Name>
  37.   <Job>Line Worker</Job>
  38.   <Phone>x12125</Phone>
  39.   <Email>bsambhus@server.com</Email>
  40.   <OrgUnit>Management</OrgUnit>
  41.   <Salary>8300.00</Salary>
  42.   <Gender>female</Gender>
  43.   <MaritalStatus>married</MaritalStatus>
  44.   <EmployeeType>part time</EmployeeType>
  45.   <EmployeeStatus>active</EmployeeStatus>
  46. </employee>
  48. </List>


 
2) GWT s'attend à ce que les champs soient définis explicitement pour pouvoir en effectuer le rendu... ce qui n'est pas mon cas, puisque le XML généré par XStream reprend comme balise les noms des attributs...
 
 
 
Bref, je dois trouver le moyen de convertir le XML de XStream en un XML "GWT compliant"... et c'est pas gagné :/

Reply

Marsh Posté le 27-10-2009 à 22:07:00    

Je n'ai pas tout compris... de 1, tu veux que le XML soit indenté c'est ça? et de 2, qu'entends-tu par "champ défini explicitement"?

Message cité 1 fois
Reply

Marsh Posté le 30-04-2010 à 12:15:09    

cbeyls a écrit :

Je n'ai pas tout compris... de 1, tu veux que le XML soit indenté c'est ça? et de 2, qu'entends-tu par "champ défini explicitement"?


Je réponds un peu tard, mais bon :
 
Je veux un XML, mais dont chacune des entrée référence explicitement son "parent".
Concrêtement en reprenant l'exemple précédent, chaque entrée "employee" dispose d'un identifiant unique "employeeId", et référence son parent par "reportsTo".
Cette mise en forme est nécessaire pour que le composant graphique de smartGWT puisse effectuer un rendu sous forme d'arbre.
 
Le tout doit être réalisé de manière dynamique, car je ne connais pas "à priori" l'arborescence d'objets que je sérialise.
 
 
 
 
 
Je m'en suis sorti par le système suivant :
1) je passe par Xstream pour serialiser mon objet java.
2) je récupère le flux XML sérialisé, que j'interprète via un parser XML
3) je passe de manière récursive à travers les nœuds du XML en reconstruisant une collection d'objets "nœud", où j'indique pour chaque nœud :
   - un identifiant unique
   - l'identifiant de son parent
4) je rattache cette collection à mon composant smartGWT
 
 
dans le détail, voici mon code de réinterprétation

Code :
  1. /**
  2.    * transcode a standard object's XML to a specific GWT Compliant XML
  3.    * @param inputXML the input XML String to transcode
  4.    * @param withRoot keep root in result ?
  5.    * @return the GWT compliant XML String
  6.    * @throws DocumentException in case XML input can not be parsed
  7.    */
  8.   public Collection<TreeObject> transcodeBasicXMLtoGWTCompliantTreeNode(String inputXML, boolean withRoot)
  9.       throws DocumentException {
  10.     IndexHandler indexHandler = new IndexHandler();
  12.     // retrieve input document
  13.     Document inputDoc = DocumentHelper.parseText(inputXML);
  14.     Element inputRoot = inputDoc.getRootElement();
  16.     // create output document
  17.     Collection<TreeObject> treeObjects = new ArrayList<TreeObject>();
  19.     // process all subNodes
  20.     if (withRoot) {
  21.       extractNode(inputRoot, treeObjects, indexHandler, 1);
  22.     } else {
  23.       List<Element> subElements = inputRoot.elements();
  24.       for (Element subElement : subElements) {
  25.         extractNode(subElement, treeObjects, indexHandler, 1);
  26.       }
  27.     }
  28.     return treeObjects;
  29.   }
  31.   private void extractNode(Element inputElement, Collection<TreeObject> treeObjects, IndexHandler indexHandler,
  32.       int parentIndex) {
  33.     // process the input Element
  34.     int inputElementIndex = indexHandler.getNextValue();
  35.     String inputElementName = inputElement.getQName().getName();
  36.     boolean inputElementIsText = inputElement.isTextOnly();
  37.     String inputElementText = null;
  38.     if (inputElementIsText) {
  39.       inputElementText = inputElement.getText();
  40.     }
  42.     TreeObject node = new TreeObject();
  43.     node.setId(inputElementIndex);
  44.     node.setParentId(parentIndex);
  45.     node.setName(extractClassName(inputElementName));
  46.     if (inputElementIsText) {
  47.       node.setValue(inputElementText);
  48.     } else {
  49.       // add empty value : contains children
  50.       node.setValue(StringUtils.EMPTY);
  51.     }
  52.     treeObjects.add(node);
  54.     // process all subNodes
  55.     List<Element> subElements = inputElement.elements();
  56.     for (Element subElement : subElements) {
  57.       extractNode(subElement, treeObjects, indexHandler, inputElementIndex);
  58.     }
  59.   }
  61.   private String extractClassName(String fullQualifiedClassName) {
  62.     if (fullQualifiedClassName != null && fullQualifiedClassName.length() > 0) {
  63.       String[] splittedName = fullQualifiedClassName.split("\\." );
  64.       if (splittedName.length > 1) {
  65.         return splittedName[splittedName.length - 1];
  66.       }
  67.     }
  68.     return fullQualifiedClassName;
  69.   }
  71.   /**
  72.    * Private class managing the record's unique identifier.
  73.    */
  74.   private class IndexHandler {
  76.     private int index;
  78.     public IndexHandler() {
  79.       index = 1;
  80.     }
  82.     public int getNextValue() {
  83.       return ++index;
  84.     }
  85.   }


 
 
sachant que mon objet "nœud" est la classe TreeObject :

Code :
  1. /**
  2. * Generic TreeObject representation (for Java object detail view)
  3. */
  4. public class TreeObject implements Serializable {
  6.   /** current node Id */
  7.   private int id;
  9.   /** parent node Id */
  10.   private int parentId;
  12.   /** attribute name */
  13.   private String name;
  15.   /** attribute value */
  16.   private String value;
  18.   public int getId() {
  19.     return id;
  20.   }
  22.   public void setId(int id) {
  23.     this.id = id;
  24.   }
  26.   public int getParentId() {
  27.     return parentId;
  28.   }
  30.   public void setParentId(int parentId) {
  31.     this.parentId = parentId;
  32.   }
  34.   public String getName() {
  35.     return name;
  36.   }
  38.   public void setName(String name) {
  39.     this.name = name;
  40.   }
  42.   public String getValue() {
  43.     return value;
  44.   }
  46.   public void setValue(String value) {
  47.     this.value = value;
  48.   }
  50. }


 
 
 
et enfin, voici comment j'effectue le rendu via smartGWT

Code :
  1. public class DetailDialogFactory {
  3.  
  4.   public static final int DEFAULT_HEIGHT = 600;
  5.  
  6.   public static final int DEFAULT_WIDTH = 600;
  7.  
  8.   public static final int DEFAULT_TOOLBAR_HEIGHT = 40;
  9.  
  10.   /**
  11.    * Build a Dialog holding a TreeGrid, filled with the provided Tree
  12.    * @param detailLines the Tree lines
  13.    * @param dialogTitle the dialog name
  14.    * @param header a {@link DynamicForm} header definition
  15.    */
  16.   public static void displayDetailDialog(Collection<TreeObject> detailLines, String dialogTitle, DynamicForm header) {
  17.    
  18.     // fill dataSource with results :
  19.     Collection<TreeNode> nodes = new ArrayList<TreeNode>();
  20.     for (TreeObject object : detailLines) {
  21.       RPCTreeObjectDataSource.BuildingTreeNode node = new RPCTreeObjectDataSource.BuildingTreeNode();
  22.       node.setId(object.getId());
  23.       node.setName(Integer.toString(object.getId()));
  24.       node.setParent(object.getParentId());
  25.       node.setTitle(object.getName());
  26.       node.setValue(object.getValue());
  27.       nodes.add(node);
  28.     }
  29.     // Instantiate new DataSource
  30.     RPCTreeObjectDataSource dataSource = new RPCTreeObjectDataSource("DataSource" + System.currentTimeMillis(),1, nodes);
  31.    
  32.     // create Treegrid
  33.     final TreeGrid detailTree = new TreeGrid();
  34.     detailTree.setHeight100();
  35.     detailTree.setWidth100();
  36.     // declare fields
  37.     TreeGridField fieldTitle   = new TreeGridField("title", "Title" );
  38.     TreeGridField fieldValue  = new TreeGridField("value", "Value" );
  39.     // attach fields
  40.     detailTree.setFields(fieldTitle, fieldValue);
  41.     detailTree.setAutoFetchData(true);
  42.     detailTree.setAutoFetchDisplayMap(true);
  43.     detailTree.setDataSource(dataSource);
  44.     detailTree.setLoadDataOnDemand(false);
  45.     detailTree.setAlternateRecordStyles(true);
  46.    
  47.     // Instantiate dialog holder
  48.     final Window dialog = new Window();
  49.     dialog.setWidth(DEFAULT_WIDTH);
  50.     dialog.setHeight(DEFAULT_HEIGHT);
  51.     dialog.setTitle(dialogTitle);
  52.     dialog.setIsModal(false);
  53.     dialog.setCanDragReposition(true);
  54.     dialog.setCanDragResize(true);
  55.    
  56.        
  57.     // add expand all Button
  58.     IButton expandButton = new IButton("Expand All" );
  59.     expandButton.setShowDown(true);
  60.     expandButton.setShowRollOver(true);
  61.     expandButton.addClickHandler(new com.smartgwt.client.widgets.events.ClickHandler() {
  62.       public void onClick(com.smartgwt.client.widgets.events.ClickEvent event) {
  63.         detailTree.getData().openAll();
  64.       }
  65.     });
  66.    
  67.     // add collapse all Button
  68.     IButton collapseButton = new IButton("Collapse All" );
  69.     collapseButton.setShowDown(true);
  70.     collapseButton.setShowRollOver(true);
  71.     collapseButton.addClickHandler(new com.smartgwt.client.widgets.events.ClickHandler() {
  72.       public void onClick(com.smartgwt.client.widgets.events.ClickEvent event) {
  73.         if (detailTree.getData() != null ) {
  74.            detailTree.getData().closeAll();
  75.         }
  76.       }
  78.     });
  79.    
  80.     dialog.addCloseClickHandler(new CloseClickHandler() {
  82.       public void onCloseClick(CloseClientEvent event) {
  83.         dialog.destroy();
  84.       }
  85.     });
  86.    
  87.     // main to display
  88.     VLayout mainPanel = new VLayout();
  89.     mainPanel.setWidth100();
  90.     mainPanel.setHeight100();
  91.     mainPanel.setLayoutMargin(5);
  92.     mainPanel.setMembersMargin(10);
  94.     mainPanel.addMember(header);
  95.    
  96.     SectionStack stack = new SectionStack();
  97.     SectionStackSection section = new SectionStackSection("Detail" );
  98.     section.setCanCollapse(true);
  99.     section.setExpanded(true);
  100.     section.setItems(detailTree);
  101.     stack.addSection(section);
  102.     stack.setHeight("*" );
  103.     stack.setWidth100();
  104.     mainPanel.addMember(stack);
  105.    
  106.     HLayout buttonLayout = new HLayout();
  107.     buttonLayout.setMembersMargin(10);
  108.     buttonLayout.setMembers(expandButton, collapseButton);
  109.     buttonLayout.setAutoHeight();
  110.     buttonLayout.setLayoutBottomMargin(5);
  111.     mainPanel.addMember(buttonLayout);
  112.    
  113.     dialog.addItem(mainPanel);
  114.     dialog.show();
  115.   }
  116. }


 
 
 
 
 
 
 
De cette manière, il est possible de représenter sous forme d'arbre n'importe quel objet JAVA (à condition qu'il ne contienne pas de récursivité) en le convertissant en XML via xstream.toXml(object), et en réinterprétant le flux XML :jap:

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed