javadeploywriter.java

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

        String useStr = " use=\"" + use + "\"";

        pw.println("  <service name=\"" + serviceName + "\" provider=\""
                + prefix + ":RPC" + "\"" + styleStr + useStr + ">");
        pw.println("      <parameter name=\"wsdlTargetNamespace\" value=\""
                + service.getQName().getNamespaceURI() + "\"/>");
        pw.println("      <parameter name=\"wsdlServiceElement\" value=\""
                + service.getQName().getLocalPart() + "\"/>");
        // MIME attachments don't work with multiref, so turn it off.
        if (hasMIME) {
            pw.println(
                    "      <parameter name=\"sendMultiRefs\" value=\"false\"/>");
        }
        ArrayList qualified = new ArrayList();
        ArrayList unqualified = new ArrayList();
        Map elementFormDefaults = symbolTable.getElementFormDefaults();
        for(Iterator it = elementFormDefaults.entrySet().iterator();it.hasNext();){
            Map.Entry entry =  (Map.Entry) it.next();
            if(entry.getValue().equals("qualified")){
                qualified.add(entry.getKey());
            } else {
                unqualified.add(entry.getKey());
            }
        }
        if(qualified.size()>0){
            pw.print("      <parameter name=\"schemaQualified\" value=\"");
            for(int i=0;i<qualified.size();i++){
                pw.print(qualified.get(i));
                if(i != qualified.size()-1){
                    pw.print(',');
                }
            }
            pw.println("\"/>");
        }
        if(unqualified.size()>0){
            pw.print("      <parameter name=\"schemaUnqualified\" value=\"");
            for(int i=0;i<unqualified.size();i++){
                pw.print(unqualified.get(i));
                if(i != unqualified.size()-1){
                    pw.print(',');
                }
            }
            pw.println("\"/>");
        }
        pw.println("      <parameter name=\"wsdlServicePort\" value=\""
                + serviceName + "\"/>");

        writeDeployBinding(pw, bEntry);
        writeDeployTypes(pw, bEntry.getBinding(), hasLiteral, hasMIME, use);
        pw.println("  </service>");
    }    // writeDeployPort

    /**
     * Write out deployment instructions for given WSDL binding
     *
     * @param pw
     * @param bEntry
     * @throws IOException
     */
    protected void writeDeployBinding(PrintWriter pw, BindingEntry bEntry)
            throws IOException {

        Binding binding = bEntry.getBinding();
        String className = bEntry.getName();

		if (emitter.isSkeletonWanted()) {
			 className += "Skeleton";
		 } else
		 {
			 String customClassName  = emitter.getImplementationClassName();
			 if ( customClassName != null )
				 className = customClassName;
			 else
				 className += "Impl";
		 }

        pw.println("      <parameter name=\"className\" value=\"" + className
                + "\"/>");

        pw.println("      <parameter name=\"wsdlPortType\" value=\""
                + binding.getPortType().getQName().getLocalPart() + "\"/>");

        pw.println("      <parameter name=\"typeMappingVersion\" value=\""
                   + emitter.getTypeMappingVersion() + "\"/>");

        HashSet allowedMethods = new HashSet();

        String namespaceURI = binding.getQName().getNamespaceURI();

        if (!emitter.isSkeletonWanted()) {
            Iterator operationsIterator =
                    binding.getBindingOperations().iterator();

            for (; operationsIterator.hasNext();) {
                BindingOperation bindingOper =
                        (BindingOperation) operationsIterator.next();
                Operation operation = bindingOper.getOperation();
                OperationType type = operation.getStyle();

                // These operation types are not supported.  The signature
                // will be a string stating that fact.
                if ((OperationType.NOTIFICATION.equals(type))
                        || (OperationType.SOLICIT_RESPONSE.equals(type))) {
                    continue;
                }
                String javaOperName = null;

                ServiceDesc serviceDesc = emitter.getServiceDesc();
                if (emitter.isDeploy() && serviceDesc != null) {
               		// If the emitter works in deploy mode, sync the java operation name with it of the ServiceDesc
                    OperationDesc[] operDescs = serviceDesc.getOperationsByQName(new QName(namespaceURI, operation.getName()));
                    if (operDescs.length == 0) {
                        log.warn("Can't find operation in the Java Class for WSDL binding operation : " + operation.getName());
                        continue;
                    }
                    OperationDesc operDesc = operDescs[0];
                    if (operDesc.getMethod() == null) {
                        log.warn("Can't find Java method for operation descriptor : " + operDesc.getName());
                        continue;
                    }

                    javaOperName = operDesc.getMethod().getName();
                } else {
                    javaOperName =
                        JavaUtils.xmlNameToJava(operation.getName());
                }

                allowedMethods.add(javaOperName);

                // We pass "" as the namespace argument because we're just
                // interested in the return type for now.
                Parameters params =
                        symbolTable.getOperationParameters(operation, "", bEntry);

                if (params != null) {
                    // TODO: Should really construct a FaultDesc here and
                    // TODO: pass it to writeOperation, but this will take
                    // TODO: some refactoring

                    // Get the operation QName
                    QName elementQName = Utils.getOperationQName(bindingOper,
                            bEntry, symbolTable);

                    // Get the operation's return QName and type
                    QName returnQName = null;
                    QName returnType = null;

                    if (params.returnParam != null) {
                        returnQName = params.returnParam.getQName();
                        returnType = Utils.getXSIType(params.returnParam);
                    }

                    // Get the operations faults
                    Map faultMap = bEntry.getFaults();
                    ArrayList faults = null;

                    if (faultMap != null) {
                        faults = (ArrayList) faultMap.get(bindingOper);
                    }

                    // Get the operation's SOAPAction
                    String SOAPAction = Utils.getOperationSOAPAction(bindingOper);

                    // Write the operation metadata
                    writeOperation(pw, javaOperName, elementQName, returnQName,
                            returnType, params, binding.getQName(),
                            faults, SOAPAction);
                }
            }
        }

        pw.print("      <parameter name=\"allowedMethods\" value=\"");

        if (allowedMethods.isEmpty()) {
            pw.println("*\"/>");
        } else {
            boolean first = true;

            for (Iterator i = allowedMethods.iterator(); i.hasNext();) {
                String method = (String) i.next();

                if (first) {
                    pw.print(method);

                    first = false;
                } else {
                    pw.print(" " + method);
                }
            }

            pw.println("\"/>");
        }

        Scope scope = emitter.getScope();

        if (scope != null) {
            pw.println("      <parameter name=\"scope\" value=\""
                    + scope.getName() + "\"/>");
        }
    }    // writeDeployBinding

    /**
     * Raw routine that writes out the operation and parameters.
     *
     * @param pw
     * @param javaOperName
     * @param elementQName
     * @param returnQName
     * @param returnType
     * @param params
     * @param bindingQName
     * @param faults
     */
    protected void writeOperation(PrintWriter pw, String javaOperName,
                                  QName elementQName, QName returnQName,
                                  QName returnType, Parameters params,
                                  QName bindingQName, ArrayList faults,
                                  String SOAPAction) {

        pw.print("      <operation name=\"" + javaOperName + "\"");

        if (elementQName != null) {
            pw.print(" qname=\""
                    + Utils.genQNameAttributeString(elementQName, "operNS")
                    + "\"");
        }

        if (returnQName != null) {
            pw.print(" returnQName=\""
                    + Utils.genQNameAttributeStringWithLastLocalPart(returnQName, "retNS")
                    + "\"");
        }

        if (returnType != null) {
            pw.print(" returnType=\""
                    + Utils.genQNameAttributeString(returnType, "rtns")
                    + "\"");
        }

        Parameter retParam = params.returnParam;
        if (retParam != null) {
            TypeEntry type = retParam.getType();
            QName returnItemQName = Utils.getItemQName(type);
            if (returnItemQName != null) {
                pw.print(" returnItemQName=\"");
                pw.print(Utils.genQNameAttributeString(returnItemQName, "tns"));
                pw.print("\"");
            }
            QName returnItemType = Utils.getItemType(type);
            if (returnItemType != null && use == Use.ENCODED) {
                    pw.print(" returnItemType=\"");
                    pw.print(Utils.genQNameAttributeString(returnItemType, "tns2"));
                    pw.print("\"");
            }
        }

        if (SOAPAction != null) {
            pw.print(" soapAction=\""
                    + SOAPAction
                    + "\"");
        }

        if (!OperationType.REQUEST_RESPONSE.equals(params.mep)) {
            String mepString = getMepString(params.mep);
            if (mepString != null) {
                pw.print(" mep=\""
                         + mepString
                         + "\"");
            }
        }

        if ((params.returnParam != null) && params.returnParam.isOutHeader()) {
            pw.print(" returnHeader=\"true\"");
        }

        pw.println(" >");

        Vector paramList = params.list;

        for (int i = 0; i < paramList.size(); i++) {
            Parameter param = (Parameter) paramList.elementAt(i);

            // Get the parameter name QName and type QName
            QName paramQName = param.getQName();
            QName paramType = Utils.getXSIType(param);

            pw.print("        <parameter");

            if (paramQName == null) {
                pw.print(" name=\"" + param.getName() + "\"");
            } else {
                pw.print(" qname=\""
                        + Utils.genQNameAttributeStringWithLastLocalPart(paramQName, "pns")
                        + "\"");
            }

            pw.print(" type=\""
                    + Utils.genQNameAttributeString(paramType, "tns") + "\"");

            // Get the parameter mode
            if (param.getMode() != Parameter.IN) {
                pw.print(" mode=\"" + getModeString(param.getMode()) + "\"");
            }

            // Is this a header?
            if (param.isInHeader()) {
                pw.print(" inHeader=\"true\"");
            }

            if (param.isOutHeader()) {
                pw.print(" outHeader=\"true\"");
            }

            QName itemQName = Utils.getItemQName(param.getType());
            if (itemQName != null) {
                pw.print(" itemQName=\"");
                pw.print(Utils.genQNameAttributeString(itemQName, "itns"));
                pw.print("\"");
            }

            pw.println("/>");
        }

        if (faults != null) {
            for (Iterator iterator = faults.iterator(); iterator.hasNext();) {
                FaultInfo faultInfo = (FaultInfo) iterator.next();
                QName faultQName = faultInfo.getQName();

                if (faultQName != null) {
                    String className =
                            Utils.getFullExceptionName(faultInfo.getMessage(),
                                    symbolTable);

                    pw.print("        <fault");
                    pw.print(" name=\"" + faultInfo.getName() + "\"");
                    pw.print(" qname=\""
                            + Utils.genQNameAttributeString(faultQName, "fns")
                            + "\"");
                    pw.print(" class=\"" + className + "\"");
                    pw.print(
                            " type=\""
                            + Utils.genQNameAttributeString(
                                    faultInfo.getXMLType(), "tns") + "\"");
                    pw.println("/>");
                }
            }
        }

        pw.println("      </operation>");
    }

    /**
     * Method getModeString
     *
     * @param mode
     * @return
     */
    public String getModeString(byte mode) {

        if (mode == Parameter.IN) {
            return "IN";
        } else if (mode == Parameter.INOUT) {
            return "INOUT";
        } else {
            return "OUT";
        }
    }

    /**
     * Method getPrintWriter
     *
     * @param filename
     * @return
     * @throws IOException
     */
    protected PrintWriter getPrintWriter(String filename) throws IOException {

        File file = new File(filename);
        File parent = new File(file.getParent());

        parent.mkdirs();

        FileOutputStream out = new FileOutputStream(file);
        OutputStreamWriter writer = new OutputStreamWriter(out, "UTF-8");

        return new PrintWriter(writer);
    }
    
    private static final Map mepStrings = new HashMap();
    static {
        mepStrings.put(OperationType.REQUEST_RESPONSE.toString(), "request-response");
        mepStrings.put(OperationType.ONE_WAY.toString(), "oneway");
    }
    
    String getMepString(OperationType mep) {
        return (String)mepStrings.get(mep.toString());
    }
}    // class JavaDeployWriter