wsdlbuilder.java

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

           }
        }

    }
    private Message createInputMessage(OperationInfo op)
    {
        Message req = getDefinition().createMessage();
        req.setQName(new QName(getTargetNamespace(), op.getName() + "Request"));
        req.setUndefined(false);

        if (getService().getServiceInfo().isWrapped())
            createWrappedInputParts(req, op);
        else
            createInputParts(req, op);

        return req;
    }

    private Fault createFault(OperationInfo op, FaultInfo faultInfo)
    {
        Message faultMsg = getDefinition().createMessage();
        faultMsg.setQName(new QName(getTargetNamespace(), faultInfo.getName()));
        faultMsg.setUndefined(false);
        getDefinition().addMessage(faultMsg);

        Fault fault = getDefinition().createFault();
        fault.setName(faultInfo.getName());
        fault.setMessage(faultMsg);

        for (Iterator itr = faultInfo.getMessageParts().iterator(); itr.hasNext();)
        {
            MessagePartInfo info = (MessagePartInfo) itr.next();

            String uri = info.getName().getNamespaceURI();
            addNamespace(getNamespacePrefix(uri), uri);

            Part part = createPart(info);
            faultMsg.addPart(part);
        }

        return fault;
    }

    public Part createPart(MessagePartInfo part)
    {
        String style = (String) getService().getProperty(ObjectServiceFactory.STYLE);
        if (style != null && style.equals(SoapConstants.STYLE_RPC))
        {
            return createRpcLitPart(part.getName(), part.getTypeClass(), part.getSchemaType());
        }
        else
        {   
          return createDocLitPart(part.getName(), part.getTypeClass(), part.getSchemaType());
        }
    }

    /**
     * Creates a wsdl:message part without creating a global schema element.
     * 
     * @param pName
     * @param clazz
     * @param type
     * @return
     */
    public Part createRpcLitPart(QName pName, Class clazz, SchemaType type)
    {
        addDependency(type);

        QName schemaTypeName = type.getSchemaType();

        Part part = getDefinition().createPart();
        part.setName(pName.getLocalPart());

        String prefix = getNamespacePrefix(schemaTypeName.getNamespaceURI());
        addNamespace(prefix, schemaTypeName.getNamespaceURI());

        if (!type.isAbstract())
        {
            part.setElementName(schemaTypeName);
        }
        else
        {

            part.setTypeName(schemaTypeName);
        }

        return part;
    }

    /**
     * Creates a wsdl:message part and a global schema element for it if it is
     * abstract.
     * 
     * @param pName
     * @param clazz
     * @param type
     * @return
     */
    public Part createDocLitPart(QName pName, Class clazz, SchemaType type)
    {
        addDependency(type);

        QName schemaTypeName = type.getSchemaType();

        Part part = getDefinition().createPart();
        part.setName(pName.getLocalPart());
        
        if (!type.isAbstract())
        {
            String prefix = getNamespacePrefix(schemaTypeName.getNamespaceURI());
            addNamespace(prefix, schemaTypeName.getNamespaceURI());

            part.setElementName(schemaTypeName);

            return part;
        }

        SchemaType regdType = (SchemaType) declaredParameters.get(pName);
        if (regdType == null)
        {
            Element schemaEl = createSchemaType(pName.getNamespaceURI());

            Element element = new Element("element", XSD_NS);
            schemaEl.addContent(element);

            String prefix = getNamespacePrefix(schemaTypeName.getNamespaceURI());
            addNamespace(prefix, schemaTypeName.getNamespaceURI());

            if (type.isAbstract())
            {
                element.setAttribute(new Attribute("name", pName.getLocalPart()));
                element.setAttribute(new Attribute("type", prefix + ":"
                        + schemaTypeName.getLocalPart()));
            }

            declaredParameters.put(pName, type);
        }
        else
        {
            if (!regdType.equals(type))
            {
                throw new XFireRuntimeException(
                        "Cannot create two schema elements with the same name "
                                + "and of different types: " + pName);

            }
        }

        part.setElementName(pName);

        return part;
    }

    public javax.wsdl.Operation createOperation(OperationInfo op,
                                                Message req,
                                                Message res,
                                                List faultMessages)
    {
        Definition def = getDefinition();
        javax.wsdl.Operation wsdlOp = def.createOperation();

        Input input = def.createInput();
        input.setMessage(req);
        input.setName(req.getQName().getLocalPart());
        
       
        wsdlOp.setInput(input);

        if (res != null)
        {
            Output output = def.createOutput();
            output.setMessage(res);
            output.setName(res.getQName().getLocalPart());
            wsdlOp.setOutput(output);
        }

        for (Iterator itr = faultMessages.iterator(); itr.hasNext();)
        {
            wsdlOp.addFault((Fault) itr.next());
        }

        wsdlOp.setName(op.getName());

        return wsdlOp;
    }

    public void createInputParts(Message req, OperationInfo op)
    {
        writeParameters(req, op.getInputMessage().getMessageParts());
        createDocumentation(op.getInputMessage().getMessageParts());
    }

    public void createOutputParts(Message req, OperationInfo op)
    {
        writeParameters(req, op.getOutputMessage().getMessageParts());
        createDocumentation(op.getOutputMessage().getMessageParts());
    }

    private void writeParameters(Message message, Collection params)
    {
        for (Iterator itr = params.iterator(); itr.hasNext();)
        {
            MessagePartInfo param = (MessagePartInfo) itr.next();

            String prefix = getNamespacePrefix(param.getName().getNamespaceURI());
            addNamespace(prefix, param.getName().getNamespaceURI());
            
            addNamespaceImport(getService().getTargetNamespace(), param.getSchemaType()
                    .getSchemaType().getNamespaceURI());

            Part part = createPart(param);
            
            message.addPart(part);
        }
    }

    protected void createWrappedInputParts(Message req, OperationInfo op)
    {
        Part part = getDefinition().createPart();

        QName typeQName = createDocumentType(op.getInputMessage(), part, op.getName());
        part.setName("parameters");
        part.setElementName(typeQName);
       
              
        req.addPart(part);
    }

    protected void createWrappedOutputParts(Message req, OperationInfo op)
    {
        // response message part
        Part part = getDefinition().createPart();

        // Document style service
        QName typeQName = createDocumentType(op.getOutputMessage(), part, op.getName() + "Response");
        part.setElementName(typeQName);
        part.setName("parameters");
        req.addPart(part);
    }

    protected QName createDocumentType(MessageInfo message, Part part, String opName)
    {
        Element element = new Element("element", AbstractWSDL.XSD_NS);
        element.setAttribute(new Attribute("name", opName));

        Element complex = new Element("complexType", AbstractWSDL.XSD_NS);
        element.addContent(complex);

        if (message.getMessageParts().size() > 0)
        {
            Element sequence = createSequence(complex);

            writeParametersSchema(message.getMessageParts(), sequence);
        }

        /**
         * Don't create the schema until after we add the types in (via
         * WSDLBuilder.addDependency()) writeParametersSchema.
         */
        Element schemaEl = createSchemaType(getTargetNamespace());
        schemaEl.addContent(element);

        return new QName(getTargetNamespace(), opName);
    }

    /**
     * @param op
     * @param sequence
     */
    protected void writeParametersSchema(Collection params, Element sequence)
    {
        for (Iterator itr = params.iterator(); itr.hasNext();)
        {
            MessagePartInfo param = (MessagePartInfo) itr.next();

            QName pName = param.getName();
            SchemaType type = param.getSchemaType();

            addDependency(type);
            QName schemaType = type.getSchemaType();

            addNamespaceImport(getService().getTargetNamespace(), schemaType.getNamespaceURI());

            String uri = type.getSchemaType().getNamespaceURI();
            String prefix = getNamespacePrefix(uri);
            addNamespace(prefix, uri);
            
            Element element = new Element("element", AbstractWSDL.XSD_NS);
            sequence.addContent(element);

            if (type.isAbstract())
            {
                element.setAttribute(new Attribute("name", pName.getLocalPart()));

                element.setAttribute(new Attribute("type", prefix + ":"
                                + schemaType.getLocalPart()));
                
                if (type.isNillable())
                {
                    element.setAttribute(new Attribute("nillable", "true"));
                }
            }
            else
            {
                element.setAttribute(new Attribute("ref", prefix + ":" + schemaType.getLocalPart()));
            }

            element.setAttribute(new Attribute("minOccurs", "1"));
            element.setAttribute(new Attribute("maxOccurs", "1"));
            if( param.getDocumentation()!=null){
                element.addContent(createDocElement(param.getDocumentation()));
            }
        }
    }

     private Element createDocElement(String value ){
         
         Element ann  = new Element("annotation",AbstractWSDL.XSD_NS);
         Element doc = new Element("documentation",AbstractWSDL.XSD_NS);
         doc.setText(value);
         return ann.addContent(doc);
     }
     
    public void addNamespace(String prefix, String uri)
    {
        def.addNamespace(prefix, uri);

        super.addNamespace(prefix, uri);
    }

    protected Element createSequence(Element complex)
    {
        Element sequence = new Element("sequence", AbstractWSDL.XSD_NS);
        complex.addContent(sequence);
        return sequence;
    }

    public List getWSDLBuilderExtensions()
    {
        return extensions;
    }

    public void setWSDLBuilderExtensions(List extensions)
    {
        this.extensions = extensions;
    }

    public Definition getDefinition()
    {
        return def;
    }

    public void setDefinition(Definition definition)
    {
        this.def = definition;
    }

}