javabeanhelperwriter.java

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

/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.axis.wsdl.toJava;

import org.apache.axis.utils.Messages;
import org.apache.axis.wsdl.symbolTable.ContainedAttribute;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.wsdl.symbolTable.DefinedElement;
import org.apache.axis.wsdl.symbolTable.DefinedType;
import org.apache.axis.wsdl.symbolTable.ElementDecl;
import org.apache.axis.wsdl.symbolTable.SchemaUtils;
import org.apache.axis.wsdl.symbolTable.TypeEntry;
import org.apache.axis.wsdl.symbolTable.CollectionTE;

import javax.xml.namespace.QName;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Vector;
import java.util.Set;

/**
 * This is Wsdl2java's Helper Type Writer.  It writes the <typeName>.java file.
 */
public class JavaBeanHelperWriter extends JavaClassWriter {

    /** Field type */
    protected TypeEntry type;

    /** Field elements */
    protected Vector elements;

    /** Field attributes */
    protected Vector attributes;

    /** Field extendType */
    protected TypeEntry extendType;

    /** Field wrapperPW */
    protected PrintWriter wrapperPW = null;

    /** Field elementMetaData */
    protected Vector elementMetaData = null;

    /** Field canSearchParents */
    protected boolean canSearchParents;

    /** Field reservedPropNames */
    protected Set reservedPropNames;

    /**
     * Constructor.
     * 
     * @param emitter    
     * @param type       The type representing this class
     * @param elements   Vector containing the Type and name of each property
     * @param extendType The type representing the extended class (or null)
     * @param attributes Vector containing the attribute types and names
     */
    protected JavaBeanHelperWriter(Emitter emitter, TypeEntry type,
                                   Vector elements, TypeEntry extendType,
                                   Vector attributes, Set reservedPropNames) {

        super(emitter, type.getName() + "_Helper", "helper");

        this.type = type;
        this.elements = elements;
        this.attributes = attributes;
        this.extendType = extendType;
        this.reservedPropNames = reservedPropNames;

        // is this a complex type that is derived from other types
        // by restriction?  if so, set the policy of the generated
        // TypeDescription to ignore metadata associated with
        // superclasses, as restricted types are required to
        // define their entire content model.  Hence the type
        // description associated with the current type provides
        // all of the types (and only those types) allowed in
        // the restricted derivation.
        if ((null != extendType)
                && (null
                != SchemaUtils.getComplexElementRestrictionBase(
                        type.getNode(), emitter.getSymbolTable()))) {
            this.canSearchParents = false;
        } else {
            this.canSearchParents = true;
        }
    }    // ctor

    /**
     * The bean helper class may be its own class, or it may be
     * embedded within the bean class.  If it's embedded within the
     * bean class, the JavaBeanWriter will set JavaBeanHelperWriter's
     * PrintWriter to its own.
     * 
     * @param pw 
     */
    protected void setPrintWriter(PrintWriter pw) {
        this.wrapperPW = pw;
    }    // setPrintWriter

    /**
     * The default behaviour (of super.getPrintWriter) is, given the
     * file name, create a PrintWriter for it.  If the bean helper
     * that this class is generating is embedded within a bean, then
     * the PrintWriter returned by this method is the JavaBeanWriter's
     * PrintWriter.  Otherwise super.getPrintWriter is called.
     * 
     * @param filename 
     * @return 
     * @throws IOException 
     */
    protected PrintWriter getPrintWriter(String filename) throws IOException {

        return (wrapperPW == null)
                ? super.getPrintWriter(filename)
                : wrapperPW;
    }    // getPrintWriter

    /**
     * Only register the filename if the bean helper is not wrapped
     * within a bean.
     * 
     * @param file 
     */
    protected void registerFile(String file) {

        if (wrapperPW == null) {
            super.registerFile(file);
        }
    }    // registerFile

    /**
     * Return the string:  "Generating <file>".
     * only if we are going to generate a new file.
     * 
     * @param file 
     * @return 
     */
    protected String verboseMessage(String file) {

        if (wrapperPW == null) {
            return super.verboseMessage(file);
        } else {
            return null;
        }
    }    // verboseMessage

    /**
     * Only write the file header if the bean helper is not wrapped
     * within a bean.
     * 
     * @param pw 
     * @throws IOException 
     */
    protected void writeFileHeader(PrintWriter pw) throws IOException {

        if (wrapperPW == null) {
            super.writeFileHeader(pw);
        }
    }    // writeFileHeader

    /**
     * Generate the file body for the bean helper.
     * 
     * @param pw 
     * @throws IOException 
     */
    protected void writeFileBody(PrintWriter pw) throws IOException {

        writeMetaData(pw);
        writeSerializer(pw);
        writeDeserializer(pw);
    }    // writeFileBody

    /**
     * Only write the file footer if the bean helper is not
     * wrapped within a bean.
     * 
     * @param pw 
     * @throws IOException 
     */
    protected void writeFileFooter(PrintWriter pw) throws IOException {

        if (wrapperPW == null) {
            super.writeFileFooter(pw);
        }
    }    // writeFileFooter

    /**
     * Only close the PrintWriter if the PrintWriter belongs to
     * this class.  If the bean helper is embedded within a bean
     * then the PrintWriter belongs to JavaBeanWriter and THAT
     * class is responsible for closing the PrintWriter.
     * 
     * @param pw 
     */
    protected void closePrintWriter(PrintWriter pw) {

        // If the output of this writer is wrapped within
        // another writer (JavaBeanWriter), then THAT
        // writer will close the PrintWriter, not this one.
        if (wrapperPW == null) {
            pw.close();
        }
    }    // closePrintWriter

    /**
     * write MetaData code
     * 
     * @param pw 
     * @throws IOException 
     */
    protected void writeMetaData(PrintWriter pw) throws IOException {

        // Collect elementMetaData
        if (elements != null) {
            for (int i = 0; i < elements.size(); i++) {
                ElementDecl elem = (ElementDecl) elements.get(i);

                // String elemName = elem.getName().getLocalPart();
                // String javaName = Utils.xmlNameToJava(elemName);
                // Changed the code to write meta data
                // for all of the elements in order to
                // support sequences. Defect 9060
                // Meta data is needed if the default serializer
                // action cannot map the javaName back to the
                // element's qname.  This occurs if:
                // - the javaName and element name local part are different.
                // - the javaName starts with uppercase char (this is a wierd
                // case and we have several problems with the mapping rules.
                // Seems best to gen meta data in this case.)
                // - the element name is qualified (has a namespace uri)
                // its also needed if:
                // - the element has the minoccurs flag set
                // if (!javaName.equals(elemName) ||
                // Character.isUpperCase(javaName.charAt(0)) ||
                // !elem.getName().getNamespaceURI().equals("") ||
                // elem.getMinOccursIs0()) {
                // If we did some mangling, make sure we'll write out the XML
                // the correct way.