Analisi dello schema XSD con XSOM in Java. Come accedere a elementi e tipi complessi

Question

Sto analizzando molto difficilmente un file .XSD con un XSOM in Java. Ho due file .XSD uno definisce un calendario e il secondo i tipi globali. Mi piacerebbe essere in grado di leggere il file di calendario e determinare che: calendario

ha 3 proprietà

• valido è un enum chiamato EYN
• Cal è una stringa
• Stato è un ENUM chiamato estatus

Calendar.xsd

<?xml version="1.0" encoding="UTF-8"?> 
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
xmlns:gtypes="http://www.btec.com/gtypes" 
elementFormDefault="qualified"> 
<xs:import namespace="http://www.btec.com/gtypes" 
schemaLocation="gtypes.xsd"/> 
<xs:element name="CALENDAR"> 
    <xs:complexType> 
    <xs:sequence> 
     <xs:element name="Valid" type="eYN" minOccurs="0"/> 
     <xs:element name="Cal" minOccurs="0"> 
     <xs:complexType> 
      <xs:simpleContent> 
      <xs:extension base="gtypes:STRING"> 
       <xs:attribute name="IsKey" type="xs:string" fixed="Y"/> 
      </xs:extension> 
      </xs:simpleContent> 
     </xs:complexType> 
     </xs:element> 
     <xs:element name="Status" type="eSTATUS" minOccurs="0"/> 
    </xs:sequence> 
    </xs:complexType> 
</xs:element> 
<xs:complexType name="eSTATUS"> 
    <xs:simpleContent> 
    <xs:extension base="gtypes:ENUM"/> 
    </xs:simpleContent> 
</xs:complexType> 
<xs:complexType name="eYN"> 
    <xs:simpleContent> 
    <xs:extension base="gtypes:ENUM"/> 
    </xs:simpleContent> 
</xs:complexType> 

gtypes.xsd

<?xml version="1.0" encoding="UTF-8"?> 
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
targetNamespace="http://www.btec.com/gtypes" 
elementFormDefault="qualified"> 
<xs:complexType name="ENUM"> 
    <xs:simpleContent> 
    <xs:extension base="xs:string"> 
     <xs:attribute name="TYPE" fixed="ENUM"/> 
     <xs:attribute name="derived" use="optional"/> 
     <xs:attribute name="readonly" use="optional"/> 
     <xs:attribute name="required" use="optional"/> 
    </xs:extension> 
    </xs:simpleContent> 
</xs:complexType> 
<xs:complexType name="STRING"> 
    <xs:simpleContent> 
    <xs:extension base="xs:string"> 
     <xs:attribute name="TYPE" use="optional"/> 
     <xs:attribute name="derived" use="optional"/> 
     <xs:attribute name="readonly" use="optional"/> 
     <xs:attribute name="required" use="optional"/> 
    </xs:extension> 
    </xs:simpleContent> 
</xs:complexType> 
</xs:schema> 

Il codice dal mio tentativo di accedere a queste informazioni è inferiore. Sono abbastanza nuovo per Java, quindi qualsiasi critica di stile benvenuto.

ho davvero bisogno di sapere

1. Come accedo al tipo complesso cal e vedere che si tratta di una stringa?
2. Come posso accedere alla definizione di stato per vedere è un'enumerazione di tipo estatus sottolineato testo

Sono ha diversi tentativi di accesso alle informazioni a destra via ComplexType e Elements e contenuti. Tuttavia, sono semplicemente non capisco e non riesco a trovare alcun esempio che aiuti. Mi aspetto (spero) che il metodo migliore sia (relativamente) semplice quando sai come. Quindi, ancora una volta, se qualcuno potesse indicarmi la giusta direzione sarebbe di grande aiuto.

xmlfile = "Calendar.xsd" 
XSOMParser parser = new XSOMParser(); 

parser.parse(new File(xmlfile)); 
XSSchemaSet sset = parser.getResult(); 
XSSchema s = sset.getSchema(1); 
if (s.getTargetNamespace().equals("")) // this is the ns with all the stuff 
     // in 
{ 
    // try ElementDecls 
    Iterator jtr = s.iterateElementDecls(); 
    while (jtr.hasNext()) 
    { 
    XSElementDecl e = (XSElementDecl) jtr.next(); 
    System.out.print("got ElementDecls " + e.getName()); 
    // ok we've got a CALENDAR.. what next? 
    // not this anyway 
    /* 
    * 
    * XSParticle[] particles = e.asElementDecl() for (final XSParticle p : 
    * particles) { final XSTerm pterm = p.getTerm(); if 
    * (pterm.isElementDecl()) { final XSElementDecl ed = 
    * pterm.asElementDecl(); System.out.println(ed.getName()); } 
    */ 
    } 

    // try all Complex Types in schema 
    Iterator<XSComplexType> ctiter = s.iterateComplexTypes(); 
    while (ctiter.hasNext()) 
    { 
    // this will be a eSTATUS. Lets type and get the extension to 
    // see its a ENUM 
    XSComplexType ct = (XSComplexType) ctiter.next(); 
    String typeName = ct.getName(); 
    System.out.println(typeName + newline); 

    // as Content 
    XSContentType content = ct.getContentType(); 
    // now what? 
    // as Partacle? 
    XSParticle p2 = content.asParticle(); 
    if (null != p2) 
    { 
     System.out.print("We got partical thing !" + newline); 
     // might would be good if we got here but we never do :-(
    } 

    // try complex type Element Decs 
    List<XSElementDecl> el = ct.getElementDecls(); 
    for (XSElementDecl ed : el) 
    { 
     System.out.print("We got ElementDecl !" + ed.getName() + newline); 
     // would be good if we got here but we never do :-(
    } 

    Collection<? extends XSAttributeUse> c = ct.getAttributeUses(); 
    Iterator<? extends XSAttributeUse> i = c.iterator(); 
    while (i.hasNext()) 
    { 
     XSAttributeDecl attributeDecl = i.next().getDecl(); 
     System.out.println("type: " + attributeDecl.getType()); 
     System.out.println("name:" + attributeDecl.getName()); 
    } 
    } 
} 

Answer 1

Ben dopo un sacco di ricerche su Google, penso di aver risposto alla mia stessa domanda. La mia soluzione proposta era irrimediabilmente ampia del marchio. Il problema principale era che l'XSD ha tre namespace e stavo cercando quello sbagliato per la cosa sbagliata.

Se stai cercando di analizzare un XSD in XSOM essere sicuri di capire la struttura del XSD e quali sono le tag significa prima di iniziare - che vi farà risparmiare un sacco di tempo.

Pubblicherò la mia versione di seguito perché sono sicuro che può essere migliorata!

Alcuni link che erano utili:

http://msdn.microsoft.com/en-us/library/ms187822.aspx

http://it.toolbox.com/blogs/enterprise-web-solutions/parsing-an-xsd-schema-in-java-32565

http://www.w3schools.com/schema/el_simpleContent.asp

package xsom.test 

import com.sun.xml.xsom.parser.XSOMParser; 
import com.sun.xml.xsom.XSComplexType; 
import com.sun.xml.xsom.XSContentType; 
import com.sun.xml.xsom.XSElementDecl; 
import com.sun.xml.xsom.XSModelGroup; 
import com.sun.xml.xsom.XSParticle; 
import com.sun.xml.xsom.XSSchema; 
import com.sun.xml.xsom.XSSchemaSet; 
import com.sun.xml.xsom.XSTerm; 

import java.util.Iterator; 
import java.io.File; 
import java.util.HashMap; 

public class mappingGenerator 
{ 
    private HashMap mappings; 

    public mappingGenerator() 
    { 
    mappings = new HashMap(); 
    } 

    public void generate(String xmlfile) throws Exception 
    { 

    // with help from 
    // http://msdn.microsoft.com/en-us/library/ms187822.aspx 
    // http://it.toolbox.com/blogs/enterprise-web-solutions/parsing-an-xsd-schema-in-java-32565 
    // http://www.w3schools.com/schema/el_simpleContent.asp 
    XSOMParser parser = new XSOMParser(); 

    parser.parse(new File(xmlfile)); 
    XSSchemaSet sset = parser.getResult(); 

    // ========================================================= 
    // types namepace 
    XSSchema gtypesSchema = sset.getSchema("http://www.btec.com/gtypes"); 
    Iterator<XSComplexType> ctiter = gtypesSchema.iterateComplexTypes(); 
    while (ctiter.hasNext()) 
    { 
     XSComplexType ct = (XSComplexType) ctiter.next(); 
     String typeName = ct.getName(); 
     // these are extensions so look at the base type to see what it is 
     String baseTypeName = ct.getBaseType().getName(); 
     System.out.println(typeName + " is a " + baseTypeName); 
    } 

    // ========================================================= 
    // global namespace 
    XSSchema globalSchema = sset.getSchema(""); 
    // local definitions of enums are in complex types 
    ctiter = globalSchema.iterateComplexTypes(); 
    while (ctiter.hasNext()) 
    { 
     XSComplexType ct = (XSComplexType) ctiter.next(); 
     String typeName = ct.getName(); 
     String baseTypeName = ct.getBaseType().getName(); 
     System.out.println(typeName + " is a " + baseTypeName); 
    } 

    // ========================================================= 
    // the main entity of this file is in the Elements 
    // there should only be one! 
    if (globalSchema.getElementDecls().size() != 1) 
    { 
     throw new Exception("Should be only elment type per file."); 
    } 

    XSElementDecl ed = globalSchema.getElementDecls().values() 
     .toArray(new XSElementDecl[0])[0]; 
    String entityType = ed.getName(); 
    XSContentType xsContentType = ed.getType().asComplexType().getContentType(); 
    XSParticle particle = xsContentType.asParticle(); 
    if (particle != null) 
    { 

     XSTerm term = particle.getTerm(); 
     if (term.isModelGroup()) 
     { 
     XSModelGroup xsModelGroup = term.asModelGroup(); 
     term.asElementDecl(); 
     XSParticle[] particles = xsModelGroup.getChildren(); 
     String propertyName = null; 
     String propertyType = null; 
     XSParticle pp =particles[0]; 
     for (XSParticle p : particles) 
     { 
      XSTerm pterm = p.getTerm(); 
      if (pterm.isElementDecl()) 
      {    
      propertyName = pterm.asElementDecl().getName(); 
      if (pterm.asElementDecl().getType().getName() == null) 
      { 
       propertyType = pterm.asElementDecl().getType().getBaseType().getName(); 
      } 
      else 
      { 
       propertyType = pterm.asElementDecl().getType().getName();    
      } 
      System.out.println(propertyName + " is a " + propertyType); 
      } 
     } 
     } 
    } 
    return; 
    } 
} 

L'output di questo è:

ENUM is a string 
STRING is a string 
eSTATUS is a ENUM 
eYN is a ENUM 
Valid is a eYN 
Cal is a STRING 
Status is a eSTATUS