利用HttpURLConnection实现SOAP调用

我们完全可以利用J2SE中的HttpURLConnection类来实现SOAP调用，而不一定需要AXIS之类的第三方组件包。下面就来仔细讲解：
        通过HttpURLConnection来实现SOAP调用，无非就是向远端的WEB Service发出HTTP请求，请求的过程通过双方可以理解的XML格式流来传递数据信息。我以下面的SOAP请求的XML格式为基础来讲解：
<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:SmInf="http://jx.ct10000.com/SmInf">
 <soapenv:Header />
 <soapenv:Body>
  <tns:SendInstantSms xmlns:tns="SmInf" soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
   <sequenceId type="xsd:long">1</sequenceId>
   <accountCode type="xsd:string">user_id</accountCode>
   <accountPasswd type="xsd:string">user_password</accountPasswd>
   <sendPhoneNo type="xsd:string">1234567890</sendPhoneNo>
   <msgContent type="xsd:string">7D27 6025 901A 77E5 FF1A 7279 522B 7D27 6025 FF0C 5341 4E07 706B 6025 002E</msgContent>
   <recvPhoneNo type="xsd:string">1234567890</recvPhoneNo>
   <scheduleTime type="xsd:dateTime">2000-10-10T09:35:12.123</scheduleTime>
  </tns:SendInstantSms>
 </soapenv:Body>
</soapenv:Envelope>
        这个SOAP请求包格式并不能完全通用于任何场合，大家具体实现某个SOAP调用时，需要根据具体情况进行调整，可以通过Web Service服务提供商获取详情。
        通过HttpURLConnection实现SOAP调用的过程简要概述如下：
        1、拼接实现如上所示的SOAP请求包的XML格式的字符流；
        2、上面讲到过SOAP调用就是一个HTTP请求，因此通过HttpURLConnection类设置相应的请求属性；
        3、通过HttpURLConnection类的getOutputStream方法获得一个输出流，然后将SOAP请求包字符流写入此输出流；
        4、通过HttpURLConnection类的getResponseCode方法获得服务器响应代码，如果响应代码为200（即HttpURLConnection.HTTP_OK）则表示请求成功，否则请求失败，请求失败后，可以通过getErrorStream方法来了解具体的错误详情；
        5、通过HttpURLConnection类的getInputStream方法获得一个输入流，由此输入流获得服务器反馈结果数据；
        大体通过HttpURLConnection实现SOAP调用的过程就是这样。下面来看具体实现代码：
        编写CSOAPClient类，并定义成员变量_url和_httpConn，在构造函数中对其进行实例化。
       _url=new URL(url);          //这里url变量是SOAP服务的网址，如http://10.5.3.134/Webservices/methods1?wsdl
       _httpConn = (HttpURLConnection) _url.openConnection();   //这里就是获得一个SOAP服务的HttpURLConnection实例
       String send_soap=createSendSOAPPackage();    //createSendSOAPPackage函数就是用来构造如上所示SOAP请求的数据包的XML字符串
       _httpConn.setReadTimeout(TIME_OUT);        //为HttpURLConnection对象指定一个读超时
       _httpConn.setRequestProperty("User-Agent","Mozilla/4.0 (compatible; MSIE 5.0; Windows XP; DigExt)");
       _httpConn.setRequestProperty( "Content-Length",String.valueOf( send_soap.length() ) );
       _httpConn.setRequestProperty("Content-Type","text/xml; charset=UTF-8");
       _httpConn.setRequestProperty("SOAPAction",_soap_action_str);
       //以上都是为HTTP请求设定请求属性，其中SOAPAction中用来指定SOAP Action的字符串。
       _httpConn.setRequestMethod( "POST" );   //为请求指定提交数据模式，对于调用Web Service来说请求模式要被设置成POST模式。
       _httpConn.setDoInput(true);
        _httpConn.setDoOutput(true);
        _httpConn.setUseCaches(false);
       _httpConn.connect();  //连接远程Url

       OutputStream out = _httpConn.getOutputStream();   //获取输出流对象
        out.write( send_soap.getBytes() );       //将要提交服务器的SOAP请求字符流写入输出流
        out.flush();
        out.close();

       int code=0;
        code = _httpConn.getResponseCode();    //用来获取服务器响应状态
       if (code == HttpURLConnection.HTTP_OK) {
            //服务器响应状态表示成功，这此处可以来获取服务器反馈的数据信息
            InputStream is=_httpConn.getInputStream();    //获取输入流对象，通过此对象可以获取服务器传回的数据信息
            InputStreamReader isr = new InputStreamReader(is,"utf-8");
            Document _doc=_sax.build(isr);     //此处Document是jdom中的类，因为要解析服务器传回的xml数据
            Element _root = _doc.getRootElement();  //此处Element是jdom中的类
            ......（略）
           
       }
       else{
            //如果服务器返回的HTTP状态不是HTTP_OK，则表示发生了错误，此时可以通过如下方法了解错误原因。
            InputStream is=_httpConn.getErrorStream();    //通过getErrorStream了解错误的详情，因为错误详情也以XML格式返回，因此也可以用JDOM来获取。
            InputStreamReader isr = new InputStreamReader(is,"utf-8");
            Document _doc=_sax.build(isr);     //此处Document是jdom中的类，因为要解析服务器传回的xml数据
            Element _root = _doc.getRootElement();  //此处Element是jdom中的类
            ......（略）
       }
       以上就是通过HttpURLConnection调用SOAP的简介。
      下面附上实现类的代码，供参考（未优化，大家使用时要优化一下）
1、CSOAPClient
 
package util;

import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Set;
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.Namespace;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

/**
 *
 * @author zhaob
 */
public class CSOAPClient {
    private static int TIME_OUT=15000;
    
    private URL _url = null;
    private String _service_id=null;
    private String _method=null;
    private String _soap_action_str=null;
    private LinkedList<NParam> _params = new LinkedList<NParam>();
    private HttpURLConnection _httpConn=null;

    private String _root_master_namespace_name=null;
    private Hashtable<String,String> _root_namespace=new Hashtable<String,String>();
    private boolean _setted_root_master_namespace_flag=false;

    private boolean _hasHead=true;
    private boolean _hasParamType=true;

    private Hashtable<String,String> _method_attrib=new Hashtable<String,String>();
    private Hashtable<String,String> _method_attrib_namespace=new Hashtable<String,String>();
    private Hashtable<String,String> _methodattrib_namespace=new Hashtable<String,String>();
    private Hashtable<String,String> _methods_namespace=new Hashtable<String,String>();

    public CSOAPClient(String url,String service_id,String method,String soap_action) throws Exception {
        _url=new URL(url);          //SOAP服务的网址
        if((service_id==null)||(service_id.trim().equals(""))){
            _service_id=null;
        }
        else{
            _service_id=service_id;
        }
        
        _method=method;
        _soap_action_str=soap_action;
        createSocket();
        
    }

    public void setHasParamType(boolean v){
        _hasParamType=v;
    }

    public void setHasHead(boolean v){
        _hasHead=v;
    }

    protected void createSocket() throws Exception {
        if(_httpConn==null){
//            Properties systemProperties = System.getProperties();
//            systemProperties.setProperty("http.proxyHost","192.168.1.1");
//            systemProperties.setProperty("http.proxyPort","8080");
            _httpConn = (HttpURLConnection) _url.openConnection();;
            
        }
    }

    public void addParams(String params_name,Object v,EParamType type){
        NParam np=new NParam(params_name,v,type);
        _params.add(np);
    }

    public void addMethodNamespace(String namespace_name,String namespace_v){
        _methods_namespace.put(namespace_name,namespace_v);
    }

    public void addMethodAttrib(String attrib_name,String v,String namespace_name,String namespace_v){
        _method_attrib.put(attrib_name, v);
        _method_attrib_namespace.put(attrib_name, namespace_name);
        _methodattrib_namespace.put(namespace_name,namespace_v);
    }

    public void addMethodAttrib(String attrib_name,String v){
        _method_attrib.put(attrib_name, v);
    }

    public void setRootMasterNamespace(){
        if(!_setted_root_master_namespace_flag){
            _root_master_namespace_name="soapenv";
            _root_namespace.put(_root_master_namespace_name, "http://schemas.xmlsoap.org/soap/envelope/");
            _setted_root_master_namespace_flag=true;
        }
    }

    public void setRootMasterNamespace(String name){
        if(!_setted_root_master_namespace_flag){
            _root_master_namespace_name=name;
            _root_namespace.put(_root_master_namespace_name, "http://schemas.xmlsoap.org/soap/envelope/");
            _setted_root_master_namespace_flag=true;
        }
    }

    public void addRootNamespace(String name,String v){
        _root_namespace.put(name, v);
    }

    public String createSendSOAPPackage(){
        Hashtable<String,Namespace> namespace_set=new Hashtable<String,Namespace>();
        // 创建根节点 root;
        Element root = new Element("Envelope");
        Set<String> sets=_root_namespace.keySet();
        Namespace master_namespace=null;
        for(String s:sets){
            String v=_root_namespace.get(s);
            Namespace sn=Namespace.getNamespace(s, v);
            namespace_set.put(s, sn);
            if(s.equals(_root_master_namespace_name)){
                root.setNamespace(sn);
                master_namespace=sn;
            }
            else{
                root.addNamespaceDeclaration(sn);
            }
            
        }
        
        // 根节点添加到文档中；
        Document doc = new Document(root);

        if(_hasHead){
            //创建Header节点
            Element head=new Element("Header");
            head.setNamespace(master_namespace);
            //加入根节点
            root.addContent(head);
        }
        
        //创建Body节点
        Element body=new Element("Body");
        body.setNamespace(master_namespace);
        //加入根节点
        root.addContent(body);

        //创建调用的方法节点
        Element method=new Element(_method);
        body.addContent(method);
        Set<String> method_attrib_set=_method_attrib.keySet();
        boolean flag=false;
        Namespace ns=null;
                
        for(String attrib_name:method_attrib_set){
            String attrib_v=_method_attrib.get(attrib_name);
            flag=_method_attrib_namespace.containsKey(attrib_name);
            if(flag){
                String namespace_name=_method_attrib_namespace.get(attrib_name);
                flag=namespace_set.containsKey(namespace_name);
                if(flag){
                    ns=namespace_set.get(namespace_name);
                    
                }
                else{
                    String namespace_v=_methodattrib_namespace.get(namespace_name);
                    ns=Namespace.getNamespace(namespace_name, namespace_v);
                    method.setNamespace(ns);
                    namespace_set.put(namespace_name, ns);
                }
                Attribute attrib=new Attribute(attrib_name, attrib_v,ns);
                method.setAttribute(attrib);
            }
            else{
                Attribute attrib=new Attribute(attrib_name, attrib_v);
                method.setAttribute(attrib);
            }
        }
        Set<String> methods_attrib=_methods_namespace.keySet();
        for(String namespace_name:methods_attrib){
            flag=namespace_set.containsKey(namespace_name);
            if(flag){
                
            }
            else{
                String namespace_v=_methods_namespace.get(namespace_name);
                ns=Namespace.getNamespace(namespace_name, namespace_v);
                method.setNamespace(ns);
                namespace_set.put(namespace_name, ns);
            }
        }
        if(_service_id!=null){
            Namespace nsl=Namespace.getNamespace("tns", _service_id);
            method.setNamespace(nsl);
        }
        
        //创建调用方法的参数节点
        int count=_params.size();
        for(int i=0;i<count;i++){
            NParam np=_params.get(i);
            String param_name=np.getName();
            String param_value=np.getValue().toString();
            String param_type=np.getType().getValue();

            Element param=new Element(param_name);
            method.addContent(param);
            param.setText(param_value);
            if(_hasParamType){
                Attribute param_attrib=new Attribute("type", param_type);
                param.setAttribute(param_attrib);
            }
            
            
        }

        //定义输出
        XMLOutputter XMLOut = new XMLOutputter();
        //设置格式
        Format format = Format.getPrettyFormat();
        format.setEncoding("UTF-8"); //设置 xml文件的字符为UTF-8
        format.setIndent(" "); //设置xml文件的缩进为4个空格
        XMLOut.setFormat(format);

        return XMLOut.outputString(doc);
    }

    public CXML call() throws Exception {
        String send_soap=createSendSOAPPackage();
        System.out.println("Request XML:");
        System.out.println(send_soap);

        _httpConn.setReadTimeout(TIME_OUT);
        _httpConn.setRequestProperty("User-Agent","Mozilla/4.0 (compatible; MSIE 5.0; Windows XP; DigExt)");
        _httpConn.setRequestProperty( "Content-Length",String.valueOf( send_soap.length() ) );
        System.out.println("Content-Length:"+String.valueOf( send_soap.length() ));
        _httpConn.setRequestProperty("Content-Type","text/xml; charset=UTF-8");
        System.out.println("Content-Type:text/xml; charset=UTF-8");
//        _httpConn.setRequestProperty("soapActionString",_soap_action_str);
        _httpConn.setRequestProperty("SOAPAction",_soap_action_str);
        System.out.println("SOAPAction:"+_soap_action_str);
        _httpConn.setRequestMethod( "POST" );
        System.out.println("Request Method:POST");
        _httpConn.setDoInput(true);
        _httpConn.setDoOutput(true);
        _httpConn.setUseCaches(false);
        
        _httpConn.connect();
        
        OutputStream out = _httpConn.getOutputStream();
        out.write( send_soap.getBytes() );
        out.flush();
        out.close();

        int code=0;
        code = _httpConn.getResponseCode();
        CXML xmlobj=null;
        if (code == HttpURLConnection.HTTP_OK) {
            xmlobj=new CXML(_httpConn.getInputStream(),_root_master_namespace_name,_root_namespace.get(_root_master_namespace_name));
            
        }
        else{
            System.out.println("Response Code: "+String.valueOf(code));

            xmlobj=new CXML(_httpConn.getErrorStream(),_root_master_namespace_name,_root_namespace.get(_root_master_namespace_name));
            
            System.out.println("错误详情: ");
            String faultcode=xmlobj.getElementTextByXPath("/soapenv:Envelope/soapenv:Body/soapenv:Fault/faultcode");
            System.out.println("错误代码: "+faultcode);
            String faultstring=xmlobj.getElementTextByXPath("/soapenv:Envelope/soapenv:Body/soapenv:Fault/faultstring");
            System.out.println("错误描述: "+faultstring);
            
        }
        
        return xmlobj;
    }

    public void destroy(){
        if(_httpConn!=null){
           _httpConn=null;

        }
    }

    public String toUTF8(String str) {
         if ("".equals(str)) {
             return "";
         }

         StringBuffer strBuff = new StringBuffer("");
         try {
             byte b[] = str.getBytes("UTF-16");
             for (int n = 0; n < b.length; n++) {
                 str = (Integer.toHexString(b[n] & 0XFF));
                 if (str.length() == 1) {
                     strBuff.append("0").append(str);
                 } else {
                     strBuff.append(str);
                 }
             }

             // 去除第一个标记字符
             str = strBuff.toString().toUpperCase().substring(4);
             // System.out.println(str);
             char[] chs = str.toCharArray();
             strBuff.delete(0, strBuff.length());
             for (int i = 0; i < chs.length; i = i + 4) {
                 strBuff.append(chs[i])
                        .append(chs[i + 1])
                        .append(chs[i + 2])
                        .append(chs[i + 3])
                        .append(" ");
             }
         } catch (Exception e) {
             System.out.print(e.getStackTrace());
             e.getStackTrace();
         }

         return strBuff.toString();
     }

    public final class NParam {
        private String _name=null;
        private Object _value=null;
        private EParamType _type=null;

        public NParam(String name,Object value,EParamType type){
            _name=name;
            _value=value;
            _type=type;
        }

        public String getName() {
            return _name;
        }

        public EParamType getType() {
            return _type;
        }

        public Object getValue() {
            return _value;
        }
        
    }

    public enum EParamType{
        String("xsd:string"),Integer("xsd:integer"),Long("xsd:long"),Datetime("xsd:dateTime");
        private final String _v;
        private EParamType(String v) {
            this._v = v;
        }
        public String getValue() {
            return _v;
        }
    }
}

2、CXML
 
package util;

import java.io.InputStream;
import java.io.InputStreamReader;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.Namespace;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import org.jdom.xpath.XPath;

/**
 *
 * @author zhaob
 */
public class CXML {

    private SAXBuilder _sax=new SAXBuilder();
    private Document _doc=null;
    private Element _root = null;
    private Namespace _master_namespace=null;

    public CXML(InputStream is,String namespace_name,String namespace_v) throws Exception {
        InputStreamReader isr = new InputStreamReader(is,"utf-8");
        _doc=_sax.build(isr);
        _root = _doc.getRootElement();
        _master_namespace=Namespace.getNamespace(namespace_name, namespace_v);

    }

    public String getElementTextByXPath(String xpath) throws Exception {
        String rtn=null;

        XPath xpathobj=XPath.newInstance(xpath);
        xpathobj.addNamespace(_master_namespace);
        Element obj=(Element)xpathobj.selectSingleNode(_doc);
        rtn=obj.getTextTrim();

        return rtn;
    }

    public String toString(){
        XMLOutputter o=new XMLOutputter();
        //设置格式
        Format format = Format.getPrettyFormat();
        format.setEncoding("UTF-8"); //设置 xml文件的字符为UTF-8
        format.setIndent(" "); //设置xml文件的缩进为4个空格
        o.setFormat(format);
        String xmlstr=o.outputString(_doc);
        
        return xmlstr;
    }
}

3、CSOAPClinetTest   这是一个JUNIT的测试类，看其中RUN方法即可。
 
package util;

import java.util.List;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import util.CSOAPClient.EParamType;

/**
 *
 * @author zhaob
 */
public class CSOAPClinetTest {

    public CSOAPClinetTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    // TODO add test methods here.
    // The methods must be annotated with annotation @Test. For example:
    //
    // @Test
    // public void hello() {}

    @Test
    public void run(){
        CSOAPClient soap_client=null;

        try{
            soap_client=new CSOAPClient("http://10.20.4.21:8080/Webservices/SmsInf","SmInf","SendInstantSms","http://w.rr.com/SmsInf/SendInstantSms");
        }
        catch(Exception e){
            System.out.println("Error:"+e.getMessage());
        }
        if(soap_client!=null){
            soap_client.setHasHead(true);
            soap_client.setRootMasterNamespace("soapenv");
            soap_client.addRootNamespace("SmInf", "http://x.rr.com/SmInf");
            soap_client.addMethodAttrib("encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/","soapenv","");
            soap_client.setHasParamType(true);

            soap_client.addParams("sequenceId", 2, EParamType.Long);
            soap_client.addParams("accountCode", "user_id", EParamType.String);
            soap_client.addParams("accountPasswd", "user_password", EParamType.String);
            soap_client.addParams("sendPhoneNo", "1234567890", EParamType.String);
            soap_client.addParams("msgContent", soap_client.toUTF8("紧急通知：特别紧急，十万火急."), EParamType.String);
            soap_client.addParams("recvPhoneNo", "07919999999", EParamType.String);
            soap_client.addParams("scheduleTime", "2000-10-10T09:35:12.123", EParamType.Datetime);

            try{
                CXML xmlobj=soap_client.call();
                System.out.println("返回的XML:");
                System.out.println(xmlobj.toString());
            }
            catch(Exception e){
                System.out.println("Error:"+e.getMessage());
            }

        }
    }
}
4、注意：运行此代码需要加入JDOM的全部lib目录下的包，否则使用XPATH时将报告错误。
如果还有什么疑问，可直接联系我。