java导入163联系人

现在在许多SNS中都有导入邮箱联系人的功能，以下的代码功能就是如何取得163邮箱账号的联系人
更多的导入联系人代码，可在此处下载：http://code.google.com/p/jcontactfetcher/

首先是工具类 
1.CommonUtil类，现在只有初始化log4j方法

 package org.gc.contact.util;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Properties;
 import org.apache.log4j.PropertyConfigurator;
 public final class CommonUtil {

     static {
         initLog4J();
     }

     private CommonUtil() {}

     private static void initLog4J() {
          InputStream in = CommonUtil.class.getResourceAsStream("/log4j.properties");
          Properties props = new Properties();
             try {
                 props.load(in);
                 PropertyConfigurator.configure(props);
             } catch(IOException ex) {
                 System.out.println("Log4JLogger Create Exception:/n" + ex.getMessage());
             }
     }

 }

2.EncodingUtil类，编码相关

 package org.gc.contact.util;
 public class EncodingUtil {

     public static final String DEFAULT_ENCODING = "UTF-8";

     private EncodingUtil() {}

 }

3.RegexpUtil类，正则表达式工具

 package org.gc.contact.util;
 import java.util.regex.Pattern;
 public final class RegexpUtil {

     private static final String REGEXP_FORM_INPUT_VALUE = "?([^//s/"]*)/"?";
     private static final String REGEXP_HOST_FROM_URI = "http://([^/]+)/.*";
     private static final String REGEXP_JS_REDIRECTION = "location//.replace//(/"(.+)/"//)";

     private static final Pattern PATTERN_FORM_INPUT_VALUE = Pattern.compile(REGEXP_FORM_INPUT_VALUE);
     private static final Pattern PATTERN_HOST_FROM_URI = Pattern.compile(REGEXP_HOST_FROM_URI);
     private static final Pattern PATTERN_JS_REDIRECTION = Pattern.compile(REGEXP_JS_REDIRECTION);


     private RegexpUtil() {}

     public static Pattern getFormInputValueRegexp() {
         return PATTERN_FORM_INPUT_VALUE;
     }

     public static Pattern getHostFromURIRegexp() {
         return PATTERN_HOST_FROM_URI;
     }

     public static Pattern getJSRedirectionRegexp() {
         return PATTERN_JS_REDIRECTION;
     }
 }

接着是实体类 
4.联系人类

 package org.gc.contact.model;
 import java.io.Serializable;
 public class ContactInfo implements Serializable {
     private static final long serialVersionUID = 5530203198421462152L;
     private final String username;
     private final String address; //email & qq etc.

     public ContactInfo(String username, String address) {
         this.username = username;
         this.address = address;
     }

     public String getUsername() {
         return username;
     }

     public String getAddress() {
         return address;
     }

     public String toString() {
         return "[" + username + "," + address + "]";
     }

 }

异常类 
5.错误消息

 package org.gc.contact.exception;
 public final class ExceptionMessage {

     public static final String PROTOCOL_MSG = "Don't find a match; may be the regular expression error, may be the protocol changed.";

     private ExceptionMessage() {}

 }

6.HttpBrowserException，浏览器异常

 package org.gc.contact.exception;
 @SuppressWarnings("serial")
 public class HttpBrowserException extends Exception {

     public HttpBrowserException() {
         super();
     }

     public HttpBrowserException(String error) {
         super(error);
     }

     public HttpBrowserException(Throwable t) {
         super(t);
     }

     public HttpBrowserException(String error, Throwable t) {
         super(error, t);
     }

 }

7.HttpServerException，服务器异常

 package org.gc.contact.exception;
 @SuppressWarnings("serial")
 public class HttpServerException extends Exception {

     public HttpServerException() {
         super();
     }

     public HttpServerException(String error) {
         super(error);
     }

     public HttpServerException(Throwable t) {
         super(t);
     }

     public HttpServerException(String error, Throwable t) {
         super(error, t);
     }

 }

8.ProtocolException，协议异常

 package org.gc.contact.exception;
 @SuppressWarnings("serial")
 public class ProtocolException extends Exception {

     public ProtocolException() {
         super();
     }

     public ProtocolException(Throwable t) {
         super(t);
     }

     public ProtocolException(String error) {
         super(error);
     }

     public ProtocolException(String error, Throwable t) {
         super(error, t);
     }

 }

核心类 
9.HttpBrowser类，模拟浏览器的类，有get,post行为

 package org.gc.contact.http;
 import java.io.IOException;
 import java.util.Date;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.apache.commons.httpclient.Cookie;
 import org.apache.commons.httpclient.Header;
 import org.apache.commons.httpclient.HttpClient;
 import org.apache.commons.httpclient.HttpException;
 import org.apache.commons.httpclient.HttpMethod;
 import org.apache.commons.httpclient.HttpStatus;
 import org.apache.commons.httpclient.NameValuePair;
 import org.apache.commons.httpclient.URIException;
 import org.apache.commons.httpclient.cookie.CookiePolicy;
 import org.apache.commons.httpclient.methods.GetMethod;
 import org.apache.commons.httpclient.methods.PostMethod;
 import org.apache.commons.httpclient.params.HttpMethodParams;
 import org.apache.commons.httpclient.protocol.Protocol;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.gc.contact.exception.ExceptionMessage;
 import org.gc.contact.exception.HttpBrowserException;
 import org.gc.contact.exception.HttpServerException;
 import org.gc.contact.util.EncodingUtil;
 import org.gc.contact.util.RegexpUtil;
 @SuppressWarnings("deprecation")
 public class HttpBrowser {

     static {
         SSLUtilities.trustAllHttpsCertificates();
         SSLUtilities.trustAllHostnames();
         Protocol myhttps = new Protocol("https", new SSLFactory (), 443);
         Protocol.registerProtocol("https", myhttps);
     }

     private static final Log logger = LogFactory.getLog(HttpBrowser.class);

     private HttpClient httpClient;
     protected String encoding;
     protected int bufferLength = 4096;
     protected String lastVisitUrl;


     public HttpBrowser() {
         this(EncodingUtil.DEFAULT_ENCODING);
     }

     public HttpBrowser(String encoding) {
         this.encoding = encoding;
         httpClient = new HttpClient();
         httpClient.getParams().setCookiePolicy(CookiePolicy.BROWSER_COMPATIBILITY);
         httpClient.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, encoding);
         httpClient.getParams().setParameter(HttpMethodParams.SINGLE_COOKIE_HEADER, true);
     }

     //----------- callable methods -------------//
     public HttpResponse doGet(String url) throws HttpBrowserException, HttpServerException {
         return doGet(url, "");
     }

     public HttpResponse doGet(String url, String referer) throws HttpBrowserException, HttpServerException {
         try {
             GetMethod getMethod = new GetMethod(url);
             setHttpRequestHeader(getMethod);
             if (referer != null && referer.trim().length() != 0) {
                 getMethod.setRequestHeader("Referer", referer);
             }
             logHttpGetRequest(getMethod);
             int status =httpClient.executeMethod(getMethod);
             String strResp = getMethod.getResponseBodyAsString();
             byte[] byteResp = getMethod.getResponseBody();
             String respEnc = getResponseEncoding(getMethod);
             logHttpResponse(getMethod, strResp);
             getMethod.releaseConnection();

             //http:301,302,303,307
             if (status == HttpStatus.SC_MOVED_PERMANENTLY ||
                 status == HttpStatus.SC_MOVED_TEMPORARILY ||
                 status == HttpStatus.SC_SEE_OTHER ||
                 status == HttpStatus.SC_TEMPORARY_REDIRECT) {
                 Header locationHeader = getMethod.getResponseHeader("Location");
                 String location = locationHeader.getValue();
                 if (logger.isDebugEnabled()) {
                     logger.debug("Redirect To Location = " + location);
                 }
                 if (location.startsWith("http")) {
                     return doGet(location);
                 } else {
                     return doGet("http://" + getResponseHost(getMethod) + location);
                 }
             } else if (status == HttpStatus.SC_OK) { //http:200
                 return new HttpResponse(getMethod.getURI().toString(), byteResp, respEnc);
             } else {
                 throw new HttpServerException("Server Exception[code=" + status + "]");
             }
         } catch (HttpException e) {
             throw new HttpBrowserException(e);
         } catch (IOException e) {
             throw new HttpBrowserException(e);
         }
     }

     public HttpResponse doPost(String url, NameValuePair[] params) throws HttpBrowserException, HttpServerException {
         return doPost(url, params, "");
     }

     public HttpResponse doPost(String url, NameValuePair[] params, String referer) throws HttpBrowserException, HttpServerException {
         try {
             PostMethod postMethod = new PostMethod(url);
             setHttpRequestHeader(postMethod);
             if (referer != null && referer.trim().length() != 0) {
                 postMethod.setRequestHeader("Referer", referer);
             }
             postMethod.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
             postMethod.setRequestBody(params);
             logHttpPostRequest(postMethod);
             int status = httpClient.executeMethod(postMethod);
             String strResp = postMethod.getResponseBodyAsString();
             byte[] byteResp = postMethod.getResponseBody();
             String respEnc = getResponseEncoding(postMethod);
             logHttpResponse(postMethod, strResp);
             postMethod.releaseConnection();

             //http:301,302,303,307
             if (status == HttpStatus.SC_MOVED_PERMANENTLY ||
                 status == HttpStatus.SC_MOVED_TEMPORARILY ||
                 status == HttpStatus.SC_SEE_OTHER ||
                 status == HttpStatus.SC_TEMPORARY_REDIRECT) {
                 Header locationHeader = postMethod.getResponseHeader("Location");
                 String location = locationHeader.getValue();
                 if (logger.isDebugEnabled()) {
                     logger.debug("Redirect To Location = " + location);
                 }
                 if (location.startsWith("http")) {
                     return doGet(location);
                 } else {
                     return doGet("http://" + getResponseHost(postMethod) + location);
                 }
             } else if (status == HttpStatus.SC_OK) { //http:200
                 return new HttpResponse(postMethod.getURI().toString(), byteResp, respEnc);
             } else {
                 throw new HttpServerException("Server Exception[code=" + status + "]");
             }
         } catch (HttpException e) {
             throw new HttpBrowserException(e);
         } catch (IOException e) {
             throw new HttpBrowserException(e);
         }
     }

     public Cookie[] getCurrentCookies() {
         Cookie[] cookies = httpClient.getState().getCookies();
         return cookies;
     }

     protected void setHttpRequestHeader(HttpMethod method) {
         method.setRequestHeader("Accept",
                 "text/html,application/xhtml+xml,application/xml,application/json,image/jpeg,image/gif,*/*");
         method.setRequestHeader("Accept-Language", "zh-cn");
         method.setRequestHeader(
                 "User-Agent",
                 "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3");
         method.setRequestHeader("Accept-Charset", encoding);
         method.setRequestHeader("Keep-Alive", "300");
         method.setRequestHeader("Connection", "Keep-Alive");
         method.setRequestHeader("Cache-Control", "no-cache");
     }

     //------------- log methods ----------------//
     private void logHttpGetRequest(HttpMethod method) {
         try {
             if (logger.isDebugEnabled()) {
                 logger.debug("/n/n============= HTTP Request Start =============");
                 logger.debug("HTTP Get Request URL ==>/n" + method.getURI().toString());
                 logger.debug("HTTP Get Request Headers ==>/n" + getHttpRequestHeader(method));
                 logger.debug("HTTP Get Request Cookies ==>/n" + getHttpCookie());
                 logger.debug("HTTP Get Request QueryString ==>/n" + method.getQueryString());
                 logger.debug("============= HTTP Request End =============/n/n");
             }
         } catch (URIException e) {
             logger.error(e);
         }
     }

     private void logHttpPostRequest(PostMethod method) {
         try {
             if (logger.isDebugEnabled()) {
                 logger.debug("/n/n============= HTTP Request Start =============");
                 logger.debug("HTTP Post Request URL ==>/n" + method.getURI().toString());
                 logger.debug("HTTP Post Request Headers ==>/n" + getHttpRequestHeader(method));
                 logger.debug("HTTP Post Request Cookies ==>/n" + getHttpCookie());
                 logger.debug("HTTP Post Request QueryString ==>/n" + method.getQueryString());
                 logger.debug("HTTP Post Request Body ==>/n" + getHttpRequestBody(method));
                 logger.debug("============= HTTP Request End =============/n/n");
             }
         } catch (URIException e) {
             logger.error("URIException", e);
         }
     }

     private void logHttpResponse(HttpMethod method, String strResp) {
         try {
             if (logger.isDebugEnabled()) {
                 logger.debug("/n/n============= HTTP Response Start =============");
                 logger.debug("HTTP Response URL ==>/n" + method.getURI().toString());
                 logger.debug("HTTP Response Headers ==>/n" + getHttpResponseHeader(method));
                 logger.debug("HTTP Response Cookies ==>/n" + getHttpCookie());
                 logger.debug("HTTP Response Body ==>/n" + strResp);
                 logger.debug("============= HTTP Response End =============/n/n");
             }
         } catch (URIException e) {
             logger.error("URIException", e);
         }
     }

     //---------- util methods -------------//
     private String getResponseEncoding(HttpMethod method) {
         Header header = method.getResponseHeader("Content-Type");
         String encoding = EncodingUtil.DEFAULT_ENCODING;
         if (header != null) {
             if (logger.isDebugEnabled()) {
                 logger.debug("Content-Type=" + header.getValue());
             }
             if (header != null) {
                 String value = header.getValue();
                 int idx1 = value.indexOf("charset=");
                 if (idx1 > -1) {
                     encoding = value.substring(idx1 + 8);
                     if (logger.isDebugEnabled()) {
                         logger.debug("Response Encoding=" + encoding);
                     }
                 }
             }
         }
         return encoding;
     }

     private String getResponseHost(HttpMethod method) {
         try {
             Pattern p = RegexpUtil.getHostFromURIRegexp();
             String url = method.getURI().toString();
             Matcher matcher = p.matcher(url);
             if (!matcher.find()) {
                 String msg = ExceptionMessage.PROTOCOL_MSG + "[Type=ResponseHost,Regexp=" + p.pattern() + "]";
                 logger.error(msg);
             }
             if (logger.isDebugEnabled()) {
                 logger.debug("Host=" + matcher.group(1));
             }
             return matcher.group(1);
         } catch (Exception e) {
             logger.error(e);
         }
         return "";
     }

     private String getHttpRequestBody(PostMethod method) {
         StringBuilder strBody = new StringBuilder();
         NameValuePair[] pairs = method.getParameters();
         for (NameValuePair pair : pairs) {
             String name = pair.getName();
             String value = pair.getValue();
             strBody.append(name + "=" + value + ";");
         }
         return strBody.toString();
     }

     private String getHttpCookie() {
         StringBuilder strHeader = new StringBuilder();
         Cookie[] cookies = httpClient.getState().getCookies();
         for (Cookie cookie : cookies) {
             String domain = cookie.getDomain();
             String path = cookie.getPath();
             String name = cookie.getName();
             String value = cookie.getValue();
             Date expired = cookie.getExpiryDate();
             boolean isSecure = cookie.getSecure();
             strHeader.append("domain=" + domain + ";");
             strHeader.append("path=" + path + ";");
             strHeader.append(name + "=" + value + ";");
             if (expired != null) {
                 strHeader.append("expired=" + expired.toGMTString() + ";");
             }
             strHeader.append("isSecure=" + isSecure+ "/n");
         }
         return strHeader.toString();
     }

     private String getHttpRequestHeader(HttpMethod method) {
         StringBuilder strHeader = new StringBuilder();
         Header[] headers = method.getRequestHeaders();
         for (Header header : headers) {
             String name = header.getName();
             String value = header.getValue();
             strHeader.append(name + "=" + value + ";");
         }
         return strHeader.toString();
     }

     private String getHttpResponseHeader(HttpMethod method) {
         StringBuilder strHeader = new StringBuilder();
         Header[] headers = method.getResponseHeaders();
         for (Header header : headers) {
             String name = header.getName();
             String value = header.getValue();
             strHeader.append(name + "=" + value + ";");
         }
         return strHeader.toString();
     }
 }

10.HttpResponse类，http的回复结果类

 package org.gc.contact.http;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.gc.contact.util.EncodingUtil;
 public class HttpResponse {

     private static final Log logger = LogFactory.getLog(HttpResponse.class);

     private final String responseUrl;
     private final byte[] bodyAsBytes;
     private final String encoding;

     public HttpResponse(String responseUrl, byte[] bodyAsBytes) {
         this(responseUrl, bodyAsBytes, EncodingUtil.DEFAULT_ENCODING);
     }

     public HttpResponse(String responseUrl, byte[] bodyAsBytes, String encoding) {
         this.responseUrl = responseUrl;
         this.bodyAsBytes = bodyAsBytes;
         this.encoding = encoding;
     }

     public String getResponseUrl() {
         return responseUrl;
     }

     public String getBodyAsString() {
         try {
             if (logger.isDebugEnabled()) {
                 logger.debug("Convert Encoding=" + encoding);
             }
             return new String(bodyAsBytes, encoding);
         } catch (UnsupportedEncodingException e) {
             logger.error("Encoding Error[encoding=" + encoding + "]", e);
             try {
                 return new String(bodyAsBytes, EncodingUtil.DEFAULT_ENCODING);
             } catch (UnsupportedEncodingException e1) {
                 logger.error("Encoding Error[encoding=" + EncodingUtil.DEFAULT_ENCODING + "]", e);
                 return new String(bodyAsBytes);
             }
         }
     }

     public byte[] getBodyAsBytes() {
         return bodyAsBytes;
     }

     public InputStream getBodyAsStream() {
         return new ByteArrayInputStream(bodyAsBytes);
     }

 }

11.SSLFactory类，用于https

 package org.gc.contact.http;
 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 SSLFactory implements SecureProtocolSocketFactory {

     static {
         System.out.println(">>>> SSLFactory Init <<<<");
     }

     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[]{};
         }
     }
 }

12.SSLUtilities类，用于https

 package org.gc.contact.http;
 import java.security.GeneralSecurityException;
 import java.security.SecureRandom;
 import java.security.cert.X509Certificate;
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.HttpsURLConnection;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;
 /**
  * This class provide various static methods that relax X509 certificate and
  * hostname verification while using the SSL over the HTTP protocol.
  *
  * @author Francis Labrie
  */
 public final class SSLUtilities {
     /**
      * Hostname verifier for the Sun's deprecated API.
      *
      * @deprecated see {@link #_hostnameVerifier}.
      */
     private static com.sun.net.ssl.HostnameVerifier __hostnameVerifier;
     /**
      * Thrust managers for the Sun's deprecated API.
      *
      * @deprecated see {@link #_trustManagers}.
      */
     private static com.sun.net.ssl.TrustManager[] __trustManagers;
     /**
      * Hostname verifier.
      */
     private static HostnameVerifier _hostnameVerifier;
     /**
      * Thrust managers.
      */
     private static TrustManager[] _trustManagers;
     /**
      * Set the default Hostname Verifier to an instance of a fake class that
      * trust all hostnames. This method uses the old deprecated API from the
      * com.sun.ssl package.
      *
      * @deprecated see {@link #_trustAllHostnames()}.
      */
     private static void __trustAllHostnames() {
         // Create a trust manager that does not validate certificate chains
         if (__hostnameVerifier == null) {
             __hostnameVerifier = new _FakeHostnameVerifier();
         } // if
         // Install the all-trusting host name verifier
         com.sun.net.ssl.HttpsURLConnection
                 .setDefaultHostnameVerifier(__hostnameVerifier);
     } // __trustAllHttpsCertificates
     /**
      * Set the default X509 Trust Manager to an instance of a fake class that
      * trust all certificates, even the self-signed ones. This method uses the
      * old deprecated API from the com.sun.ssl package.
      *
      * @deprecated see {@link #_trustAllHttpsCertificates()}.
      */
     private static void __trustAllHttpsCertificates() {
         com.sun.net.ssl.SSLContext context;
         // Create a trust manager that does not validate certificate chains
         if (__trustManagers == null) {
             __trustManagers = new com.sun.net.ssl.TrustManager[] { new _FakeX509TrustManager() };
         } // if
         // Install the all-trusting trust manager
         try {
             context = com.sun.net.ssl.SSLContext.getInstance("SSL");
             context.init(null, __trustManagers, new SecureRandom());
         } catch (GeneralSecurityException gse) {
             throw new IllegalStateException(gse.getMessage());
         } // catch
         com.sun.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(context
                 .getSocketFactory());
     } // __trustAllHttpsCertificates
     /**
      * Return true if the protocol handler property java. protocol.handler.pkgs
      * is set to the Sun's com.sun.net.ssl. internal.www.protocol deprecated
      * one, false otherwise.
      *
      * @return true if the protocol handler property is set to the Sun's
      *         deprecated one, false otherwise.
      */
     private static boolean isDeprecatedSSLProtocol() {
         return ("com.sun.net.ssl.internal.www.protocol".equals(System
                 .getProperty("java.protocol.handler.pkgs")));
     } // isDeprecatedSSLProtocol
     /**
      * Set the default Hostname Verifier to an instance of a fake class that
      * trust all hostnames.
      */
     private static void _trustAllHostnames() {
         // Create a trust manager that does not validate certificate chains
         if (_hostnameVerifier == null) {
             _hostnameVerifier = new FakeHostnameVerifier();
         } // if
         // Install the all-trusting host name verifier:
         HttpsURLConnection.setDefaultHostnameVerifier(_hostnameVerifier);
     } // _trustAllHttpsCertificates
     /**
      * Set the default X509 Trust Manager to an instance of a fake class that
      * trust all certificates, even the self-signed ones.
      */
     private static void _trustAllHttpsCertificates() {
         SSLContext context;
         // Create a trust manager that does not validate certificate chains
         if (_trustManagers == null) {
             _trustManagers = new TrustManager[] { new FakeX509TrustManager() };
         } // if
         // Install the all-trusting trust manager:
         try {
             context = SSLContext.getInstance("SSL");
             context.init(null, _trustManagers, new SecureRandom());
         } catch (GeneralSecurityException gse) {
             throw new IllegalStateException(gse.getMessage());
         } // catch
         HttpsURLConnection.setDefaultSSLSocketFactory(context
                 .getSocketFactory());
     } // _trustAllHttpsCertificates
     /**
      * Set the default Hostname Verifier to an instance of a fake class that
      * trust all hostnames.
      */
     public static void trustAllHostnames() {
         // Is the deprecated protocol setted?
         if (isDeprecatedSSLProtocol()) {
             __trustAllHostnames();
         } else {
             _trustAllHostnames();
         } // else
     } // trustAllHostnames
     /**
      * Set the default X509 Trust Manager to an instance of a fake class that
      * trust all certificates, even the self-signed ones.
      */
     public static void trustAllHttpsCertificates() {
         // Is the deprecated protocol setted?
         if (isDeprecatedSSLProtocol()) {
             __trustAllHttpsCertificates();
         } else {
             _trustAllHttpsCertificates();
         } // else
     } // trustAllHttpsCertificates
     /**
      * This class implements a fake hostname verificator, trusting any host
      * name. This class uses the old deprecated API from the com.sun. ssl
      * package.
      *
      * @author Francis Labrie
      *
      * @deprecated see {@link SSLUtilities.FakeHostnameVerifier}.
      */
     public static class _FakeHostnameVerifier implements
             com.sun.net.ssl.HostnameVerifier {
         /**
          * Always return true, indicating that the host name is an acceptable
          * match with the server's authentication scheme.
          *
          * @param hostname
          *            the host name.
          * @param session
          *            the SSL session used on the connection to host.
          * @return the true boolean value indicating the host name is trusted.
          */
         public boolean verify(String hostname, String session) {
             return (true);
         } // verify
     } // _FakeHostnameVerifier
     /**
      * This class allow any X509 certificates to be used to authenticate the
      * remote side of a secure socket, including self-signed certificates. This
      * class uses the old deprecated API from the com.sun.ssl package.
      *
      * @author Francis Labrie
      *
      * @deprecated see {@link SSLUtilities.FakeX509TrustManager}.
      */
     public static class _FakeX509TrustManager implements
             com.sun.net.ssl.X509TrustManager {
         /**
          * Empty array of certificate authority certificates.
          */
         private static final X509Certificate[] _AcceptedIssuers = new X509Certificate[] {};
         /**
          * Always return true, trusting for client SSL chain peer certificate
          * chain.
          *
          * @param chain
          *            the peer certificate chain.
          * @return the true boolean value indicating the chain is trusted.
          */
         public boolean isClientTrusted(X509Certificate[] chain) {
             return (true);
         } // checkClientTrusted
         /**
          * Always return true, trusting for server SSL chain peer certificate
          * chain.
          *
          * @param chain
          *            the peer certificate chain.
          * @return the true boolean value indicating the chain is trusted.
          */
         public boolean isServerTrusted(X509Certificate[] chain) {
             return (true);
         } // checkServerTrusted
         /**
          * Return an empty array of certificate authority certificates which are
          * trusted for authenticating peers.
          *
          * @return a empty array of issuer certificates.
          */
         public X509Certificate[] getAcceptedIssuers() {
             return (_AcceptedIssuers);
         } // getAcceptedIssuers
     } // _FakeX509TrustManager
     /**
      * This class implements a fake hostname verificator, trusting any host
      * name.
      *
      * @author Francis Labrie
      */
     public static class FakeHostnameVerifier implements HostnameVerifier {
         /**
          * Always return true, indicating that the host name is an acceptable
          * match with the server's authentication scheme.
          *
          * @param hostname
          *            the host name.
          * @param session
          *            the SSL session used on the connection to host.
          * @return the true boolean value indicating the host name is trusted.
          */
         public boolean verify(String hostname, javax.net.ssl.SSLSession session) {
             return (true);
         } // verify
     } // FakeHostnameVerifier
     /**
      * This class allow any X509 certificates to be used to authenticate the
      * remote side of a secure socket, including self-signed certificates.
      *
      * @author Francis Labrie
      */
     public static class FakeX509TrustManager implements X509TrustManager {
         /**
          * Empty array of certificate authority certificates.
          */
         private static final X509Certificate[] _AcceptedIssuers = new X509Certificate[] {};
         /**
          * Always trust for client SSL chain peer certificate chain with any
          * authType authentication types.
          *
          * @param chain
          *            the peer certificate chain.
          * @param authType
          *            the authentication type based on the client certificate.
          */
         public void checkClientTrusted(X509Certificate[] chain, String authType) {
         } // checkClientTrusted
         /**
          * Always trust for server SSL chain peer certificate chain with any
          * authType exchange algorithm types.
          *
          * @param chain
          *            the peer certificate chain.
          * @param authType
          *            the key exchange algorithm used.
          */
         public void checkServerTrusted(X509Certificate[] chain, String authType) {
         } // checkServerTrusted
         /**
          * Return an empty array of certificate authority certificates which are
          * trusted for authenticating peers.
          *
          * @return a empty array of issuer certificates.
          */
         public X509Certificate[] getAcceptedIssuers() {
             return (_AcceptedIssuers);
         } // getAcceptedIssuers
     } // FakeX509TrustManager
 } // SSLUtilities

下面就是取得联系人的过程了 
13.IContactFetcher接口

 package org.gc.contact.fetcher;
 import java.util.List;
 import org.gc.contact.exception.HttpBrowserException;
 import org.gc.contact.exception.HttpServerException;
 import org.gc.contact.exception.ProtocolException;
 import org.gc.contact.model.ContactInfo;
 public interface IContactFetcher {

     void doLogin() throws HttpBrowserException, HttpServerException, ProtocolException;
     List fetchContactInfo() throws HttpBrowserException, HttpServerException, ProtocolException;

 }

14.AbstractContactFetcher类

 package org.gc.contact.fetcher;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.gc.contact.exception.ExceptionMessage;
 import org.gc.contact.exception.ProtocolException;
 import org.gc.contact.http.HttpBrowser;
 import org.gc.contact.util.RegexpUtil;
 public abstract class AbstractContactFetcher implements IContactFetcher {

     protected final Log logger = LogFactory.getLog(getClass());
     protected final HttpBrowser browser;

     protected String username;
     protected String password;

     public AbstractContactFetcher(String username, String password) {
         this.username = username;
         this.password = password;
         browser = new HttpBrowser();
     }

     protected String getJSRedirection(String htmlContent) throws ProtocolException {
         Pattern p = RegexpUtil.getJSRedirectionRegexp();
         Matcher matcher = p.matcher(htmlContent);
         if (!matcher.find()) {
             String msg = ExceptionMessage.PROTOCOL_MSG + "[Type=JSRedirection,Regexp=" + p.pattern() + "]";
             logger.error(msg);
             throw new ProtocolException(msg);
         }
         if (logger.isDebugEnabled()) {
             logger.debug("Redirection URL = " + matcher.group(1));
         }
         return matcher.group(1);
     }

     protected String getFormInputValue(String name, String htmlContent) throws ProtocolException {
         Pattern p = RegexpUtil.getFormInputValueRegexp();
         int index = htmlContent.indexOf(name);
         int prePos = index - 400 > 0 ? index - 400 : 0;
         int postPos = index + 400 < htmlContent.length() ? index + 400 : htmlContent.length();
         int start = htmlContent.substring(prePos, index).lastIndexOf(") + prePos;
         int end = htmlContent.substring(index, postPos).indexOf(">") + index;
         String htmlInput = htmlContent.substring(start, end + 1);
         if (logger.isDebugEnabled()) {
             logger.debug("HtmlInput=" + htmlInput);
         }
         Matcher matcher = p.matcher(htmlInput);
         if (!matcher.find()) {
             String msg = ExceptionMessage.PROTOCOL_MSG + "[Type=FormInputValue,Regexp=" + p.pattern() + "]";
             logger.error(msg);
             throw new ProtocolException(msg);
         }
         if (logger.isDebugEnabled()) {
             logger.debug("Name = " + name + ";value = " + matcher.group(1));
         }
         return matcher.group(1);
     }

     protected String getHost(String url) throws ProtocolException {
         Pattern p = RegexpUtil.getHostFromURIRegexp();
         Matcher matcher = p.matcher(url);
         if (!matcher.find()) {
             String msg = ExceptionMessage.PROTOCOL_MSG + "[Type=Host,Regexp=" + p.pattern() + "]";
             logger.error(msg);
             throw new ProtocolException(msg);
         }
         if (logger.isDebugEnabled()) {
             logger.debug("Host = " + matcher.group(1));
         }
         return matcher.group(1);
     }

     protected List getValue(Pattern p, String htmlContent) throws ProtocolException {
         List data = new ArrayList();
         Matcher matcher = p.matcher(htmlContent);
         while (matcher.find()) {
             try {
                 data.add(matcher.group(1));
                 if (logger.isDebugEnabled()) {
                     logger.debug("Matched String=" + matcher.group(1));
                 }
             } catch (Exception e) {
                 String msg = ExceptionMessage.PROTOCOL_MSG + "[Type=getValue,Regexp=" + p.pattern() + "]";
                 logger.error(msg);
                 throw new ProtocolException(msg);
             }
         }
         if (data.size() == 0) {
             String msg = ExceptionMessage.PROTOCOL_MSG + "[Type=getValue,Regexp=" + p.pattern() + "]";
             logger.warn(msg);
         }
         return data;
     }
 }

15.取163的联系人

 package org.gc.contact.fetcher;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
 import org.apache.commons.httpclient.NameValuePair;
 import org.gc.contact.exception.HttpBrowserException;
 import org.gc.contact.exception.HttpServerException;
 import org.gc.contact.exception.ProtocolException;
 import org.gc.contact.http.HttpResponse;
 import org.gc.contact.model.ContactInfo;
 /**
  * @163.com邮箱取地址本过程
  * 1. loginUrl
  * 2. window.location.replace("url")
  * 3. fetch address list
  *
  */
 public class Mail163ContactFetcher extends AbstractContactFetcher {

     private final String loginUrl = "http://reg.163.com/login.jsp?type=1&product=mail163&url=http://entry.mail.163.com/coremail/fcg/ntesdoor2?lightweight%3D1%26verifycookie%3D1%26language%3D-1%26style%3D35";

     /**
      * fetch url
      * http://g1a61.mail.163.com/jy3/address/addrlist.jsp?sid=SBmtqsXXQmCXunRFLtXXXfowbRxMPUUX&gid=all
     */
     private String fetchUrl;

     private final String REGEXP_USER = "Ibx_Td_addrName/">/" mce_href="/""addrdetail.jsp//?sid=.+&gid=all/" title=/".+/">(.+)";
     private final String REGEXP_EMAIL = "Ibx_Td_addrEmail/">/" mce_href="/""addrdetail.jsp//?sid=.+&gid=all/" title=/".+/">(.+)";
     private final Pattern PATTERN_USER = Pattern.compile(REGEXP_USER);
     private final Pattern PATTERN_EMAIL = Pattern.compile(REGEXP_EMAIL);

     public Mail163ContactFetcher(String username, String password) {
         super(username, password);
     }
     @Override
     public void doLogin() throws HttpBrowserException, HttpServerException, ProtocolException {
         NameValuePair[] loginParams = makeLoginParams();
         HttpResponse redirectPage = browser.doPost(loginUrl, loginParams);
         String redirectUrl = getJSRedirection(redirectPage.getBodyAsString());
         HttpResponse mainPage = browser.doGet(redirectUrl);
         fetchUrl = mainPage.getResponseUrl();
     }
     @Override
     public List fetchContactInfo() throws HttpBrowserException, HttpServerException, ProtocolException {
         List contacts = new ArrayList();
         String contactUrl = fetchUrl.replace("main.jsp", "address/addrlist.jsp");
         contactUrl += "&gid=all";
         HttpResponse contactPage = browser.doGet(contactUrl);
         String html = contactPage.getBodyAsString();
         //为了匹配,每个td一行
         html = html.replace("", "/n");
         List username = getValue(PATTERN_USER, html);
         List email = getValue(PATTERN_EMAIL, html);
         for (int i = 0; i < username.size(); i++) {
             contacts.add(new ContactInfo(username.get(i), email.get(i)));
         }
         return contacts;
     }

     private NameValuePair[] makeLoginParams() {
         return new NameValuePair[] {
                 new NameValuePair("username", username),
                 new NameValuePair("password", password)
         };
     }

 }