soapenvelope.java

来自「it is a tools for developing J2ME applic」· Java 代码 · 共 325 行

/* Copyright (c) 2003,2004, Stefan Haustein, Oberhausen, Rhld., Germany
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The  above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE. */


package org.ksoap2;

import java.io.*;

import org.xmlpull.v1.*;
import org.kxml2.kdom.*;

/** 
 * A SOAP envelope, holding head and body objects. While this 
 * basic envelope supports literal encoding as content format 
 * via KDom, The SoapSerializationEnvelope provides support
 * for the SOAP Serialization format specification and 
 * simple object serialization. */

public class SoapEnvelope {

    /** SOAP Version 1.0 constant */

    public static final int VER10 = 100;

    /** SOAP Version 1.1 constant */

    public static final int VER11 = 110;

    /** SOAP Version 1.2 constant */

    public static final int VER12 = 120;

    public static final String ENV2001 =
        "http://www.w3.org/2001/12/soap-envelope";

    public static final String ENC2001 =
        "http://www.w3.org/2001/12/soap-encoding";

    /** Namespace constant: http://schemas.xmlsoap.org/soap/envelope/ */

    public static final String ENV =
        "http://schemas.xmlsoap.org/soap/envelope/";

    /** Namespace constant: http://schemas.xmlsoap.org/soap/encoding/ */

    public static final String ENC =
        "http://schemas.xmlsoap.org/soap/encoding/";

    /** Namespace constant: http://www.w3.org/2001/XMLSchema */

    public static final String XSD = "http://www.w3.org/2001/XMLSchema";

    /** Namespace constant: http://www.w3.org/2001/XMLSchema */

    public static final String XSI =
        "http://www.w3.org/2001/XMLSchema-instance";

    /** Namespace constant: http://www.w3.org/1999/XMLSchema */

    public static final String XSD1999 = "http://www.w3.org/1999/XMLSchema";

    /** Namespace constant: http://www.w3.org/1999/XMLSchema */

    public static final String XSI1999 =
        "http://www.w3.org/1999/XMLSchema-instance";

    
    /** 
     * Returns true for the string values "1" and "true", ignoring 
     * upper/lower case and whitespace, false otherwise. */ 

    public static boolean stringToBoolean(String s) {

        if (s == null)
            return false;

        s = s.trim().toLowerCase();
        return (s.equals("1") || s.equals("true"));
    }

    /**
     * The body object received with this envelope. Will be an
     * KDom Node for literal encoding. For SOAP Serialization,
     * please refer to SoapSerializationEnvelope. */

    public Object bodyIn;

    /** 
     * The body object to be sent with this envelope. Must be a KDom Node
     * modelling the remote call including all parameters
     * for literal encoding. For SOAP Serialization, please 
     * refer to SoapSerializationEnvelope  */

    public Object bodyOut;


    /** 
     * Incoming header elements */
    
    public Element [] headerIn;

    /** 
     * Outgoing header elements */

    public Element [] headerOut;
    public String encodingStyle;


    /** 
     * The SOAP version, set by the constructor */

    public int version;    

    /** Envelope namespace, set by the constructor */

    public String env;

    /** Encoding namespace, set by the constructor */

    public String enc;

    /** Xml Schema instance namespace, set by the constructor */
    
    public String xsi;   

    /** Xml Schema data namespace, set by the constructor */

    public String xsd;


    /** 
     * Initializes a SOAP Envelope. The version parameter must
     * be set to one of VER10, VER11 or VER12 */ 

    public SoapEnvelope (int version) {
                this.version = version;
        //  prefixMap = SoapEnvelope.prefixMap[version];

        if (version == SoapEnvelope.VER10) {
            xsi = SoapEnvelope.XSI1999;
            xsd = SoapEnvelope.XSD1999;
        }
        else {
            xsi = SoapEnvelope.XSI;
            xsd = SoapEnvelope.XSD;
        }

        if (version < SoapEnvelope.VER12) {
            enc = SoapEnvelope.ENC;
            env = SoapEnvelope.ENV;
        }
        else {
            enc = SoapEnvelope.ENC2001;
            env = SoapEnvelope.ENV2001;
        }

    }


    /** Parses the SOAP envelope from the given parser */


    public void parse(XmlPullParser parser)
        throws IOException, XmlPullParserException {

        parser.nextTag();
        
   /*     System.out.println ("name-r: '"+parser.getName()+"'");
        System.out.println ("name-x: 'Envelope'");
        System.out.println ("namesp-r: '"+parser.getNamespace()+"'");
        System.out.println ("namesp-x: '"+env+"'"); */
        
        parser.require(XmlPullParser.START_TAG, env, "Envelope");
        encodingStyle = parser.getAttributeValue(env, "encodingStyle");

        parser.nextTag();

        if (parser.getEventType() == XmlPullParser.START_TAG
            && parser.getNamespace().equals(env)
            && parser.getName().equals("Header")) {

            parseHeader(parser);

            parser.require(XmlPullParser.END_TAG, env, "Header");
            parser.nextTag();
        }

        parser.require(XmlPullParser.START_TAG, env, "Body");
        encodingStyle = parser.getAttributeValue(env, "encodingStyle");

        parseBody (parser);

        parser.require(XmlPullParser.END_TAG, env, "Body");

        parser.nextTag();
        parser.require(XmlPullParser.END_TAG, env, "Envelope");
    }


    public void parseHeader(XmlPullParser parser)
        throws IOException, XmlPullParserException {

        // consume start header

        parser.nextTag();

        // look at all header entries

        Node headers = new Node ();
        headers.parse (parser);
    
        int count = 0;
        for (int i = 0; i < headers.getChildCount(); i++) {
            Element child = headers.getElement(i);
            if (child != null) count++;
        }
        
        headerIn = new Element [count];
        count = 0;
        for (int i = 0; i < headers.getChildCount(); i++) {
            Element child = headers.getElement(i);
            if (child != null) 
                headerIn [count++] = child;
        }
    }

    public void parseBody(XmlPullParser parser)
        throws IOException, XmlPullParserException {

        parser.nextTag();
        // insert fault generation code here

        if (parser.getEventType() == XmlPullParser.START_TAG
            && parser.getNamespace().equals(env)
            && parser.getName().equals("Fault")) {
            SoapFault fault = new SoapFault();
            fault.parse(parser);
            bodyIn = fault;
        }
        else {
            Node node = (bodyIn instanceof Node) ? (Node) bodyIn : new Node ();
            node.parse(parser);
            bodyIn = node;
        }
    }


    /** 
     * Writes the complete envelope including header and body 
     * elements to the given XML writer. */

    public void write(XmlSerializer writer) throws IOException {

        writer.setPrefix("i", xsi);  
        writer.setPrefix("d", xsd);  
        writer.setPrefix("c", enc);      
        writer.setPrefix("v", env);      
        writer.startTag(env, "Envelope");

        //  writer.attribute (Soap.ENV, "encodingStyle", encodingStyle); 
        
        writer.startTag(env, "Header");
        writeHeader(writer);
        writer.endTag(env, "Header");

        writer.startTag(env, "Body");
        writeBody(writer);
        writer.endTag(env, "Body");


        writer.endTag(env, "Envelope");
    }

    /** 
     * Writes the header elements contained in headerOut */

    public void writeHeader(XmlSerializer writer) throws IOException {
        if (headerOut != null) {
            for (int i = 0; i < headerOut.length; i++) {
                headerOut[i].write (writer);
            }   
        }
    }

    /** 
     * Writes the SOAP body stored in the object variable bodyIn,
     * Overwrite this method for customized writing of
     * the soap message body. */

    public void writeBody(XmlSerializer writer) throws IOException {

        /*   if (body instanceof XmlIO) {
               if (encodingStyle != null)
                   writer.attribute(classMap.env, "encodingStyle", encodingStyle);
        
               ((XmlIO) body).write(writer);
           }
           else { */

		if (encodingStyle != null) 
           writer.attribute(env, "encodingStyle", encodingStyle);
        
        ((Node) bodyOut).write(writer);
        //        }
    }

}