HttpClient鏈接https網站

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.ResourceBundle;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import javazoom.jl.player.Player;

import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.util.EntityUtils;

public class Monitor {

	private static ResourceBundle p = ResourceBundle.getBundle("Config");

	public static void main(String[] args) {
		int interval = Integer.valueOf(p.getString("interval"));
		String do_url = p.getString("do_url");
		String pharmweb_url = p.getString("pharmweb_url");
		String do_login_url = p.getString("do_login_url");
		String pharmweb_login_url = p.getString("pharmweb_login_url");
		int timeout = Integer.valueOf(p.getString("timeout"));

		String proxyAddress = p.getString("proxy");
		int port = Integer.valueOf(p.getString("port"));

		String musicPath = p.getString("music_path");

		int sendmailCount = Integer.valueOf(p
				.getString("sendmail_interrupt_count"));
		int existCount = Integer.valueOf(p.getString("exit_interrupt_count"));

		ScheduledExecutorService service = Executors
				.newSingleThreadScheduledExecutor();
		Task task = new Task(do_url, do_login_url, pharmweb_url,
				pharmweb_login_url, timeout, proxyAddress, port, musicPath,
				sendmailCount, existCount);
		service.scheduleWithFixedDelay(task, 0, interval, TimeUnit.SECONDS);
	}
}

class Task implements Runnable {
	private static final SimpleDateFormat sf = new SimpleDateFormat(
			"dd/MM/yyyy HH:mm:ss");

	private String do_url ;
	private String pharmweb_url ;
	private String do_login_url ;
	private String pharmweb_login_url ;
	private int timeout = 30;
	private String proxyAddress = "proxy1.scig.gov.hk";
	private int port = 8080;
	private String music;
	private int sendmailCount;
	private int existCount;

	private static HashMap<String, Integer> interruptCounter = new HashMap<String, Integer>();
	private static int totalErrorConnection = 0;

	public Task(String do_url, String do_login_url, String pharmweb_url,
			String pharmweb_login_url, int timeout, String proxyAddress,
			int port, String music, int sendmailCount, int existCount) {
		this.do_url = do_url;
		this.do_login_url = do_login_url;
		this.pharmweb_url = pharmweb_url;
		this.pharmweb_login_url = pharmweb_login_url;
		this.timeout = timeout;
		this.proxyAddress = proxyAddress;
		this.port = port;
		this.music = music;
		this.sendmailCount = sendmailCount;
		this.existCount = existCount;
	}

	@Override
	public void run() {
		System.out.printf("=============== %s =====================\n", sf
				.format(new Date()));

		boolean useProxy = false;
		if (!"".equals(this.proxyAddress)) {
			useProxy = true;
		}

		System.out.printf("connect: %s\n", do_url);
		if (connectionChecking(do_url, useProxy)) {
			System.out.printf("connect: %s\n", do_login_url);
			checkDoLogin(do_login_url, useProxy);
		}

		System.out.printf("connect: %s\n", pharmweb_url);
		if (connectionChecking(pharmweb_url, false)) {
			System.out.printf("connect: %s\n", pharmweb_login_url);
			checkPharmwebLogin(pharmweb_login_url);
		}

		if (totalErrorConnection > 0) {
			System.out.printf("total error connection: [%s]\n",
					totalErrorConnection);
			if (totalErrorConnection > this.existCount) {
				System.exit(0);
			}
		}

		System.out.println("\n");
		notifyUser();
	}

	private void notifyUser() {
		for (String url : interruptCounter.keySet()) {
			int connectErrors = interruptCounter.get(url);

			if (connectErrors > this.sendmailCount) {
				System.out.println("send mail to notify users. error url: "
						+ url);
				interruptCounter.put(url, 0);
			}
		}
	}

	private boolean connectionChecking(String url, boolean useProxy) {
		DefaultHttpClient client = new DefaultHttpClient();
		if (useProxy) {
			HttpHost proxy = new HttpHost(proxyAddress, port);
			client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,
					proxy);
		}
		client.getParams().setParameter(
				CoreConnectionPNames.CONNECTION_TIMEOUT, timeout);

		HttpGet httpget = new HttpGet(url);

		try {
			HttpResponse response = client.execute(httpget);
			System.out.println(response.getStatusLine());
			return true;
		} catch (ClientProtocolException e) {
			processException(url, e);
		} catch (IOException e) {
			processException(url, e);
		} finally {
			postProcess(client, url);
		}
		return false;
	}

	private void checkPharmwebLogin(String url) {
		final DefaultHttpClient client = new DefaultHttpClient();
		client.getParams().setParameter(
				CoreConnectionPNames.CONNECTION_TIMEOUT, timeout);

		HttpPost httpget = new HttpPost(url);

		try {
			HttpResponse response = client.execute(httpget);
			System.out.println(response.getStatusLine());
		} catch (ClientProtocolException e) {
			processException(url, e);
		} catch (IOException e) {
			processException(url, e);
		} finally {
			postProcess(client, url);
		}
	}

	private void checkDoLogin(String url, boolean useProxy) {
		HttpClient client = WebClientDevWrapper
				.wrapClient(new DefaultHttpClient());
		HttpPost httpget = new HttpPost(url);

		try {
			if (useProxy) {
				HttpHost proxy = new HttpHost(proxyAddress, port);
				client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,
						proxy);
			}
			client.getParams().setParameter(
					CoreConnectionPNames.CONNECTION_TIMEOUT, timeout);
			HttpResponse response = client.execute(httpget);
			System.out.println(response.getStatusLine());

			EntityUtils.consume(response.getEntity());
		} catch (ClientProtocolException e) {
			processException(url, e);
		} catch (IOException e) {
			processException(url, e);
		} finally {
			postProcess(client, url);
		}
	}

	private void processException(String url, Exception e) {
		e.printStackTrace();
		System.out.printf("connect error:[%s]\n ", url);
		try {
			InputStream in = new FileInputStream(music);
			Player player = new Player(in);
			player.play();
		} catch (Exception e1) {
			e1.printStackTrace();
		}

		int num = 1;
		if (interruptCounter.containsKey(url)) {
			num = interruptCounter.get(url);
			num++;
			interruptCounter.put(url, num);
		} else {
			interruptCounter.put(url, num);
		}
		System.out.printf("url [%s] interrupt:[%d] \n", url, num);
		totalErrorConnection++;
	}

	private void postProcess(HttpClient client, String url) {
		client.getConnectionManager().shutdown();
		/*
		 * if (interruptCounter.containsKey(url)) { interruptCounter.put(url,
		 * 0); }
		 */
	}
}

class WebClientWrapper {
	public static HttpClient wrapClient(HttpClient base) {
		try {
			SSLContext ctx = SSLContext.getInstance("TLS");
			X509TrustManager tm = new X509TrustManager() {
				@Override
				public void checkClientTrusted(X509Certificate[] arg0,
						String arg1) throws CertificateException {
				}

				@Override
				public void checkServerTrusted(X509Certificate[] arg0,
						String arg1) throws CertificateException {
				}

				@Override
				public X509Certificate[] getAcceptedIssuers() {
					return null;
				}
			};

			ctx.init(null, new TrustManager[] { tm }, null);
			SSLSocketFactory ssf = new SSLSocketFactory(ctx,
					SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
			ClientConnectionManager ccm = base.getConnectionManager();
			SchemeRegistry sr = ccm.getSchemeRegistry();
			sr.register(new Scheme("https", 443, ssf));
			return new DefaultHttpClient(ccm, base.getParams());

		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
}

參考：

http://javaskeleton.blogspot.com/2010/07/avoiding-peer-not-authenticated-with.html

http://javasight.net/2011/06/avoid-javax-net-ssl-sslpeerunverifiedexception/