摘要：使支持協(xié)議類，是自定義私有類請(qǐng)求類根據(jù)請(qǐng)求報(bào)文，請(qǐng)求服務(wù)地址獲取響應(yīng)報(bào)文請(qǐng)求報(bào)文請(qǐng)求地址字符集類型封裝的服務(wù)器響應(yīng)參數(shù)和返回報(bào)文正常響應(yīng)。

使commons httpclient支持https協(xié)議類，是commons httpclient

import java.io.IOException;  
import java.net.InetAddress;  
import java.net.InetSocketAddress;  
import java.net.Socket;  
import java.net.SocketAddress;  
import java.net.UnknownHostException;  
import java.security.KeyManagementException;  
import java.security.NoSuchAlgorithmException;  
import java.security.cert.CertificateException;  
import java.security.cert.X509Certificate;  
import javax.net.SocketFactory;  
import javax.net.ssl.SSLContext;  
import javax.net.ssl.TrustManager;  
import javax.net.ssl.X509TrustManager;  
import org.apache.commons.httpclient.ConnectTimeoutException;  
import org.apache.commons.httpclient.params.HttpConnectionParams;  
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;  

/** 
 * httpclient https 
 * 
 */  
public class HTTPSSecureProtocolSocketFactory implements ProtocolSocketFactory {//SecureProtocolSocketFactory  
    private SSLContext sslcontext = null;
     
    private SSLContext createSSLContext()
    {
        SSLContext sslcontext = null;
        try
        {
            sslcontext = SSLContext.getInstance("SSL");
            sslcontext.init(null, new TrustManager[]
            { new TrustAnyTrustManager() }, new java.security.SecureRandom());
        }
        catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }
        catch (KeyManagementException e)
        {
            e.printStackTrace();
        }
        return sslcontext;
    }

    private SSLContext getSSLContext()
    {
        if (this.sslcontext == null)
        {
            this.sslcontext = createSSLContext();
        }
        return this.sslcontext;
    }

    public Socket createSocket(Socket socket, String host, int port,
            boolean autoClose) throws IOException, UnknownHostException
    {
        return getSSLContext().getSocketFactory().createSocket(socket, host,
                port, autoClose);
    }

    public Socket createSocket(String host, int port) throws IOException,
            UnknownHostException
    {
        return getSSLContext().getSocketFactory().createSocket(host, port);
    }

    public Socket createSocket(String host, int port, InetAddress clientHost,
            int clientPort) throws IOException, UnknownHostException
    {
        return getSSLContext().getSocketFactory().createSocket(host, port,
                clientHost, clientPort);
    }

    public Socket createSocket(String host, int port, InetAddress localAddress,
            int localPort, HttpConnectionParams params) throws IOException,
            UnknownHostException, ConnectTimeoutException
    {
        if (params == null)
        {
            throw new IllegalArgumentException("Parameters may not be null");
        }
        int timeout = params.getConnectionTimeout();
        SocketFactory socketfactory = getSSLContext().getSocketFactory();
        if (timeout == 0)
        {
            return socketfactory.createSocket(host, port, localAddress,
                    localPort);
        }
        else
        {
            Socket socket = socketfactory.createSocket();
            SocketAddress localaddr = new InetSocketAddress(localAddress,
                    localPort);
            SocketAddress remoteaddr = new InetSocketAddress(host, port);
            socket.bind(localaddr);
            socket.connect(remoteaddr, timeout);
            return socket;
        }
    }

    // 自定義私有類
    private static class TrustAnyTrustManager implements X509TrustManager
    {

        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException
        {
        }

        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException
        {
        }

        public X509Certificate[] getAcceptedIssuers()
        {
            return new X509Certificate[]
            {};
        }
    }
   
}

httpclient請(qǐng)求類

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.httpclient.protocol.Protocol;


public class SoapUtil {

    /**  
        * 
Description: 根據(jù)請(qǐng)求報(bào)文，請(qǐng)求服務(wù)地址獲取 響應(yīng)報(bào)文  
         * @param requestSoap  請(qǐng)求報(bào)文  
         * @param serviceAddress 請(qǐng)求地址  
         * @param charSet 字符集  utf-8
         * @param contentType  類型  text/xml; charset=utf-8
         * @return  map封裝的 服務(wù)器響應(yīng)參數(shù)和返回報(bào)文.PS:statusCode :200正常響應(yīng)。responseSoap：響應(yīng)報(bào)文   
         * 
thinking: 
  
         *  
         * @author  
         */
      public  static Map responseSoap(String requestSoap,String serviceAddress,String charSet, String contentType){  
          String responseSoap="";  
          Map resultmap=new HashMap();  
          PostMethod postMethod = new PostMethod(serviceAddress);  
          HttpClient httpClient = new HttpClient();  
          Protocol myhttps = new Protocol("https", new HTTPSSecureProtocolSocketFactory(), 443);//支持https
          Protocol.registerProtocol("https", myhttps);
          int statusCode = 0;  
          try {  
              httpClient.getState().setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("USERNAME", "PASSWORD"));//設(shè)置用戶名密碼,如果不需要就忽略這一行
              StringRequestEntity entity = new StringRequestEntity(requestSoap,contentType,charSet);
              postMethod.setRequestEntity(entity);  
              statusCode = httpClient.executeMethod(postMethod);  
              resultmap.put("statusCode", statusCode);  
          } catch (IOException e) {  
              throw new RuntimeException("執(zhí)行http請(qǐng)求失敗", e);  
          }  
          if (statusCode == 200) {  
              try {  
                responseSoap = postMethod.getResponseBodyAsString();  
                resultmap.put("responseSoap", responseSoap);  
              } catch (IOException e) {  
                  throw new RuntimeException("獲取請(qǐng)求返回報(bào)文失敗", e);  
              }  
          } else {  
              throw new RuntimeException("請(qǐng)求失?。? + statusCode);  
          }  
          return resultmap;  
      }  
      
}

xml工具類

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.xml.sax.InputSource;

public class XmlUtil {

    
    
    
     /** 
     * 
Description:將字符串類型的XML 轉(zhuǎn)化成Docunent文檔結(jié)構(gòu)
 
     * @param parseStrXml 待轉(zhuǎn)換的xml 字符串 
     * @return Document  
     * 
     * @author  
     * @throws JDOMException 
     * @throws IOException 
     */  
    public static Document strXmlToDocument(String parseStrXml) throws JDOMException, IOException{  
        StringReader read = new StringReader(parseStrXml);    
        //創(chuàng)建新的輸入源SAX 解析器將使用 InputSource 對(duì)象來確定如何讀取 XML 輸入    
        InputSource source = new InputSource(read);    
        //創(chuàng)建一個(gè)新的SAXBuilder    
        SAXBuilder sb = new SAXBuilder();   // 新建立構(gòu)造器    
        Document doc = null;  
        try {  
            doc = sb.build(source);  
        } catch (JDOMException e) {
            throw e;
        } catch (IOException e) {  
            throw e; 
        }   
        return doc;  
          
    }  

    /** 
     * 
Description: 根據(jù)目標(biāo)節(jié)點(diǎn)名獲取值
 
     * @param doc 文檔結(jié)構(gòu) 
     * @param finalNodeName  最終節(jié)點(diǎn)名 
     * @return 
     * 
     * @author  
     */  
    public static String getValueByElementName(Document doc,String finalNodeName){  
       Element root = doc.getRootElement();  
        HashMap map=new HashMap();  
       //調(diào)用getChildAllText方法。獲取目標(biāo)子節(jié)點(diǎn)的值 
       getChildAllText(doc, root,map);     
       String result=(String)map.get(finalNodeName);  
       return result;  
    }  
    
    /** 
     * 
Description: 遞歸獲得子節(jié)點(diǎn)的值
 
     * @param doc 文檔結(jié)構(gòu) 
     * @param e  節(jié)點(diǎn)元素 
     * @param resultmap  遞歸將值壓入map中 
     * @return   
     * 
     * @author  
     */  
    public static Map getChildAllText(Document doc, Element e,Map resultmap) {

        if (e != null) {
            if (e.getChildren() != null) // 如果存在子節(jié)點(diǎn)
            {
                List list = e.getChildren();
                for (Element el : list) // 循環(huán)輸出
                {
                    if (el.getChildren().size() > 0) // 如果子節(jié)點(diǎn)還存在子節(jié)點(diǎn)，則遞歸獲取
                    {
                        getChildAllText(doc, el, resultmap);
                    } else {
                        resultmap.put(el.getName(), el.getTextTrim()); // 將葉子節(jié)點(diǎn)值壓入map
                    }
                }
            }
        }
        return resultmap;
    }
    
    /**
     * 獲取某個(gè)節(jié)點(diǎn)下的所有子節(jié)點(diǎn)
     * @param doc
     * @param element
     * @return
     */
    public static List getChildToList(Document doc,String element){
        Element root = doc.getRootElement();
        Element e = root.getChild(element);
        if(e != null){ //判斷要查找的節(jié)點(diǎn)是否存在根節(jié)點(diǎn)，
            return e.getChildren();//存在：返回節(jié)點(diǎn)下的所有子節(jié)點(diǎn)
        }else{
            return getChildToList(root, element);//不存在：進(jìn)入遞歸查詢
        }
    }
    /**
     * 遞歸查找節(jié)點(diǎn)
     * @param root
     * @param element
     * @return
     */
    private static List getChildToList(Element root,String element){
        List list = new ArrayList<>();
        List rootElements = root.getChildren();
        for (Element element2 : rootElements) {
            if(element2.getChild(element)!=null){
                return element2.getChild(element).getChildren();
            }else{
                list = getChildToList(element2, element);
                if(list.size() != 0)
                    return list;
            }
        }
        return new ArrayList<>();
    }
}