javageneratorfactory.java

Java有关XML编程需要用到axis 的源代码 把里面bin下的包导入相应的Java工程 进行使用

     * @param definition
     * @param symbolTable
     * @return
     */
    public Generator getGenerator(Definition definition,
                                  SymbolTable symbolTable) {
        if (include(definition.getQName())) {
            defWriters.addStuff(null, definition, symbolTable);
            return defWriters;
        }
        else {
            return new NoopGenerator();
        }
    }    // getGenerator

    // Hack class just to play with the idea of adding writers

    /**
     * Class Writers
     *
     * @version %I%, %G%
     */
    protected class Writers implements Generator {

        /** Field writers */
        Vector writers = new Vector();

        /** Field symbolTable */
        SymbolTable symbolTable = null;

        /** Field baseWriter */
        Generator baseWriter = null;

        // entry or def, but not both, will be a parameter.

        /** Field entry */
        SymTabEntry entry = null;

        /** Field def */
        Definition def = null;

        /**
         * Method addGenerator
         *
         * @param writer
         */
        public void addGenerator(Class writer) {
            writers.add(writer);
        }    // addWriter

        /**
         * Method addStuff
         *
         * @param baseWriter
         * @param entry
         * @param symbolTable
         */
        public void addStuff(Generator baseWriter, SymTabEntry entry,
                             SymbolTable symbolTable) {

            this.baseWriter = baseWriter;
            this.entry = entry;
            this.symbolTable = symbolTable;
        }    // addStuff

        /**
         * Method addStuff
         *
         * @param baseWriter
         * @param def
         * @param symbolTable
         */
        public void addStuff(Generator baseWriter, Definition def,
                             SymbolTable symbolTable) {

            this.baseWriter = baseWriter;
            this.def = def;
            this.symbolTable = symbolTable;
        }    // addStuff

        /**
         * Method generate
         *
         * @throws IOException
         */
        public void generate() throws IOException {

            if (baseWriter != null) {
                baseWriter.generate();
            }

            Class[] formalArgs;
            Object[] actualArgs;

            if (entry != null) {
                formalArgs = new Class[]{Emitter.class, entry.getClass(),
                                         SymbolTable.class};
                actualArgs = new Object[]{emitter, entry, symbolTable};
            } else {
                formalArgs = new Class[]{Emitter.class, Definition.class,
                                         SymbolTable.class};
                actualArgs = new Object[]{emitter, def, symbolTable};
            }

            for (int i = 0; i < writers.size(); ++i) {
                Class wClass = (Class) writers.get(i);
                Generator gen;

                try {
                    Constructor ctor = wClass.getConstructor(formalArgs);

                    gen = (Generator) ctor.newInstance(actualArgs);
                } catch (Throwable t) {
                    throw new IOException(Messages.getMessage("exception01",
                            t.getMessage()));
                }

                gen.generate();
            }
        }    // generate
    }    // class Writers

    /**
     * Method addGenerator
     *
     * @param wsdlClass
     * @param generator
     */
    public void addGenerator(Class wsdlClass, Class generator) {

        // This is just a hack right now... it just works with Service
        if (Message.class.isAssignableFrom(wsdlClass)) {
            messageWriters.addGenerator(generator);
        } else if (PortType.class.isAssignableFrom(wsdlClass)) {
            portTypeWriters.addGenerator(generator);
        } else if (Binding.class.isAssignableFrom(wsdlClass)) {
            bindingWriters.addGenerator(generator);
        } else if (Service.class.isAssignableFrom(wsdlClass)) {
            serviceWriters.addGenerator(generator);
        } else if (TypeEntry.class.isAssignableFrom(wsdlClass)) {
            typeWriters.addGenerator(generator);
        } else if (Definition.class.isAssignableFrom(wsdlClass)) {
            defWriters.addGenerator(generator);
        }
    }    // addGenerator

    /**
     * Fill in the names of each SymTabEntry with the javaified name.
     * Note: This method also ensures that anonymous types are
     * given unique java type names.
     *
     * @param symbolTable
     */
    protected void javifyNames(SymbolTable symbolTable) {

        int uniqueNum = 0;
        HashMap anonQNames = new HashMap();
        Iterator it = symbolTable.getHashMap().values().iterator();

        while (it.hasNext()) {
            Vector v = (Vector) it.next();

            for (int i = 0; i < v.size(); ++i) {
                SymTabEntry entry = (SymTabEntry) v.elementAt(i);

                if (entry.getName() != null) {
                    continue;
                }

                // Use the type or the referenced type's QName to generate the java name.
                if (entry instanceof TypeEntry) {
                    uniqueNum = javifyTypeEntryName(symbolTable, (TypeEntry) entry, anonQNames, uniqueNum);
                }

                // If it is not a type, then use this entry's QName to
                // generate its name.
                else {
                    entry.setName(emitter.getJavaName(entry.getQName()));
                }
            }
        }
    }    // javifyNames

    /** Refactored to call recursively for JAX-RPC 1.1 spec 4.2.5. */
    protected int javifyTypeEntryName(SymbolTable symbolTable, TypeEntry entry, HashMap anonQNames, int uniqueNum) {
        TypeEntry tEntry = entry;
        String dims = tEntry.getDimensions();
        TypeEntry refType = tEntry.getRefType();
        while (refType != null) {
            tEntry = refType;
            dims += tEntry.getDimensions();
            refType = tEntry.getRefType();
        }

        TypeEntry te = tEntry;
        while (te != null) {
            TypeEntry base = SchemaUtils.getBaseType(te, symbolTable);
            if (base == null)
                break;

            uniqueNum = javifyTypeEntryName(symbolTable, base, anonQNames, uniqueNum);

            if (Utils.getEnumerationBaseAndValues(te.getNode(), symbolTable) == null
                    &&SchemaUtils.getComplexElementExtensionBase(te.getNode(), symbolTable) == null
					&& te.getContainedAttributes() == null) {
                if(!SchemaUtils.isSimpleTypeWithUnion(te.getNode())) {
                    if (base.isSimpleType()) {
                        // Case 1:
                        // <simpleType name="mySimpleStringType">
                        //   <restriction base="xs:string">
                        //   </restriction>
                        // </simpleType>
                        te.setSimpleType(true);
                        te.setName(base.getName());
                        te.setRefType(base);
                    }
    
                    if (base.isBaseType()) {
                        // Case 2:
                        // <simpleType name="FooString">
                        //   <restriction base="foo:mySimpleStringType">
                        //   </restriction>
                        // </simpleType>
                        te.setBaseType(true);
                        te.setName(base.getName());
                        te.setRefType(base);
                    }
                }
            }

            if (!te.isSimpleType())
                break;

            te = base;
        }

        // Need to javify the ref'd TypeEntry if it was not
        // already processed
        if (tEntry.getName() == null) {
            boolean processed = false;	// true if the java name is already determined
            // Get the QName of the ref'd TypeEntry, which
            // is will be used to javify the name
            QName typeQName = tEntry.getQName();

            // In case of <xsd:list itemType="...">,
            // set typeQName to the value of the itemType attribute.
            QName itemType = SchemaUtils.getListItemType(tEntry.getNode());
            if (itemType != null) {
                // Get the typeEntry so we know the absolute base type
                TypeEntry itemEntry = symbolTable.getTypeEntry(itemType, false);
		// TODO - If the itemEntry is not found, we need to throw
		// an exception.  "Item is referenced, but not defined"
                javifyTypeEntryName(symbolTable, itemEntry, anonQNames, uniqueNum);
                // Grab the referenced type, If it's there.
                TypeEntry refedEntry = itemEntry.getRefType();
                QName baseName = refedEntry == null ? itemEntry.getQName() : 
                        refedEntry.getQName();
                typeQName = new QName(baseName.getNamespaceURI(),
                                        baseName.getLocalPart() + "[]");
            }
            
            if (emitter.isDeploy()) {				
                Class class1 = (Class) emitter.getQName2ClassMap().get(typeQName);				
				if (class1 != null && !class1.isArray()) {                    
                    tEntry.setName(getJavaClassName(class1));
                    processed = true;
                }                            
            }
            
            if (!processed) {
	            if ((typeQName.getLocalPart().
	                    indexOf(SymbolTable.ANON_TOKEN) < 0)) {
	                // Normal Case: The ref'd type is not anonymous
	                // Simply construct the java name from
	                // the qName
	                tEntry.setName(emitter.getJavaName(typeQName));
	            } else {
	                // This is an anonymous type name.
	                // Axis uses '>' as a nesting token to generate
	                // unique qnames for anonymous types.
	                // Only consider the localName after the last '>'
	                // when generating the java name
	                // String localName = typeQName.getLocalPart();
	                // localName =
	                // localName.substring(
	                // localName.lastIndexOf(
	                // SymbolTable.ANON_TOKEN)+1);
	                // typeQName = new QName(typeQName.getNamespaceURI(),
	                // localName);
	                String localName = typeQName.getLocalPart();
	
	                // Check to see if this is an anonymous type,
	                // if it is, replace Axis' ANON_TOKEN with
	                // an underscore to make sure we don't run
	                // into name collisions with similarly named
	                // non-anonymous types
	                StringBuffer sb = new StringBuffer(localName);
	                int aidx;
	
	                while ((aidx = sb.toString().indexOf(SymbolTable.ANON_TOKEN)) > -1) {
	                    sb.replace(aidx, aidx + SymbolTable.ANON_TOKEN.length(), "");
	                    char c = sb.charAt(aidx);
	                    if (Character.isLetter(c) && Character.isLowerCase(c)) {
	                        sb.setCharAt(aidx, Character.toUpperCase(c));
	                    }
	                }
	                        
	                localName = sb.toString();
	                typeQName = new QName(typeQName.getNamespaceURI(),
	                        localName);
	
	                if (emitter.isTypeCollisionProtection() &&
	                        !emitter.getNamespaceExcludes().contains(new NamespaceSelector(typeQName.getNamespaceURI()))) {
	                    // If there is already an existing type,
	                    // there will be a collision.
	                    // If there is an existing anon type,
	                    // there will be a  collision.
	                    // In both cases, mangle the name.
	                    if (symbolTable.getType(typeQName) != null ||
	                            anonQNames.get(typeQName) != null) {
	                        localName += "Type" + uniqueNum++;
	                        typeQName =
	                            new QName(typeQName.getNamespaceURI(),
	                                      localName);
	                    }
	                    
	                    anonQNames.put(typeQName, typeQName);
	                }
	
	                // Now set the name with the constructed qname
	                tEntry.setName(emitter.getJavaName(typeQName));
	            }