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.SecureProtocolSocketFactory;

public class MySSLSocketFactory implements SecureProtocolSocketFactory {
static{
     System.out.println("loading SSL");
}
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[]{};
     }
}

}

Protocol myhttps = new Protocol("https", new MySSLSocketFactory (), 443);
         Protocol.registerProtocol("https", myhttps);

https需要的类