使用httpurlconnection带cookie进行get/post类型的url请求

package httpconnection;

import java.net.*;
import java.io.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.text.*;

/**
 * please view http://www.hccp.org/java-net-cookie-how-to.html to get more doc.
 * 
 * CookieManager is a simple utilty for handling cookies when working with
 * java.net.URL and java.net.URLConnection objects.
 * 
 * 
 * Cookiemanager cm = new CookieManager(); 
 * URL url = new URL("http://www.hccp.org/test/cookieTest.jsp");
 * 
 *  . . .
 *  
 *  // getting cookies: 
 *  URLConnection conn = url.openConnection();
 *  
 *  // setting cookies 
 *  cm.setCookies(url.openConnection());  
 *  
 *  conn.connect(); 
 *  cm.storeCookies(conn);
 *  

 * 
 * @author Ian Brown
 * 
 */

public class CookieManager {

	private Map<String, Map<String, Map<String, String>>> store = new ConcurrentHashMap<String, Map<String, Map<String, String>>>();;

	private static final String SET_COOKIE = "Set-Cookie";
	private static final String COOKIE_VALUE_DELIMITER = ";";
	private static final String PATH = "path";
	private static final String EXPIRES = "expires";
	private static final String DATE_FORMAT = "EEE, dd-MMM-yyyy hh:mm:ss z";
	private static final String SET_COOKIE_SEPARATOR = "; ";
	private static final String COOKIE = "Cookie";

	private static final char NAME_VALUE_SEPARATOR = '=';
	private static final char DOT = '.';

	private DateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);;

	public CookieManager() {
	}

	/**
	 * Retrieves and stores cookies returned by the host on the other side of
	 * the the open java.net.URLConnection.
	 * 
	 * The connection MUST have been opened using the connect() method or a
	 * IOException will be thrown.
	 * 
	 * @param conn
	 *            a java.net.URLConnection - must be open, or IOException will
	 *            be thrown
	 * @throws java.io.IOException
	 *             Thrown if conn is not open.
	 */
	public void storeCookies(URLConnection conn) throws IOException {

		// let's determine the domain from where these cookies are being sent
		String domain = getDomainFromHost(conn.getURL().getHost());

		Map<String, Map<String, String>> domainStore; // this is where we will
		// store cookies for
		// this domain

		// now let's check the store to see if we have an entry for this domain
		synchronized (store) {
			if (store.containsKey(domain)) {
				// we do, so lets retrieve it from the store
				domainStore = store.get(domain);
			} else {
				// we don't, so let's create it and put it in the store
				domainStore = new HashMap<String, Map<String, String>>();
				store.put(domain, domainStore);
			}
		}

		// OK, now we are ready to get the cookies out of the URLConnection

		String headerName = null;
		for (int i = 1; (headerName = conn.getHeaderFieldKey(i)) != null; i++) {
			if (headerName.equalsIgnoreCase(SET_COOKIE)) {
				Map<String, String> cookie = new HashMap<String, String>();
				StringTokenizer st = new StringTokenizer(conn.getHeaderField(i), COOKIE_VALUE_DELIMITER);

				// the specification dictates that the first name/value pair
				// in the string is the cookie name and value, so let's handle
				// them as a special case:

				if (st.hasMoreTokens()) {
					String token = st.nextToken();
					String name = token.substring(0, token.indexOf(NAME_VALUE_SEPARATOR));
					String value = token.substring(token.indexOf(NAME_VALUE_SEPARATOR) + 1, token.length());
					domainStore.put(name, cookie);
					cookie.put(name, value);
				}

				while (st.hasMoreTokens()) {
					String token = st.nextToken();
					cookie.put(token.substring(0,token.indexOf(NAME_VALUE_SEPARATOR)).toLowerCase(),
							token.substring(token.indexOf(NAME_VALUE_SEPARATOR) + 1, token.length()));
				}
			}
		}
		System.out.println(this);
	}

	/**
	 * Prior to opening a URLConnection, calling this method will set all
	 * unexpired cookies that match the path or subpaths for thi underlying URL
	 * 
	 * The connection MUST NOT have been opened method or an IOException will be
	 * thrown.
	 * 
	 * @param conn
	 *            a java.net.URLConnection - must NOT be open, or IOException
	 *            will be thrown
	 * @throws java.io.IOException
	 *             Thrown if conn has already been opened.
	 */
	public void setCookies(URLConnection conn) throws IOException {

		// let's determine the domain and path to retrieve the appropriate
		// cookies
		URL url = conn.getURL();
		String domain = getDomainFromHost(url.getHost());
		String path = url.getPath();

		Map<String, Map<String, String>> domainStore = store.get(domain);
		if (domainStore == null)
			return;
		StringBuffer cookieStringBuffer = new StringBuffer();

		Iterator<String> cookieNames = domainStore.keySet().iterator();
		while (cookieNames.hasNext()) {
			String cookieName = cookieNames.next();
			Map<String, String> cookie = domainStore.get(cookieName);
			// check cookie to ensure path matches and cookie is not expired
			// if all is cool, add cookie to header string
			if (comparePaths((String) cookie.get(PATH), path) && isNotExpired((String) cookie.get(EXPIRES))) {
				cookieStringBuffer.append(cookieName);
				cookieStringBuffer.append("=");
				cookieStringBuffer.append((String) cookie.get(cookieName));
				if (cookieNames.hasNext())
					cookieStringBuffer.append(SET_COOKIE_SEPARATOR);
			}
		}
		try {
			conn.setRequestProperty(COOKIE, cookieStringBuffer.toString());
		} catch (java.lang.IllegalStateException ise) {
			IOException ioe = new IOException(
					"Illegal State! Cookies cannot be set on a URLConnection that is already connected. "
							+ "Only call setCookies(java.net.URLConnection) AFTER calling java.net.URLConnection.connect().");
			throw ioe;
		}
	}

	private String getDomainFromHost(String host) {
		if (host.indexOf(DOT) != host.lastIndexOf(DOT)) {
			return host.substring(host.indexOf(DOT) + 1);
		} else {
			return host;
		}
	}

	private boolean isNotExpired(String cookieExpires) {
		if (cookieExpires == null)
			return true;
		Date now = new Date();
		try {
			return (now.compareTo(dateFormat.parse(cookieExpires))) <= 0;
		} catch (java.text.ParseException pe) {
			pe.printStackTrace();
			return false;
		}
	}

	private boolean comparePaths(String cookiePath, String targetPath) {
		if (cookiePath == null) {
			return true;
		} else if (cookiePath.equals("/")) {
			return true;
		} else if (targetPath.regionMatches(0, cookiePath, 0, cookiePath
				.length())) {
			return true;
		} else {
			return false;
		}

	}

	/**
	 * Returns a string representation of stored cookies organized by domain.
	 */

	public String toString() {
		return store.toString();
	}

	public static void main(String[] args) {
		CookieManager cm = new CookieManager();
		try {
			URL url = new URL("http://www.hccp.org/test/cookieTest.jsp");
			URLConnection conn = url.openConnection();
			conn.connect();
			cm.storeCookies(conn);
			System.out.println(cm);
			cm.setCookies(url.openConnection());
		} catch (IOException ioe) {
			ioe.printStackTrace();
		}
	}
}


package httpconnection;

import java.io.*;
import java.net.*;

public class HttpClient {

	public static final String METHOD_GET  = "GET";
	public static final String METHOD_POST = "POST";

	private final CookieManager cs;
	private final String urlString;

	public HttpClient(String urlString, CookieManager cm){
		if (cm == null)
			throw new RuntimeException("CookieManager for HttpClient() can NOT be NULL");

		this.urlString =urlString;
		this.cs = cm;
	}

	public BufferedReader doRequestGET(){
		return doRequest(METHOD_GET, null);
	}

	public BufferedReader doRequestPOST(String paramsToBePost){
		return doRequest(METHOD_POST, paramsToBePost);
	}




	private BufferedReader doRequest(String requestMethod, String paramsToBePost){

		HttpURLConnection conn = null;
		DataOutputStream output = null;
		BufferedReader in = null;

		try {
            URL url = new URL(urlString);
            conn = (HttpURLConnection) url.openConnection();

            //属性"User-Agent" 和 "Host"必须有，否则报错： "您的请求来路不正确或验证字串不符，无法提交。"
            conn.setRequestProperty("User-Agent","Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1.9) Gecko/20100315 Firefox/3.5.9");
            conn.setRequestProperty("Host",url.getHost());

            conn.setDefaultUseCaches(false);
            conn.setConnectTimeout(5000);
        	conn.setRequestProperty("Keep-Alive", "300");
            conn.setRequestProperty("Connection", "Keep-Alive");

            cs.setCookies(conn);

            if (requestMethod.toUpperCase().equals(METHOD_POST)) {
                conn.setDoOutput(true);
                conn.setDoInput(true);
                conn.setRequestMethod(requestMethod);


    			//setInstanceFollowRedirects can then be used to set if 
    			//redirects should be followed or not and this should be used before the
    			//connection is established (via getInputStream, getResponseCode, and other
    			//methods that result in the connection being established).

    			//inorder to disable the redirects
                conn.setInstanceFollowRedirects(false);

//              application/x-www-form-urlencoded
                conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");

                output=new DataOutputStream(conn.getOutputStream());
                output.writeBytes(paramsToBePost);
                output.flush();
                output.close();

            } else {
//            	User-Agent	Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1.9) Gecko/20100315 Firefox/3.5.9
//            	Accept	text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
//            	Accept-Language	zh-cn,zh;q=0.5
//            	Accept-Encoding	gzip,deflate
//            	Accept-Charset	GB2312,utf-8;q=0.7,*;q=0.7

//                conn.setRequestProperty("Accept","text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
//                conn.setRequestProperty("Accept-Language","zh-cn,zh;q=0.5");
//                conn.setRequestProperty("Accept-Encoding","gzip,deflate");
//                conn.setRequestProperty("Accept-Charset","GB2312,utf-8;q=0.7,*;q=0.7");

            }

            conn.connect();
            cs.storeCookies(conn);

        	int code = conn.getResponseCode();

        	in = new BufferedReader(new InputStreamReader(conn.getInputStream()));

//          String line;
//	        while ((line = in.readLine()) != null) {
//	            System.out.println(line);
//	        }          

		}catch(Exception e){
			in = null;
			e.printStackTrace();
		}finally{
			try {
				if(output != null) output.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		return in;
	}
}