使用httpclient模拟登陆

1，导入jar包

2，配置文件：roadThread.properties

#\u7EBF\u7A0B\u6C60\u7EF4\u62A4\u7EBF\u7A0B\u7684\u6700\u5C11\u6570\u91CF
ExecutorServicePool.corePoolSize=5
#\u7EBF\u7A0B\u6C60\u7EF4\u62A4\u7EBF\u7A0B\u7684\u6700\u5927\u6570\u91CF
ExecutorServicePool.maximumPoolSize=5
#\u7EBF\u7A0B\u6C60\u7EF4\u62A4\u7EBF\u7A0B\u6240\u5141\u8BB8\u7684\u7A7A\u95F2\u65F6\u95F4
#默认5分钟
ExecutorServicePool.keepAliveTime=5
ExecutorServicePool.corePoolSizeThread=5
ExecutorServicePool.maximumPoolSizeThread=7

#初始化线程
ExecutorServicePool.corePoolSizeThreadController=5
#controller最大线程数
ExecutorServicePool.maximumPoolSizeThreadController=10
#controller承受最大的任务队列
ExecutorServicePool.maxTaskController=2000
#重发次数
ExecuteAbstract.resendTimes=4
#是否直接请求直接交付给线程池管理
ExecuteAbstract.isThreadManagement=true
#是否启用代理
ExecuteAbstract.isproxy=true

3，java实现类：

CHeader.java

package test;

/**
 * httpClient请求头实体bean
 * 
 * @author fastw
 * 
 */
public class CHeader {
	/** 服务器接受类型 */
	private String Accept;
	/** 引用那个地址过来 */
	private String Referer;
	/** 服务器接受类型编码 gzip.default */
	private String Accept_Encoding;
	/** 服务器接受类型语言 */
	private String Accept_Language;
	/** 是否有缓存 */
	private String Cache_Control;
	/** 连接状态 keep-alive */
	private String Connection;
	/** 文本格式渲染格式 */
	private String Content_Type;
	private String Host;
	/** xml request */
	private Boolean x_requested_with;
	// 默认就行
	private String User_Agent;
	/** 响应解析编码 */
	private String respCharset;
	private String Origin;

	/***
	 * cookie信息
	 */
	private String cookie;

	public CHeader() {
	}

	public CHeader(String accept, String content_Type, String host) {
		Accept = accept;
		Content_Type = content_Type;
		Host = host;
	}

	public CHeader(String referer, Boolean x_requested_with) {
		this.Referer = referer;
		this.x_requested_with = x_requested_with;
	}

	/**
	 * @param referer
	 *            设置referer
	 */
	public CHeader(String referer) {
		this.Referer = referer;
	}

	public CHeader(String referer, String origin) {
		this.Referer = referer;
		this.Origin = origin;
	}

	public CHeader(String accept, String referer, String content_Type,
			String host) {
		super();
		Accept = accept;
		Referer = referer;
		Content_Type = content_Type;
		Host = host;
	}

	public CHeader(String accept, String referer, String content_Type,
			String host, Boolean x_requested_with) {
		super();
		Accept = accept;
		Referer = referer;
		Content_Type = content_Type;
		Host = host;
		this.x_requested_with = x_requested_with;
	}

	public String getAccept() {
		return Accept;
	}

	/** 服务器接受类型 */
	public void setAccept(String accept) {
		Accept = accept;
	}

	public String getReferer() {
		return Referer;
	}

	/** 引用那个地址过来 */
	public void setReferer(String referer) {
		Referer = referer;
	}

	public String getAccept_Encoding() {
		return Accept_Encoding;
	}

	/** 服务器接受类型编码 gzip.default ,可为空 */
	public void setAccept_Encoding(String accept_Encoding) {
		Accept_Encoding = accept_Encoding;
	}

	public String getAccept_Language() {
		return Accept_Language;
	}

	/** 服务器接受类型语言 可为空默认zh-cn */
	public void setAccept_Language(String accept_Language) {
		Accept_Language = accept_Language;
	}

	public String getCache_Control() {
		return Cache_Control;
	}

	/** 是否有缓存,可为空 */
	public void setCache_Control(String cache_Control) {
		Cache_Control = cache_Control;
	}

	public String getConnection() {
		return Connection;
	}

	/** 连接状态 keep-alive,可为空 */
	public void setConnection(String connection) {
		Connection = connection;
	}

	public String getContent_Type() {
		return Content_Type;
	}

	/** 文本格式渲染格式 */
	public void setContent_Type(String content_Type) {
		Content_Type = content_Type;
	}

	public String getHost() {
		return Host;
	}

	public void setHost(String host) {
		Host = host;
	}

	public Boolean getX_requested_with() {
		return x_requested_with;
	}

	/** xml request */
	public void setX_requested_with(Boolean x_requested_with) {
		this.x_requested_with = x_requested_with;
	}

	public String getUser_Agent() {
		return User_Agent;
	}

	public void setUser_Agent(String user_Agent) {
		User_Agent = user_Agent;
	}

	public String getCookie() {
		return cookie;
	}

	public void setCookie(String cookie) {
		this.cookie = cookie;
	}

	/**
	 * @return 编码
	 */
	public String getRespCharset() {
		return respCharset;
	}

	/**
	 * 设置响应编码
	 */
	public void setRespCharset(String respCharset) {
		this.respCharset = respCharset;
	}

	/**
	 * @return origin
	 */
	public String getOrigin() {
		return Origin;
	}

	/**
	 * @param origin
	 *            要设置的 origin
	 */
	public void setOrigin(String origin) {
		Origin = origin;
	}
}

ComparableFutureTask.java

package test;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 实现Comparable 接口
 * 
 * @author fastw
 * @date 2014-10-4 下午11:29:31
 * @param <V>
 */
public class ComparableFutureTask<V> extends FutureTask<V> implements
		Comparable<ComparableFutureTask<V>> {
	private Object object;

	public ComparableFutureTask(Callable<V> callable) {
		super(callable);
		object = callable;
	}
	public ComparableFutureTask(Runnable runnable, V result) {
		super(runnable, result);
		object = runnable;
	}
	@Override
	@SuppressWarnings("unchecked")
	public int compareTo(ComparableFutureTask<V> o) {
		if (this == o) {
			return 0;
		}
		if (o == null) {
			return -1; // high priority
		}
		if (object != null && o.object != null) {
			if (object.getClass().equals(o.object.getClass())) {
				if (object instanceof Comparable) {
					return ((Comparable) object).compareTo(o.object);
				}
			}
		}
		return 0;
	}
}

class ThreadCallable implements Callable<String> {
	private ExecuteRequest request;
	private SendRequestPojo pojo;

	public ThreadCallable(ExecuteRequest request, SendRequestPojo pojo) {
		this.request = request;
		this.pojo = pojo;
	}

	@Override
	public String call() throws Exception {
		return request.execute(pojo);
	}

}

ExecuteRequest.java

package test;

import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.impl.client.CloseableHttpClient;

/**
 * 请求执行类
 * 
 * @author fastw
 * @date 2014-8-13 下午3:18:21
 */
public class ExecuteRequest {
	
	public static CloseableHttpClient client = HttpClientConnectionPool.getInstance();
	
	public static final String isThreadManagement = InfoUtil.getInstance().getInfo("roadThread", "ExecuteAbstract.isThreadManagement");
	public static final int resendTimes = Integer.parseInt(InfoUtil.getInstance().getInfo("roadThread", "ExecuteAbstract.resendTimes"));// 重发次数

	private static final Integer corePoolSize = Integer.parseInt(InfoUtil .getInstance().getInfo("roadThread", "ExecutorServicePool.corePoolSize"));

	private static final Integer maximumPoolSize = Integer.parseInt(InfoUtil.getInstance().getInfo("roadThread", "ExecutorServicePool.maximumPoolSize"));

	private static final Integer keepAliveTime = Integer.parseInt(InfoUtil.getInstance().getInfo("roadThread", "ExecutorServicePool.keepAliveTime"));

	public HttpClientContext context;

	public ExecuteRequest() {
		super();
	}

	public ExecuteRequest(HttpClientContext context) {
		this.context = context;
	}

	public HttpClientContext getContext() {
		return context;
	}

	/**
	 * 禁止直接使用
	 * 
	 * @param requestPojo
	 * @return
	 */
	public String execute(SendRequestPojo requestPojo) {
		
		Integer statusCode = 0;// 响应头
		String text = null;
		long startTime = 0;
		for (int j = 0; j < resendTimes; j++) {
			startTime = System.currentTimeMillis();
			long time = 0;
			try {
				HttpResponse response = client.execute(requestPojo.getHttpRequestBase(), this.context);
				time = System.currentTimeMillis() - startTime;
				System.out.println("地址:" + requestPojo.getUrl() + "响应时间:" + time);
				statusCode = response.getStatusLine().getStatusCode();
				if (statusCode == 200) {
					if (requestPojo.getHeader() != null && requestPojo.getHeader().getRespCharset() != null) {
						text = ParseResponse.parse(response, requestPojo.getHeader().getRespCharset());
					} else {
						text = ParseResponse.parse(response);
					}
				} else if (statusCode == 302 || statusCode == 301) {
					text = ParseResponse.getLocation(response);
				} else if (statusCode >= 400 && statusCode < 500) {
					if (statusCode != 404) {
						statusCode = 403;
					}
				} else {
					if (statusCode < 400) {
						statusCode = 200;
					}
				}
			} catch (Exception e) {
				
			}
			if (time != 0) {
				break;
			} else {
			}
		}
		if (text == null) {
			requestPojo.abort();
		}
		return text;
	}

	public String getResult(SendRequestPojo pojo) {
		String result = null;
		if (StringUtils.isNotBlank(pojo.getUrl())) {
			//是否交给线程池去管理，暂时不用
			if (!isThreadManagement.equals("false")) {
				result = this.execute(pojo);
			} else {
				ComparableFutureTask<String> futureTask = new ComparableFutureTask<String>(new ThreadCallable(this, pojo));
				BlockingQueue<Runnable> workQueue = new PriorityBlockingQueue<Runnable>();// 带有执行优先级的队列
				new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MINUTES, workQueue).submit(futureTask);
				try {
					result = futureTask.get();
				} catch (Exception e) {
					
				}
			}
		}
		return result;
	}

	public String get(String url) {
		return get(url, null);
	}

	public String get(String url, CHeader h) {
		return getResult(new SendRequestPojo(url, h, true));
	}

	public String getURL(String url) {
		return getResult(new SendRequestPojo(url, null, false));
	}

	public String getURL(String url, CHeader h) {
		return getResult(new SendRequestPojo(url, h, false));
	}

	public String post(String url, CHeader h, String XmlsOrJson) {
		SendRequestPojo pojo = new SendRequestPojo(url, h);
		pojo.setXmlsOrJsonEntity(XmlsOrJson);
		return getResult(pojo);
	}

	public String post(String url, Map<String, String> param) {
		return post(url, null, param);
	}

	public String post(String url, CHeader h, Map<String, String> param) {
		return getResult(new SendRequestPojo(url, param, h, true));// 为兼容之前的请求默认是true
																	// uri请求访问
	}

	public String postURL(String url, Map<String, String> param) {
		return getResult(new SendRequestPojo(url, param, null, false));
	}

	public String postURL(String url, CHeader h, Map<String, String> param) {
		return getResult(new SendRequestPojo(url, param, h, false));
	}
}

HttpClientConnectionPool.java

package test;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import java.nio.charset.CodingErrorAction;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

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

import org.apache.http.Consts;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.config.MessageConstraints;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ConnectionKeepAliveStrategy;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;

/**
 * client池类
 * 
 * @author fastw
 * @date 2014-9-14 上午11:10:24
 */
public class HttpClientConnectionPool {
	/** 将最大连接数增加到200 **/
	private final Integer maxTotal = 2000;
	/** defaultMaxPerRoute */
	private final Integer defaultMaxPerRoute = 1000;
	/** 如果内部失败就重发!,最多重发4次 **/
	private final int resendTimes = 4;

	private static CloseableHttpClient client = null;
	private HttpClientBuilder builder = null;
	static {
		client = getCloseableClient();
	}

	public static CloseableHttpClient getInstance() {
		return client;
	}

	private static CloseableHttpClient getCloseableClient() {
		HttpClientConnectionPool clientPool = new HttpClientConnectionPool();
		clientPool.setExecutionCount().setClientConnectionPool()
				.setKeepAliveDuration();
		return clientPool.getBuilder().build();
	}

	public HttpClientBuilder getBuilder() {
		if (builder == null) {
			builder = HttpClientBuilder.create();
		}
		return builder;
	}

	/**
	 * 默认请求次数
	 * 
	 * @param builder
	 */
	private HttpClientConnectionPool setExecutionCount() {
		HttpRequestRetryHandler myRetryHandler = new HttpRequestRetryHandler() {

			public boolean retryRequest(IOException exception,
					int executionCount, HttpContext context) {
				if (executionCount >= resendTimes) {
					// 如果已经重试了5次，就放弃
					return false;
				}
				if (exception instanceof InterruptedIOException) {
					// 超时
					return false;
				}
				if (exception instanceof UnknownHostException) {
					// 目标服务器不可达
					return false;
				}
				if (exception instanceof ConnectTimeoutException) {
					// 连接被拒绝
					return false;
				}
				if (exception instanceof SSLException) {
					// ssl握手异常
					return false;
				}
				HttpClientContext clientContext = HttpClientContext
						.adapt(context);
				HttpRequest request = clientContext.getRequest();
				boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
				if (idempotent) {
					// 如果请求是幂等的，就再次尝试
					return true;
				}
				return false;
			}

		};
		getBuilder().setRetryHandler(myRetryHandler);
		return this;
	}

	/**
	 * 设置线程池
	 * 
	 * @param builder
	 */
	private HttpClientConnectionPool setClientConnectionPool() {
		X509TrustManager xtm = new X509TrustManager() { // 创建TrustManager
			public void checkClientTrusted(X509Certificate[] chain,
					String authType) throws CertificateException {
			}

			public void checkServerTrusted(X509Certificate[] chain,
					String authType) throws CertificateException {
			}

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

		};

		SSLContext ctx = null;
		Registry<ConnectionSocketFactory> r = null;
		try {
			// TLS1.0与SSL3.0基本上没有太大的差别，可粗略理解为TLS是SSL的继承者，但它们使用的是相同的SSLContext
			ctx = SSLContext.getInstance("TLS");
			// 使用TrustManager来初始化该上下文，TrustManager只是被SSL的Socket所使用
			ctx.init(null, new TrustManager[] { xtm }, new SecureRandom());
			SSLContext.setDefault(ctx);
			SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
					ctx, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
			r = RegistryBuilder.<ConnectionSocketFactory> create()
					.register("http", PlainConnectionSocketFactory.INSTANCE)
					.register("https", sslsf).build();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (KeyManagementException e) {
			e.printStackTrace();
		}
		PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(
				r);
		SocketConfig socketConfig = SocketConfig.custom().setTcpNoDelay(true)
				.build();
		cm.setDefaultSocketConfig(socketConfig);
		MessageConstraints messageConstraints = MessageConstraints.custom()
				.setMaxHeaderCount(200).setMaxLineLength(2000).build();
		ConnectionConfig connectionConfig = ConnectionConfig.custom()
				.setMalformedInputAction(CodingErrorAction.IGNORE)
				.setUnmappableInputAction(CodingErrorAction.IGNORE)
				.setCharset(Consts.UTF_8)
				.setMessageConstraints(messageConstraints).build();
		cm.setDefaultConnectionConfig(connectionConfig);
		// 将最大连接数增加到200
		cm.setMaxTotal(maxTotal);
		// 将每个路由基础的连接增加到20
		cm.setDefaultMaxPerRoute(defaultMaxPerRoute);
		getBuilder().setConnectionManager(cm);
		return this;
	}

	private HttpClientConnectionPool setKeepAliveDuration() {
		ConnectionKeepAliveStrategy keepAliveStrat = new DefaultConnectionKeepAliveStrategy() {
			@Override
			public long getKeepAliveDuration(HttpResponse response,
					HttpContext context) {
				long keepAlive = super.getKeepAliveDuration(response, context);
				if (keepAlive == -1) {
					// 如果服务器没有设置keep-alive这个参数，我们就把它设置成5秒
					keepAlive = 5000;
				}
				return keepAlive;
			}

		};
		// 定制我们自己的httpclient

		getBuilder().setKeepAliveStrategy(keepAliveStrat);
		return this;

	}

	/** 关闭连接 */
	public static void colse(CloseableHttpClient client) {
		try {
			client.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

InfoUtil.java

package test;

import java.util.ResourceBundle;

/**
 * 类说明 提取指定资源文件key=>value
 */
public class InfoUtil {
	private static InfoUtil instance = null;

	private InfoUtil() {
	}

	public synchronized static InfoUtil getInstance() {
		if (instance == null) {
			instance = new InfoUtil();
		}
		return instance;
	}

	public String getInfo(String name, String key) {
		ResourceBundle rb = ResourceBundle.getBundle(name);
		return rb.getString(key);
	}
}

ParseResponse.java

package test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;

/**
 * httpResponse 内容解析
 * 
 * @author fastw
 * 
 */
public class ParseResponse {
	/**
	 * @param response
	 *            HttpResponse响应
	 * @param charset
	 *            响应编码 默认GBK
	 * @return
	 */
	public static String parse(HttpResponse response, String charset) {
		return parse(response, charset, false);
	}

	/**
	 * 理论上万能解析
	 * 
	 * @param response
	 *            HttpResponse响应
	 */
	public static String parse(HttpResponse response) {
		return parse(response, getContentCharset(response),
				getContentEncoding(response));
	}

	public static String getLocation(HttpResponse response) {
		return response.getFirstHeader("Location").getValue();
	}

	/**
	 * @param response
	 *            HttpResponse响应
	 * @param charset
	 *            响应编码 默认GBK
	 * @param isGzip
	 *            是否gzip 默认false
	 * @return
	 * @throws Exception
	 */
	public static String parse(HttpResponse response, String charset,
			boolean isGzip) {
		HttpEntity entity = response.getEntity();
		BufferedReader br = null;
		StringBuilder sb = null;
		String s = null;
		try {
			if (isGzip) {
				try {
					br = new BufferedReader(new InputStreamReader(
							new GZIPInputStream(entity.getContent()), charset));
				} catch (IOException e) {
					System.out.println("gzip" + e.getLocalizedMessage());
					br = new BufferedReader(new InputStreamReader(
							entity.getContent(), charset));
				}
			} else {
				br = new BufferedReader(new InputStreamReader(
						entity.getContent(), charset));
			}

			sb = new StringBuilder();
			String temp = null;
			while ((temp = br.readLine()) != null) {
				sb.append(temp);
			}
			s = sb.toString();
			if (s.contains("Error: The requested URL could not be checked")) {
				return null;
			}
		} catch (Exception e) {
			s = sb.toString();
		} finally {
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return s;
	}

	/** */
	/**
	 * 获取Response内容字符集
	 * 
	 * @param response
	 * @return
	 */
	public static String getContentCharset(HttpResponse response) {
		String strs = "GBK";
		Header header = response.getEntity().getContentType();
		if (header != null) {
			String s = header.getValue();
			if (matcher(s, "(charset)\\s?=\\s?(utf-?8)")) {
				strs = "utf-8";
			} else if (matcher(s, "(charset)\\s?=\\s?(gbk)")) {
				strs = "gbk";
			} else if (matcher(s, "(charset)\\s?=\\s?(gb2312)")) {
				strs = "gb2312";
			}
		}
		return strs;
	}

	public static boolean getContentEncoding(HttpResponse response) {
		Header header = response.getEntity().getContentEncoding();
		boolean b = false;
		if (header != null) {
			String s = header.getValue();
			if (s.toLowerCase().contains("gzip")) {
				b = true;
			}
		}
		return b;
	}

	/**
	 * 正则匹配
	 * 
	 * @param s
	 * @param pattern
	 * @return
	 */
	public static boolean matcher(String s, String pattern) {
		Pattern p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE
				+ Pattern.UNICODE_CASE);
		Matcher matcher = p.matcher(s);
		if (matcher.find()) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 空关闭
	 **/
	public static boolean closeResponse(HttpResponse response) {
		boolean b = false;
		try {
			response.getEntity().getContent().close();
			b = true;
		} catch (IllegalStateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return b;
	}

	/**
	 * @param response
	 *            urlconnection响应
	 * @param charset
	 *            响应编码 默认UTF-8
	 * @return
	 */
	public static String parse(URLConnection conn, String charset) {
		return parse(conn, charset, false);
	}

	/**
	 * 默认utf-8
	 * 
	 * @param response
	 *            urlconnection响应
	 */
	public static String parse(URLConnection conn) {
		return parse(conn, "UTF-8", false);
	}

	/**
	 * @param response
	 *            urlconnection响应
	 * @param charset
	 *            响应编码 默认utf-8
	 * @param isGzip
	 *            是否gzip 默认false
	 * @return
	 * @throws Exception
	 */
	public static String parse(URLConnection conn, String charset,
			boolean isGzip) {
		BufferedReader br = null;
		StringBuilder sb = null;
		try {
			if (isGzip) {
				br = new BufferedReader(new InputStreamReader(
						new GZIPInputStream(conn.getInputStream()), charset));
			} else {
				br = new BufferedReader(new InputStreamReader(
						conn.getInputStream(), charset));
			}

			sb = new StringBuilder();
			String temp = null;
			while ((temp = br.readLine()) != null) {
				sb.append(temp);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return sb.toString();
	}
}

SendRequestPojo.java

package test;

import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.config.RequestConfig.Builder;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.StringEntity;
import org.apache.http.message.BasicNameValuePair;

public class SendRequestPojo {
	/**
	 * 设置请求POST方式
	 */
	public static final int POST = 0;
	/***
	 * 设置请求GET方式
	 */
	public static final int GET = 1;
	public static final Integer socketTimeout = 20000;// 20秒
	public static final Integer connectTimeout = 20000;// 20秒

	private String url;
	private Map<String, String> params;
	/**
	 * 请求方式,get or post
	 */
	private int method;

	private CHeader header;
	/** 默认是uri请求 */
	private boolean isUri = true;

	private String xmlsOrJsonEntity;

	private Builder builder = RequestConfig.custom()
			.setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout); // httpClient
																				// 请求参数

	private String cookieSpec;

	/**
	 * 是否禁用代理
	 */
	// private boolean forbid = true;
	private HttpRequestBase uriRequest;

	public SendRequestPojo(String url) {
		this.url = url;
		this.method = GET;
	}

	public SendRequestPojo(String url, CHeader h) {
		this.url = url;
		this.header = h;
		this.method = GET;
	}

	public SendRequestPojo(String url, CHeader header, boolean isUri) {
		this.url = url;
		this.method = GET;
		this.header = header;
		this.isUri = isUri;
	}

	public SendRequestPojo(String url, Map<String, String> params) {
		this.url = url;
		this.params = params;
		this.method = POST;
	}

	public SendRequestPojo(String url, Map<String, String> params, CHeader h) {
		this.url = url;
		this.params = params;
		this.header = h;
		this.method = POST;
	}

	public SendRequestPojo(String url, Map<String, String> params,
			CHeader header, boolean isUri) {
		this.url = url;
		this.params = params;
		this.method = POST;
		this.header = header;
		this.isUri = isUri;
	}

	public String getUrl() {
		if (url != null && url.contains("<html>") && url.length() > 1030) {
			url = "";
		}
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public void setParams(Map<String, String> params) {
		this.params = params;
	}

	public int getMethod() {
		if (getXmlsOrJsonEntity() != null) {
			this.method = POST;
		}
		return method;
	}

	/**
	 * get请求or post请求 格式: Request.GET/Request.POST
	 * 
	 * @param method
	 */
	public void setMethod(int method) {
		this.method = method;
	}

	public CHeader getHeader() {
		if (header == null) {
			header = new CHeader();
		}
		return header;
	}

	public void setHeader(CHeader header) {
		this.header = header;
	}

	public boolean isUri() {
		return isUri;
	}

	public void setUri(boolean isUri) {
		this.isUri = isUri;
	}

	public String getXmlsOrJsonEntity() {
		return xmlsOrJsonEntity;
	}

	/**
	 * XML/json格式的post提交 </br> 需要通过CHeader 设置请求头信息</br> HttpPost post = new
	 * HttpPost(url);</br> StringEntity s = new StringEntity(xmls);</br>
	 * if(c.getRespCharset()!=null){</br> s.setContentEncoding("UTF-8");</br>
	 * }else{</br> s.setContentEncoding("GBK");</br> }</br>
	 * if(c.getContent_Type()!=null){</br>
	 * s.setContentType(c.getContent_Type());</br> }else{</br>
	 * s.setContentType("application/json");</br> }</br> post.setEntity(s);</br>
	 * 
	 * @param xmls
	 */
	public void setXmlsOrJsonEntity(String xmlsOrJsonEntity) {
		this.xmlsOrJsonEntity = xmlsOrJsonEntity;
	}

	/**
	 * 默认设置超时时间 如果修改请求参数可直接使用该方法set对应的参数
	 * 
	 * @return builder对象
	 */
	public Builder getBuilder() {
		if (getCookieSpec() != null) {
			builder.setCookieSpec(getCookieSpec());
		}
		return builder;
	}

	/**
	 * 禁止重定向
	 * 
	 * @return
	 */
	public Builder forbidRedirect() {
		builder.setRedirectsEnabled(false);
		return builder;
	}

	/**
	 * 默认毫秒
	 * 
	 * @param socketTimeout
	 * @param connectTimeout
	 */
	public Builder setTimeOut(int socketTimeout, int connectTimeout) {
		// setConnectionRequestTimeout(50)
		builder.setSocketTimeout(socketTimeout).setConnectTimeout(
				connectTimeout);
		return builder;
	}

	public String getCookieSpec() {
		return cookieSpec;
	}

	/**
	 * 设置cookie格式,默认CookieSpecs.BEST_MATCH
	 * 
	 * @Title: setCookieSpec
	 * @Description: CookieSpecs.BROWSER_COMPATIBILITY
	 * @param cookieSpec
	 */
	public void setCookieSpec(String cookieSpec) {
		this.cookieSpec = cookieSpec;
	}

	/**
	 * 返回request请求没有设置 RequestConfig
	 * 
	 * @return
	 */
	public HttpRequestBase getHttpRequestBase() {
		if (uriRequest == null) {
			URI uri = null;
			// 判断是uri请求还是url请求
			if (isUri()) {
				try {
					URL u = new URL(this.url);
					uri = new URI(u.getProtocol(), u.getHost(), u.getPath(),
							u.getQuery(), null);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}

			if (getMethod() == GET) {
				if (uri != null) {
					uriRequest = new HttpGet(uri);
				} else {
					uriRequest = new HttpGet(this.url);
				}
			} else {
				if (uri != null) {
					uriRequest = new HttpPost(uri);
				} else {
					uriRequest = new HttpPost(this.url);
				}
			}
			// 是否xml形式的post提交
			if (getXmlsOrJsonEntity() != null) {
				StringEntity s = null;
				try {
					s = new StringEntity(getXmlsOrJsonEntity());
				} catch (UnsupportedEncodingException e) {
					e.printStackTrace();
				}
				if (getHeader().getRespCharset() != null) {
					s.setContentEncoding("UTF-8");
				} else {
					s.setContentEncoding("GBK");
				}
				if (getHeader().getContent_Type() != null) {
					s.setContentType(getHeader().getContent_Type());
				} else {
					s.setContentType("application/json");
				}
				uriRequest.setHeader("Content-Type", s.getContentType()
						.getValue());
				putHeader(getHeader(), uriRequest);
				((HttpPost) uriRequest).setEntity(s);
			} else {
				setParam(uriRequest, getHeader(), this.params);
			}

		}
		return uriRequest;
	}

	/**
	 * 默认调用 getHttpRequestBase().abort();中止连接
	 */
	public void abort() {
		this.getHttpRequestBase().abort();
	}

	public static void putHeader(CHeader h, HttpRequestBase base) {
		// 网页头信息
		base.setHeader("Accept", h.getAccept());
		if (h.getReferer() != null) {
			base.setHeader("Referer", h.getReferer());
		}
		if (h.getAccept_Encoding() != null) {
			base.setHeader("Accept-Encoding", h.getAccept_Encoding());
		}
		if (h.getHost() != null) {
			base.setHeader("Host", h.getHost());
		}
		if (h.getCookie() != null) {
			base.setHeader("Cookie", h.getCookie());
		}
		if (h.getAccept_Language() != null) {
			base.setHeader("Accept-Language", h.getAccept_Language());
		}
		if (h.getCache_Control() != null) {
			base.setHeader("Cache-Control", h.getCache_Control());
		}
		if (h.getConnection() != null) {
			base.setHeader("Connection", h.getConnection());
		}
		if (h.getContent_Type() != null) {
			base.setHeader("Content-Type", h.getContent_Type());
		}
		if (h.getUser_Agent() != null) {
			base.setHeader("User-Agent", h.getUser_Agent());
		}

	}

	public static void setMap(Map<String, String> map, HttpPost base) {
		if (map != null) {
			List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 构建POST请求的表单参数
			for (Map.Entry<String, String> entry : map.entrySet()) {
				formParams.add(new BasicNameValuePair(entry.getKey(), entry
						.getValue()));
			}
			UrlEncodedFormEntity params = null;
			try {
				params = new UrlEncodedFormEntity(formParams, "UTF-8");
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
			base.setEntity(params);
		}
	}

	public static void setParam(HttpRequestBase base, CHeader header,
			Map<String, String> map) {
		if (header != null) {
			putHeader(header, base);
		}
		if (map != null) {
			setMap(map, (HttpPost) base);
		}
	}
}

4，测试类：Test.java

package test;

import java.util.HashMap;
import java.util.Map;

public class Test {

	public static void main(String[] args) {
		ExecuteRequest cutil = new ExecuteRequest();
		try {
			String text = cutil.get("http://www.baidu.com");
			System.out.println(text);
			Map<String, String> dxMap = new HashMap<String, String>();
			dxMap.put("checkbox", "false");
			dxMap.put("fromFlag", "doorPage");
			dxMap.put("icode", "");
			dxMap.put("isHasV", "false");
			dxMap.put("loginType", "myjsmcc");
			dxMap.put("mobile", "15101254051");
			dxMap.put("password", "809713");
			CHeader c = new CHeader();
			c.setReferer("https://gs.ac.10086.cn/login");
			c.setHost("gs.ac.10086.cn");
			SendRequestPojo pojo = new SendRequestPojo("https://gs.ac.10086.cn/popDoorPopLogonNew" , dxMap, c);
			pojo.setTimeOut(40000,40000);
			text = cutil.getResult(pojo);
			if (text != null) {
				if (text.contains("rcode:\"-7\"")) {
					
				} else if (text.contains("rcode:'-1020'")) {
					
				} else if (text.contains("rcode:\"1000\"")) {
					c.setReferer("http://www.gs.10086.cn");
					c.setHost("www.gs.10086.cn");
					c.setRespCharset("UTF-8");
					text = cutil.get("https://gs.ac.10086.cn/gsauth/ssoCookieJsonp?_1427203319699=", c);
					dxMap.put("jsonParam", "[{\"dynamicURI\":\"/userCurrentFee\",\"dynamicParameter\":{\"method\":\"queryBalance\",\"reqHandle\":\"query\",\"busiNum\":\"CX_DQYE\"},\"dynamicDataNodeName\":\"API_balInfo\"}]");
					c.setReferer("http://www.gs.10086.cn/my/myAccount.html");
					c.setRespCharset("UTF-8");
					text = cutil.post("http://www.gs.10086.cn/gs_obsh_service/actionDispatcher.do", c, dxMap);
					if (text != null && text.contains("15101254051")) {
						System.out.println(text);
					}
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("ok");
	}
}

测试结果：

地址:http://www.baidu.com响应时间:259
<!DOCTYPE html>百度页面</html>
地址:https://gs.ac.10086.cn/popDoorPopLogonNew响应时间:1503
地址:https://gs.ac.10086.cn/gsauth/ssoCookieJsonp?_1427203319699=响应时间:63
地址:http://www.gs.10086.cn/gs_obsh_service/actionDispatcher.do响应时间:791
{"API_balInfo":{"opInfo":null,"errorMessage":"","closeSmsReslutCode":"","busiErrCode":"","eventResults":[{"errorMessage":"","result":[],"busiErrCode":"","continue":true,"errorCode":"","resultCode":"9","show":true,"actionId":"","actionType":"1","showErrorMsg":""},{"errorMessage":"","result":[],"busiErrCode":"","continue":true,"errorCode":"","resultCode":"9","show":true,"actionId":"","actionType":"1","showErrorMsg":""},{"errorMessage":"","result":[],"busiErrCode":"","continue":true,"errorCode":"","resultCode":"9","show":true,"actionId":"","actionType":"1","showErrorMsg":""}],"clientCallbackInfo":null,"errorType":0,"resultCode":"1","errorCode":"","resultObj":{"specalMoneyFee":"0","qrySMIRet":[],"user":{"uid":"0","userCounty":0,"tel":"","score":"","yxfa":"999308","errorMsg":"","userType":"1","userState":"0","balance":"2937","loginSource":0,"mpoint":"","city_jbNum":"LZDQ","userName":"白红","realTimeTotalFee":"","userBrandNum":"5","channelId":"","custIcNo":"","brand_jbNum":"SZX","userApplyDate":"","feebPwdCheckFlg":"0","cookie":"LzvhVV2HD337LXZMMX1Kv8kZVJNTFCH040WXGRJlwQ3yhx79Qj99!-664121335!1427453447813","email":"","sessionId":"","contactName":"","city_busiNum":"","payType":"","cgmodelFlag":"","lateFee":"","mobile":"15101254051","enPwd":"86EA74C0D7451D","lastMonOweFee":"0","sumScoreCycle":0,"userAreaNum":"931","gprsState":"","contactAddr":"","userAreaName":"兰州地区","contactTel":"","brand_busiNum":"","loginType":"1","lastSsoActiveTime":0,"bossCode":"","mobilePwd":"A5AE9F92270A4479289B45E9BEC97BAA","feebPwdCheckRet":"","brand_jbNum_name":"神州行","custIcType":"","email_139":"","contactEmail":"","currNeedFee":"0","billRelevanceState":"","postCode":"","userCountyName":"","userEmailInfo":null,"primPwdTime":"1","ssoCookieStr":"","userSex":"1","errorCode":"","clState":"","openAccTime":"20140609124546"}},"showErrorMsg":""}}
ok