emitter.java

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

                qname = new QName(intfNS, qname.getLocalPart());
            }

            oper.setElementQName(qname);
        }
    }

    /**
     * Method getResponseQName
     * 
     * @param oper 
     * @return 
     */
    protected QName getResponseQName(OperationDesc oper) {

        qualifyOperation(oper);

        QName qname = oper.getElementQName();

        if (qname == null) {
            return new QName(oper.getName() + "Response");
        }

        return new QName(qname.getNamespaceURI(),
                qname.getLocalPart() + "Response");
    }

    /**
     * Write out the schema definition for a WRAPPED operation request or
     * response.
     * 
     * @param def     
     * @param msg     
     * @param oper    
     * @param request
     * @return the name of the part the was written
     * @throws AxisFault 
     */
    public String writeWrapperPart(
            Definition def, Message msg, OperationDesc oper, boolean request)
            throws AxisFault {

        QName qname = request
                ? getRequestQName(oper)
                : getResponseQName(oper);

        boolean hasParams;
        if (request) {
            hasParams = (oper.getNumInParams() > 0);
        } else {
            if (oper.getReturnClass() != void.class) {
                hasParams = true;
            } else {
                hasParams = (oper.getNumOutParams() > 0);
            }
        }

        // First write the wrapper element itself.
        Element sequence = types.writeWrapperElement(qname, request, hasParams);

        // If we got anything back above, there must be parameters in the
        // operation, and it's a <sequence> node in which to write them...
        if (sequence != null) {
            ArrayList parameters = request
                    ? oper.getAllInParams()
                    : oper.getAllOutParams();

            if (!request) {
                String retName;
                
                if (oper.getReturnQName() == null) {
                    retName = oper.getName() + "Return";
                } else {
                    retName = oper.getReturnQName().getLocalPart();
                }

                types.writeWrappedParameter(sequence, retName,
                        oper.getReturnType(),
                        oper.getReturnClass());
            }

            for (int i = 0; i < parameters.size(); i++) {
                ParameterDesc parameter = (ParameterDesc) parameters.get(i);

                // avoid headers
                if (!parameter.isInHeader() && !parameter.isOutHeader())
                {
                    types.writeWrappedParameter(sequence,
                                                parameter.getName(),
                                                parameter.getTypeQName(),
                                                parameter.getJavaType());
                }
            }
        }

        // Finally write the part itself
        Part part = def.createPart();

        part.setName("parameters");    // We always use "parameters"
        part.setElementName(qname);
        msg.addPart(part);

        return part.getName();
    }

    /**
     * Create a Response Message
     * 
     * @param def  
     * @param desc 
     * @return 
     * @throws WSDLException 
     * @throws AxisFault     
     */
    protected Message writeResponseMessage(Definition def, OperationDesc desc, BindingOperation bindop)
            throws WSDLException, AxisFault
    {
        String partName;
        ArrayList bodyParts = new ArrayList();
        ArrayList parameters = desc.getAllOutParams();

        Message msg = def.createMessage();
        QName qName =
                createMessageName(def, getResponseQName(desc).getLocalPart());

        msg.setQName(qName);
        msg.setUndefined(false);

        // output all the parts for headers
        boolean headers = writeHeaderParts(def, parameters, bindop, msg, false);

        if (desc.getStyle() == Style.WRAPPED) {
            partName = writeWrapperPart(def, msg, desc, false);
            bodyParts.add(partName);
        } else {

            // Write the return value part
            ParameterDesc retParam = new ParameterDesc();

            if (desc.getReturnQName() == null) {
                String ns = "";

                if (desc.getStyle() != Style.RPC) {
                    ns = getServiceDesc().getDefaultNamespace();

                    if ((ns == null) || "".equals(ns)) {
                        ns = "http://ws.apache.org/axis/defaultNS";
                    }
                }

                retParam.setQName(new QName(ns, desc.getName() + "Return"));
            } else {
                retParam.setQName(desc.getReturnQName());
            }

            retParam.setTypeQName(desc.getReturnType());
            retParam.setMode(ParameterDesc.OUT);
            retParam.setIsReturn(true);
            retParam.setJavaType(desc.getReturnClass());
            String returnPartName = writePartToMessage(def, msg, false, retParam);
            bodyParts.add(returnPartName);

            // write a part for each non-header parameter
            for (int i = 0; i < parameters.size(); i++) {
                ParameterDesc parameter = (ParameterDesc) parameters.get(i);
                if (!parameter.isInHeader() && !parameter.isOutHeader()) {
                    partName = writePartToMessage(def, msg, false, parameter);
                    bodyParts.add(partName);
                }
            }

        }
        // If we have headers, we must fill in the parts attribute of soap:body
        // if not, we just leave it out (which means all parts)
        if (headers) {
            // Find soap:body in binding
            List extensibilityElements = bindop.getBindingOutput().getExtensibilityElements();
            for (int i = 0; i < extensibilityElements.size(); i++)
            {
                Object ele = extensibilityElements.get(i);
                if (ele instanceof SOAPBodyImpl)
                {
                    SOAPBodyImpl soapBody = (SOAPBodyImpl) ele;
                    soapBody.setParts(bodyParts);
                }
            }
        }

        return msg;
    }

    /**
     * Create a Fault Message
     * 
     * @param def       
     * @param exception (an ExceptionRep object)
     * @return 
     * @throws WSDLException 
     * @throws AxisFault     
     */
    protected Message writeFaultMessage(Definition def, FaultDesc exception)
            throws WSDLException, AxisFault {

        String pkgAndClsName = exception.getClassName();
        String clsName =
                pkgAndClsName.substring(pkgAndClsName.lastIndexOf('.') + 1,
                        pkgAndClsName.length());

        // Do this to cover the complex type case with no meta data
        exception.setName(clsName);

        // The following code uses the class name for both the name= attribute
        // and the message= attribute.
        Message msg = (Message) exceptionMsg.get(pkgAndClsName);

        if (msg == null) {
            msg = def.createMessage();

            QName qName = createMessageName(def, clsName);

            msg.setQName(qName);
            msg.setUndefined(false);

            ArrayList parameters = exception.getParameters();

            if (parameters != null) {
                for (int i = 0; i < parameters.size(); i++) {
                    ParameterDesc parameter = (ParameterDesc) parameters.get(i);

                    writePartToMessage(def, msg, true, parameter);
                }
            }

            exceptionMsg.put(pkgAndClsName, msg);
        }

        return msg;
    }

    /**
     * Create a Part
     * 
     * @param def     
     * @param msg     
     * @param request message is for a request
     * @param param   ParamRep object
     * @return The parameter name added or null
     * @throws WSDLException 
     * @throws AxisFault     
     */
    public String writePartToMessage(
            Definition def, Message msg, boolean request, ParameterDesc param)
            throws WSDLException, AxisFault {

        // Return if this is a void type
        if ((param == null) || (param.getJavaType() == java.lang.Void.TYPE)) {
            return null;
        }

        // If Request message, only continue if IN or INOUT
        // If Response message, only continue if OUT or INOUT
        if (request && (param.getMode() == ParameterDesc.OUT)) {
            return null;
        }

        if (!request && (param.getMode() == ParameterDesc.IN)) {
            return null;
        }

        // Create the Part
        Part part = def.createPart();

        if (param.getDocumentation() != null) {
            part.setDocumentationElement(
                    createDocumentationElement(
                            param.getDocumentation()));
        }

        // Get the java type to represent in the wsdl
        // (if the mode is OUT or INOUT and this
        // parameter does not represent the return type,
        // the type held in the Holder is the one that should
        // be written.)
        Class javaType = param.getJavaType();

        if ((param.getMode() != ParameterDesc.IN)
                && (param.getIsReturn() == false)) {
            javaType = JavaUtils.getHolderValueType(javaType);
        }

        if ((use == Use.ENCODED) || (style == Style.RPC)) {

            // Add the type representing the param
            // Write <part name=param_name type=param_type>
            QName typeQName = param.getTypeQName();

            if (javaType != null) {
                typeQName = types.writeTypeAndSubTypeForPart(javaType, typeQName);
            }

            // types.writeElementForPart(javaType, param.getTypeQName());
            if (typeQName != null) {
                part.setName(param.getName());
                part.setTypeName(typeQName);
                msg.addPart(part);
            }
        } else if (use == Use.LITERAL) {

            // This is doc/lit.  So we should write out an element
            // declaration whose name and type may be found in the
            // ParameterDesc.
            QName qname = param.getQName();

            if (param.getTypeQName() == null) {
                log.warn(Messages.getMessage("registerTypeMappingFor01",
                        param.getJavaType().getName()));
                QName qName = types.writeTypeForPart(param.getJavaType(),null);
                if (qName != null) {
                    param.setTypeQName(qName);                    
                } else {
                    param.setTypeQName(Constants.XSD_ANYTYPE);                    
                }                    
            }

            if (param.getTypeQName().getNamespaceURI().equals("")) {
                param.setTypeQName(
                        new QName(intfNS, param.getTypeQName().getLocalPart()));
            }

            if (param.getQName().getNamespaceURI().equals("")) {
                qname = new QName(intfNS, param.getQName().getLocalPart());

                param.setQName(qname);
            }

            // Make sure qname's value is unique.
            ArrayList   names = (ArrayList)
                    usedElementNames.get(qname.getNamespaceURI());
            if (names == null) {
                names = new ArrayList(1);
                usedElementNames.put(qname.getNamespaceURI(), names);
            }
            else if (names.contains(qname.getLocalPart())) {
                qname = new QName(qname.getNamespaceURI(),
                    JavaUtils.getUniqueValue(names, qname.getLocalPart()));
            }
            names.add(qname.getLocalPart());

            types.writeElementDecl(qname,
                                   param.getJavaType(),
                                   param.getTypeQName(),
                                   false,
                                   param.getItemQName());

            part.setName(param.getName());
            part.setElementName(qname);
            msg.addPart(part);
        }

        // return the name of the parameter added
        return param.getName();
    }

    /*
     * Return a message QName which has not already been defined in the WSDL
     */

    /**
     * Method createMessageName
     * 
     * @param def        
     * @param methodName 
     * @return 
     */
    protected QName createMessageName(Definition def, String methodName) {

        QName qName = new QName(intfNS, methodName);

        // Check the make sure there isn't a message with this name already
        int messageNumber = 1;

        while (def.getMessage(qName) != null) {
            StringBuffer namebuf = new StringBuffer(methodName);

            namebuf.append(messageNumber);

            qName = new QName(intfNS, namebuf.toString());

            messageNumber++;
        }

        return qName;
    }

    /**
     * Write a prettified document t