HttpClient 访问SSL WebService 方式

在使用HttpClient 访问WebService 时

                HttpClient 4.3 代码中有自己的SSL实现，但是其对WebService的格式要求较高，

在测试使用myEclipse创建的jax-ws WebService有问题，原因没找到，返回报文为

HTTP/1.1 200 OK
Response content length: -1
Request:POST http://localhost:8080/w_taxremovalservice/SystemStatusPort?wsdl HTTP/1.1
HTTP/1.1 500 Internal Server Error

使用http 测试时报，原因也没找到

 Request:POST http://10.50.50.51:8080/w_taxremovalservice/SystemStatusPort?wsdl HTTP/1.1
HTTP/1.1 500 Internal Server Error
Response content length: 1000

后找到了HttpClient 3.1 jar包，3.1没有自实现的SSL认证，网上找了实现代码如下，访问myEclipse创建的jax-ws WebService没问题

3.1 SSL实现如下：

EasySSLProtocolSocketFactory

package com.hoperun.ssl;

import java.io.FileInputStream;
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.KeyStore;

import javax.net.SocketFactory;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;

import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.HttpClientError;
import org.apache.commons.httpclient.params.HttpConnectionParams;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;

public class EasySSLProtocolSocketFactory implements ProtocolSocketFactory {

    private SSLContext sslcontext = null;

    private String     ksfile;
    private String     tksfile;
    private String     kspwd;
    private String     tkspwd;

    public EasySSLProtocolSocketFactory(String ks, String kspwd, String tks, String tkspwd){
        this.ksfile = ks;
        this.kspwd = kspwd;
        this.tksfile = tks;
        this.tkspwd = tkspwd;
    }

    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(final String host, final int port, final InetAddress localAddress, final int localPort,
                               final 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;
        }
    }

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

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

    private SSLContext createEasySSLContext() {
        try {
            SSLContext context = SSLContext.getInstance("SSL");

            KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");

            KeyStore ks = KeyStore.getInstance("JKS");
            KeyStore tks = KeyStore.getInstance("JKS");

            ks.load(new FileInputStream(ksfile), kspwd.toCharArray());
            tks.load(new FileInputStream(tksfile), tkspwd.toCharArray());

            kmf.init(ks, kspwd.toCharArray());
            tmf.init(tks);

            context.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            return context;
        } catch (Exception e) {
            throw new HttpClientError(e.toString());
        }
    }

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

}

AliSSLContext

package com.hoperun.ssl;


public class AliSSLContext {

    private static final String                 KS_PWD   = "changeit";
    private static final String                 TKS_PWD  = "changeit";
    private static final String                 KS_FILE  = "d:\\keys\\client.keystore";
    private static final String                 TKS_FILE = "d:\\keys\\trust.keystore";

    private static EasySSLProtocolSocketFactory easySSLProtocolSocketFactory;

    public static EasySSLProtocolSocketFactory getEasySSLProtocolSocketFactory() {
        if (easySSLProtocolSocketFactory == null) {
            easySSLProtocolSocketFactory = new EasySSLProtocolSocketFactory(KS_FILE, KS_PWD, TKS_FILE, TKS_PWD);
        }
        return easySSLProtocolSocketFactory;
    }

}

AliHttpsAccessor

package com.hoperun.ssl;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;

import net.sf.json.xml.XMLSerializer;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
import org.apache.commons.httpclient.protocol.Protocol;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

public class AliHttpsAccessor {

    private HttpClient httpClient;

    public AliHttpsAccessor(){
        Protocol.registerProtocol("https", new Protocol("https", AliSSLContext.getEasySSLProtocolSocketFactory(), 8443));
        httpClient = new HttpClient(new MultiThreadedHttpConnectionManager());
    }
    public HttpClient getHttpClient(){
    	return httpClient;
    }
    public String request(String url) {
        GetMethod req = new GetMethod(url);
        String ret = "";
        try {
            httpClient.executeMethod(req);
            ret = req.getResponseBodyAsString();
            req.releaseConnection();
        } catch (Exception e) {
            System.out.println(e);
        }
        return ret;
    }
}

测试代码如下：

	public static void SoapServer(HttpClient httpClient,String url) {
		String soapRequestData = "<xml>test</xml>";
		PostMethod postMethod = new PostMethod(
				url+"/service/SystemStatusPort?wsdl");
		try {
			byte[] b = soapRequestData.getBytes("utf-8");
			InputStream is = new ByteArrayInputStream(b, 0, b.length);
			RequestEntity re = new InputStreamRequestEntity(is, b.length,
					"text/xml; charset=utf-8");
			postMethod.setRequestEntity(re);
			httpClient.executeMethod(postMethod);
			String soapResponseData = postMethod.getResponseBodyAsString();
						
		} catch (UnsupportedEncodingException e) {
			System.out.println(e.getMessage());
		} catch (DocumentException e) {
			System.out.println(e.getMessage());
		} catch (HttpException e) {
			System.out.println(e.getMessage());
		} catch (IOException e) {
			System.out.println(e.getMessage());
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}

所用Jar包可到我的资源区下载