schematester.java

对xml很好的java处理引擎,编译中绑定xml

package org.jibx.schema;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.jdt.core.dom.AST;
import org.jibx.binding.Loader;
import org.jibx.binding.Utility;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.MungedClass;
import org.jibx.binding.def.BindingDefinition;
import org.jibx.extras.DocumentComparator;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.codegen.ClassAssigner;
import org.jibx.schema.codegen.NameConverter;
import org.jibx.schema.codegen.PackageDirectory;
import org.jibx.schema.codegen.PackageHolder;
import org.jibx.schema.codegen.ReferenceCountMap;
import org.jibx.schema.codegen.UsageFinder;
import org.jibx.schema.elements.CommonTypeDefinition;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.validation.PrevalidationVisitor;
import org.jibx.schema.validation.RegistrationVisitor;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.schema.validation.ValidationVisitor;
import org.jibx.util.InsertionOrderedSet;

/**
 * Test class for working with a specified schema.
 */
public class SchemaTester
{
    private static final String SCHEMA_CLASS =
        "org.jibx.schema.elements.SchemaElement";
    private static final IBindingFactory m_bindingFactory;
    static {
        try {
            
            // set paths to be used for loading referenced classes
            URL[] urls = Loader.getClassPaths();
            String[] paths = new String[urls.length];
            for (int i = 0; i < urls.length; i++) {
                paths[i] = urls[i].getFile();
            }
            ClassCache.setPaths(paths);
            ClassFile.setPaths(paths);
            
            // find the binding definition
            ClassLoader loader = SchemaTester.class.getClassLoader();
            InputStream is = loader.getResourceAsStream("org/jibx/schema/binding.xml");
            if (is == null) {
                throw new RuntimeException("Schema binding definition not found");
            }
            
            // process the binding
            BoundClass.reset();
            MungedClass.reset();
            BindingDefinition.reset();
            BindingDefinition def = Utility.loadBinding("binding.xml",
                "binding", is, null, false);
            def.generateCode(false);
            
            // output the modified class files
            MungedClass.fixChanges(true);
            
            // look up the mapped class and associated binding factory
            Class mclas = Class.forName(SCHEMA_CLASS);
            m_bindingFactory = BindingDirectory.getFactory(mclas);
            
        } catch (JiBXException e) {
            throw new RuntimeException("JiBXException: " + e.getMessage());
        } catch (IOException e) {
            throw new RuntimeException("IOException: " + e.getMessage());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("ClassNotFoundException: " +
                e.getMessage());
        }
    }
    
    private static void delete(File file) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                delete(files[i]);
            }
        }
        file.delete();
    }
    
    /**
     * Test a set of schemas.
     *
     * @param args
     * @throws Exception on error
     */
    public static void main(String[] args) throws Exception {
        ValidationContext vctx = new ValidationContext();
        File genroot = new File(args[0]);
        System.out.println("Generating to output directory " + genroot.getAbsolutePath());
        if (genroot.exists()) {
            delete(genroot);
        }
        SchemaElement[] schemas = new SchemaElement[args.length-1];
        for (int i = 1; i < args.length; i++) {
            
            // unmarshal document to construct schema structure
            IUnmarshallingContext uctx =
                m_bindingFactory.createUnmarshallingContext();
            File file = new File(args[i]);
            uctx.setDocument(new FileInputStream(file), file.getAbsolutePath(),
                null);
            uctx.setUserContext(vctx);
            Object obj = uctx.unmarshalElement();
            
            // list validation errors
            ArrayList probs = vctx.getProblems();
            if (probs.size() > 0) {
                for (int j = 0; j < probs.size(); j++) {
                    ValidationProblem prob = (ValidationProblem)probs.get(j);
                    System.out.print(prob.getSeverity() >=
                        ValidationProblem.ERROR_LEVEL ? "Error: " : "Warning: ");
                    System.out.println(prob.getDescription());
                }
            } else {
                
                // determine encoding of input document
                String enc = ((UnmarshallingContext)uctx).getInputEncoding();
                if (enc == null) {
                    enc = "UTF-8";
                }
                
                // marshal root object back out to document in memory
                IMarshallingContext mctx = m_bindingFactory.createMarshallingContext();
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                mctx.setIndent(2);
                mctx.marshalDocument(obj, enc, null, bos);
                
                // compare with original input document
                InputStreamReader brdr = new InputStreamReader
                    (new ByteArrayInputStream(bos.toByteArray()), enc);
                InputStreamReader frdr = new InputStreamReader
                    (new FileInputStream(args[i]), enc);
                DocumentComparator comp = new DocumentComparator(System.err);
                if (comp.compare(frdr, brdr)) {
                    
                    // report schema roundtripped successfully
                    System.out.println("Roundtripped schema " + args[i]);
                    
                    // set resolver for use during schema processing
                    SchemaElement schema = (SchemaElement)obj;
                    URL url = new URL("file", "", file.getAbsolutePath());
                    schema.setResolver(new UrlResolver(url));
                    schemas[i-1] = (SchemaElement)obj;
                    
                } else {
                    
                    // save file before returning failure
                    try {
                        File fout = new File("temp.xml");
                        fout.delete();
                        FileOutputStream fos = new FileOutputStream(fout);
                        fos.write(bos.toByteArray());
                        fos.close();
                    } catch (IOException ex) {
                        System.err.println("Error writing to temp.xml: " +
                            ex.getMessage());
                    }
                }
            }
        }
        
        // validate the schemas and report any problems
        TreeWalker wlkr = new TreeWalker(vctx, vctx);
        System.out.println("** Beginning prevalidation **");
        vctx.clearTraversed();
        for (int i = 0; i < schemas.length; i++) {
            wlkr.walkSchema(schemas[i], new PrevalidationVisitor(vctx));
        }
        System.out.println("** Beginning registration **");
        vctx.clearTraversed();
        for (int i = 0; i < schemas.length; i++) {
            wlkr.walkSchema(schemas[i], new RegistrationVisitor(vctx));
        }
        System.out.println("** Beginning validation **");
        vctx.clearTraversed();
        for (int i = 0; i < schemas.length; i++) {
            wlkr.walkSchema(schemas[i], new ValidationVisitor(vctx));
        }
        ArrayList probs = vctx.getProblems();
        if (probs.size() > 0) {
            for (int j = 0; j < probs.size(); j++) {
                ValidationProblem prob = (ValidationProblem)probs.get(j);
                System.out.print(prob.getSeverity() >=
                    ValidationProblem.ERROR_LEVEL ? "Error: " : "Warning: ");
                System.out.println(prob.getDescription());
            }
        }
        
        // check usage of all schema elements
        System.out.println("** Beginning full usage counting **");
        vctx.clearTraversed();
        UsageFinder usage = new UsageFinder();
        for (int i = 0; i < schemas.length; i++) {
            usage.countSchemaTree(schemas[i]);
        }
        
        // report reference counts for entire set of schemas
        ReferenceCountMap rcmap = usage.getUsageMap();
        System.out.println("** Reference counts across all schemas **");
        printReferenceCounts(rcmap);
        
        // check usage of closure from global definitions in top-level schema
        System.out.println("** Beginning subset closure usage counting **");
        vctx.clearTraversed();
        usage = new UsageFinder();
        for (int i = 0; i < schemas.length; i++) {
            SchemaElement schema = schemas[i];
            usage.setNameRegister(schema.getRegister());
            usage.addReferenceClosure(schema.getTopLevelChildren());
        }
        
        // report reference counts for schema subset
        rcmap = usage.getUsageMap();
        System.out.println("** Reference counts from schema subset **");
        printReferenceCounts(rcmap);
        
        // start with set of all global elements to drive class generation
        Set comps = new InsertionOrderedSet();
        for (int i = 0; i < schemas.length; i++) {
            for (Iterator iter = schemas[i].getTopLevelChildren().iterator();
                iter.hasNext();) {
                Object child = iter.next();
                if (child instanceof ElementElement) {
                    comps.add(child);
                }
            }
        }
        
        // add all multiple references to set
        for (Iterator iter = rcmap.iterator(); iter.hasNext();) {
            SchemaBase key = (SchemaBase)iter.next();
            if (rcmap.getCount(key) > 1 &&
                !(key instanceof CommonTypeDefinition &&
                ((CommonTypeDefinition)key).isPredefinedType())) {
                comps.add(key);
            }
        }
        
        // assign class names for schema components, starting from set
        PackageDirectory pkgdir = new PackageDirectory(genroot,
            "org.opentravel.ota");
        ClassAssigner assigner = new ClassAssigner(new NameConverter(), pkgdir);
        assigner.assign(rcmap, comps);
        
        // generate the classes in all packages
        AST ast = AST.newAST(AST.JLS3);
        ArrayList packs = pkgdir.getPackages();
        for (int i = 0; i < packs.size(); i++) {
            PackageHolder pack = (PackageHolder)packs.get(i);
            pack.generate(ast);
        }
    }

    /**
     * Print ordered list of reference counts.
     *
     * @param rcmap
     */
    private static void printReferenceCounts(ReferenceCountMap rcmap) {
        
        // get array of keys ordered by item name
        Object[] keys = rcmap.keyArray();
        Arrays.sort(keys, new Comparator() {
            public int compare(Object arg0, Object arg1) {
                String name0 = ((INamed)arg0).getName();
                String name1 = ((INamed)arg1).getName();
                return name0.compareTo(name1);
            }
        });
        
        // print the reference counts
        for (int i = 0; i < keys.length; i++) {
            SchemaBase key = (SchemaBase)keys[i];
            System.out.println("Found " + rcmap.getCount(key) +
                " references to " + key.name() + " " + ((INamed)key).getName());
        }
    }
}