wsdlbuilder.java

Xfire文件 用于开发web service 的一个开源工具 很好用的

package org.codehaus.xfire.wsdl11.builder;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.wsdl.Definition;
import javax.wsdl.Fault;
import javax.wsdl.Input;
import javax.wsdl.Message;
import javax.wsdl.Output;
import javax.wsdl.Part;
import javax.wsdl.Port;
import javax.wsdl.PortType;
import javax.wsdl.Types;
import javax.wsdl.WSDLException;
import javax.wsdl.extensions.schema.Schema;
import javax.wsdl.factory.WSDLFactory;
import javax.xml.namespace.QName;

import org.codehaus.xfire.XFireRuntimeException;
import org.codehaus.xfire.service.Binding;
import org.codehaus.xfire.service.Endpoint;
import org.codehaus.xfire.service.FaultInfo;
import org.codehaus.xfire.service.MessageInfo;
import org.codehaus.xfire.service.MessagePartInfo;
import org.codehaus.xfire.service.OperationInfo;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;
import org.codehaus.xfire.soap.SoapConstants;
import org.codehaus.xfire.transport.TransportManager;
import org.codehaus.xfire.util.DOMUtils;
import org.codehaus.xfire.wsdl.AbstractWSDL;
import org.codehaus.xfire.wsdl.SchemaType;
import org.codehaus.xfire.wsdl.WSDLWriter;
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.Namespace;
import org.jdom.output.DOMOutputter;

import com.ibm.wsdl.extensions.schema.SchemaImpl;

/**
 * WSDL
 * 
 * @author <a href="mailto:[e-mail]">Dan Diephouse</a>
 * @author <a href="mailto:[e-mail]">Tomasz Sztelak</a>
 * 
 */
public class WSDLBuilder
    extends org.codehaus.xfire.wsdl.AbstractWSDL
    implements WSDLWriter
{
    public static final String OVERRIDING_TYPES = "overridingTypes";

    private static final QName SCHEMA_QNAME = new QName(SoapConstants.XSD, "schema");
    
    private PortType portType;

    private Map wsdlOps = new HashMap();

    private TransportManager transportManager;

    private Map declaredParameters = new HashMap();

    private List extensions;

    private Definition def;
    
    org.w3c.dom.Document w3cDocument =  DOMUtils.createDocument();
    

    
    public WSDLBuilder(Service service, TransportManager transportManager) throws WSDLException
    {
        super(service);

        setDefinition(WSDLFactory.newInstance().newDefinition());
        getDefinition().setTargetNamespace(getTargetNamespace());
        
        getDefinition().getExtensionRegistry().registerSerializer(Types.class, 
                                                                  SCHEMA_QNAME,
                                                                  new SchemaSerializer());
                                                    
        this.transportManager = transportManager;
    }

    public TransportManager getTransportManager()
    {
        return transportManager;
    }

    public void setTransportManager(TransportManager transportManager)
    {
        this.transportManager = transportManager;
    }

    protected void writeComplexTypes()
    {
        if (getSchemaTypes().getContentSize() > 0)
        {   
            Element schemaTypes = getSchemaTypes();
            List addNs = schemaTypes.getAdditionalNamespaces();
            for (Iterator itr = addNs.iterator(); itr.hasNext();)
            {
                Namespace ns = (Namespace) itr.next();

                if (getDefinition().getNamespace(ns.getPrefix()) == null)
                    addNamespace(ns.getPrefix(), ns.getURI());
            }
            
            try
            {
                Types types = getDefinition().getTypes();
                if (types == null)
                {
                    types = getDefinition().createTypes();
                    getDefinition().setTypes(types);
                }
                
                List children = schemaTypes.getChildren();
                while (children.size() > 0)
                {
                    Element child = (Element) children.get(0);
                    child.detach();
                    
                    if (child.getChildren().size() > 0)
                    {
                        Document inputDoc = new Document(child);
                        org.w3c.dom.Document doc = new DOMOutputter().output(inputDoc);
                        
                        Schema uee = new SchemaImpl();
                        uee.setElement((org.w3c.dom.Element) doc.getDocumentElement());
                        uee.setRequired(Boolean.TRUE);
                        uee.setElementType(SCHEMA_QNAME);
                        types.addExtensibilityElement(uee);
                    }
                }
            }
            catch (JDOMException e)
            {
                throw new XFireRuntimeException("Could write schemas to wsdl!", e);
            }
        }
    }
        
    public void write(OutputStream out)
        throws IOException
    {
        try
        {
            initialize();
            
            PortType portType = createAbstractInterface();

            createConcreteInterface(portType);
            
            updateImports();
            
            initializeOverrideTypes();
            
            writeComplexTypes();
            
            if (extensions != null)
            {
                for (Iterator itr = extensions.iterator(); itr.hasNext();)
                {
                    WSDLBuilderExtension ex = (WSDLBuilderExtension) itr.next();
                    
                    ex.extend(getDefinition(), this);
                }
            }
            
            javax.wsdl.xml.WSDLWriter writer = WSDLFactory.newInstance().newWSDLWriter();
            writer.writeWSDL(getDefinition(), out);
        }
        catch (WSDLException e)
        {
            throw new XFireRuntimeException("Error creating wsdl", e);
        }
    }


    private void initializeOverrideTypes()
    {
        List l = (List) getService().getProperty(OVERRIDING_TYPES);
        if (l != null)
        {
            for (Iterator it = l.iterator(); it.hasNext();)
            {
                SchemaType t = (SchemaType) it.next();
                addDependency(t);
            }
        }
    }

    public PortType createAbstractInterface()
        throws WSDLException
    {
        Service service = getService();
        Definition def = getDefinition();

        QName portName = service.getServiceInfo().getPortType();

        if (portName == null)
            portName = new QName(getTargetNamespace(), service.getSimpleName() + "PortType");

        portType = def.createPortType();
        portType.setQName(portName);
        portType.setUndefined(false);
        
        String doc = service.getServiceInfo().getDocumentation();
        if( doc != null ){
            portType.setDocumentationElement(createElement(doc));    
        }
        
        
        def.addPortType(portType);

        // Create Abstract operations
        for (Iterator itr = service.getServiceInfo().getOperations().iterator(); itr.hasNext();)
        {
            OperationInfo op = (OperationInfo) itr.next();
            

            // Create input message
            Message req = createInputMessage(op);
            def.addMessage(req);
           
           
            
            // Create output message if we have an out MEP
            Message res = null;
            if (op.getMEP().equals(SoapConstants.MEP_ROBUST_IN_OUT))
            {
                res = createOutputMessage(op);
                def.addMessage(res);
            }

            // Create the fault messages
            List faultMessages = new ArrayList();
            for (Iterator faultItr = op.getFaults().iterator(); faultItr.hasNext();)
            {
                FaultInfo fault = (FaultInfo) faultItr.next();
                Fault faultMsg = createFault(op, fault);
                if( fault.getDocumentation()!= null ){
                    faultMsg.setDocumentationElement(createElement(fault.getDocumentation()));    
                }
                
                faultMessages.add(faultMsg);
            }

            javax.wsdl.Operation wsdlOp = createOperation(op, req, res, faultMessages);
            wsdlOp.setUndefined(false);
            portType.addOperation(wsdlOp);
            
            String opDoc  = op.getDocumenation();
            if( opDoc != null ){
                wsdlOp.setDocumentationElement(createElement(opDoc));    
            }
            
            wsdlOps.put(op.getName(), wsdlOp);
        }

        return portType;
    }
    
    
    private org.w3c.dom.Element createElement(String value){

        org.w3c.dom.Element elem =  w3cDocument.createElementNS(WSDL11_NS, "documentation");
        String prefix = getNamespacePrefix(WSDL11_NS);
        elem.setPrefix(prefix);
        elem.setNodeValue(value);
        return elem;
    }

    public void createConcreteInterface(PortType portType)
    {
        Service service = getService();
        Definition def = getDefinition();

        QName name = service.getName();

        // Create a concrete instance for each transport.
        javax.wsdl.Service wsdlService = def.createService();
        wsdlService.setQName(name);

        for (Iterator itr = service.getBindings().iterator(); itr.hasNext();)
        {
            Binding binding = (Binding) itr.next();

            javax.wsdl.Binding wbinding = binding.createBinding(this, portType);

            Port port = binding.createPort(this, wbinding);
            if (port != null)
            {
                wsdlService.addPort(port);
            }

            // Add in user defined endpoints
            Collection endpoints = service.getEndpoints(binding.getName());
            if (endpoints == null)
                continue;

            for (Iterator eitr = endpoints.iterator(); eitr.hasNext();)
            {
                Endpoint ep = (Endpoint) eitr.next();

                port = binding.createPort(ep, this, wbinding);
                if (port != null)
                {
                    wsdlService.addPort(port);
                }
            }
        }

        def.addService(wsdlService);
    }

    private Message createOutputMessage(OperationInfo op)
    {
        // response message
        Message res = getDefinition().createMessage();
        res.setQName(new QName(getTargetNamespace(), op.getName() + "Response"));

        res.setUndefined(false);

        if (getService().getServiceInfo().isWrapped())
            createWrappedOutputParts(res, op);
        else
            createOutputParts(res, op);

        return res;
    }

    private void createDocumentation(List messageParts){
        for(Iterator itr = messageParts.iterator();itr.hasNext();){
            MessagePartInfo param = (MessagePartInfo) itr.next();
           
           if( param.getDocumentation() != null){
           
               Element e = (Element) typeMap.get(param.getName().getNamespaceURI());
               List children  =  e.getChildren("element",Namespace.getNamespace(SoapConstants.XSD));
               for( Iterator elemItr = children.iterator(); elemItr.hasNext();){
                   Element elem = (Element) elemItr .next();
                   if(elem.getAttribute("name").getValue().equals(param.getName().getLocalPart())){
                       elem.addContent(createDocElement(param.getDocumentation()));
                       break;
                   }
               }