HttpClient4.3 第二次封装

httpclient.java

package com.httpclint.util;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.http.HttpException;
import org.apache.http.entity.mime.content.ByteArrayBody;
import org.apache.http.entity.mime.content.FileBody;

/**
 * HTTP工具类，封装HttpClient4.3.x来对外提供简化的HTTP请求
 * @author   yangjian1004
 * @Date     Aug 5, 2014     
 */
public class HttpClient {

	private HttpProxy proxy;

	/**
	 * 设置代理访问网络
	 * @param proxy
	 */
	public void setProxy(HttpProxy proxy) {
		this.proxy = proxy;
	}

	/**
	 * 是否启用SSL模式
	 * @param enabled
	 */
	public void enableSSL(boolean enabled) {
		HttpClientWrapper.enabledSSL(enabled);
	}

	/**
	 * 使用Get方式 根据URL地址，获取ResponseStatus对象
	 * 
	 * @param url
	 *            完整的URL地址
	 * @return ResponseStatus 如果发生异常则返回null，否则返回ResponseStatus对象
	 * @throws IOException 
	 * @throws HttpException 
	 */
	public ResponseStatus get(String url) throws HttpException, IOException {
		HttpClientWrapper hw = new HttpClientWrapper(proxy);
		return hw.sendRequest(url);
	}

	/**
	 * 使用Get方式 根据URL地址，获取ResponseStatus对象
	 * 
	 * @param url
	 *            完整的URL地址
	 * @param urlEncoding
	 *            编码，可以为null
	 * @return ResponseStatus 如果发生异常则返回null，否则返回ResponseStatus对象
	 */
	public ResponseStatus get(String url, String urlEncoding) {
		HttpClientWrapper hw = new HttpClientWrapper(proxy);
		ResponseStatus response = null;
		try {
			response = hw.sendRequest(url, urlEncoding);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return response;
	}

	/**
	 * 将参数拼装在url中，进行post请求。
	 * 
	 * @param url
	 * @return
	 */
	public ResponseStatus post(String url) {
		HttpClientWrapper hw = new HttpClientWrapper(proxy);
		ResponseStatus ret = null;
		try {
			setParams(url, hw);
			ret = hw.postNV(url);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return ret;
	}

	private void setParams(String url, HttpClientWrapper hw) {
		String[] paramStr = url.split("[?]", 2);
		if (paramStr == null || paramStr.length != 2) {
			return;
		}
		String[] paramArray = paramStr[1].split("[&]");
		if (paramArray == null) {
			return;
		}
		for (String param : paramArray) {
			if (param == null || "".equals(param.trim())) {
				continue;
			}
			String[] keyValue = param.split("[=]", 2);
			if (keyValue == null || keyValue.length != 2) {
				continue;
			}
			hw.addNV(keyValue[0], keyValue[1]);
		}
	}

	/**
	 * 上传文件（包括图片）
	 * 
	 * @param url
	 *            请求URL
	 * @param paramsMap
	 *            参数和值
	 * @return
	 */
	public ResponseStatus post(String url, Map<String, Object> paramsMap) {
		HttpClientWrapper hw = new HttpClientWrapper(proxy);
		ResponseStatus ret = null;
		try {
			setParams(url, hw);
			Iterator<String> iterator = paramsMap.keySet().iterator();
			while (iterator.hasNext()) {
				String key = iterator.next();
				Object value = paramsMap.get(key);
				if (value instanceof File) {
					FileBody fileBody = new FileBody((File) value);
					hw.getContentBodies().add(fileBody);
				} else if (value instanceof byte[]) {
					byte[] byteVlue = (byte[]) value;
					ByteArrayBody byteArrayBody = new ByteArrayBody(byteVlue, key);
					hw.getContentBodies().add(byteArrayBody);
				} else {
					if (value != null && !"".equals(value)) {
						hw.addNV(key, String.valueOf(value));
					} else {
						hw.addNV(key, "");
					}
				}
			}
			ret = hw.postEntity(url);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return ret;
	}

	/**
	 * 使用post方式，发布对象转成的json给Rest服务。
	 * 
	 * @param url
	 * @param jsonBody
	 * @return
	 */
	public ResponseStatus post(String url, String jsonBody) {
		return post(url, jsonBody, "application/json");
	}

	/**
	 * 使用post方式，发布对象转成的xml给Rest服务
	 * 
	 * @param url
	 *            URL地址
	 * @param xmlBody
	 *            xml文本字符串
	 * @return ResponseStatus 如果发生异常则返回空，否则返回ResponseStatus对象
	 */
	public ResponseStatus postXml(String url, String xmlBody) {
		return post(url, xmlBody, "application/xml");
	}

	private ResponseStatus post(String url, String body, String contentType) {
		HttpClientWrapper hw = new HttpClientWrapper(proxy);
		ResponseStatus ret = null;
		try {
			hw.addNV("body", body);
			ret = hw.postNV(url, contentType);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return ret;
	}

	public static void main(String[] args) throws HttpException, IOException {
		testGet();
		//testUploadFile();
	}

	//test
	public static void testGet() throws HttpException, IOException {
		String url = "http://www.baidu.com/";
		HttpClient c = new HttpClient();
		ResponseStatus r = c.get(url);
		System.out.println(r.getContent());
	}

	//test
	public static void testUploadFile() {
		try {
			HttpClient c = new HttpClient();
			String url = "http://localhost:8280/jfly/action/admin/user/upload.do";
			Map<String, Object> paramsMap = new HashMap<String, Object>();
			paramsMap.put("userName", "jj");
			paramsMap.put("password", "jj");
			paramsMap.put("filePath", new File("C:\\Users\\yangjian1004\\Pictures\\default (1).jpeg"));
			ResponseStatus ret = c.post(url, paramsMap);
			System.out.println(ret.getContent());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package com.httpclint.util;

import java.io.IOException;
import java.net.URLEncoder;
import java.nio.charset.CodingErrorAction;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

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

import org.apache.http.Consts;
import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpException;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpHost;
import org.apache.http.NameValuePair;
import org.apache.http.StatusLine;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
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.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.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.ContentBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.CharsetUtils;
import org.apache.http.util.EntityUtils;

/**
 * 封装HttpClient
 * <p>
 * @author   yangjian1004
 * @Date     Aug 5, 2014     
 */
public class HttpClientWrapper {

	private enum HttpMethod {
		GET, POST
	}

	private static CloseableHttpClient client;
	private List<ContentBody> contentBodies;
	private List<NameValuePair> nameValuePostBodies;
	private static PoolingHttpClientConnectionManager connManager = null;
	
	
	public static void enabledSSL(boolean enabled) {
		if (enabled) {
			try {
				SSLContext sslContext = SSLContexts.custom().useTLS().build();
				sslContext.init(null, new TrustManager[] { new X509TrustManager() {

					public void checkClientTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
							throws CertificateException {
					}

					public void checkServerTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
							throws CertificateException {
					}

					public X509Certificate[] getAcceptedIssuers() {
						return null;
					}
				} }, null);
				Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
						.<ConnectionSocketFactory> create().register("http", PlainConnectionSocketFactory.INSTANCE)
						.register("https", new SSLConnectionSocketFactory(sslContext)).build();
				connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
				SocketConfig socketConfig = SocketConfig.custom().setTcpNoDelay(true).build();
				connManager.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();
				connManager.setDefaultConnectionConfig(connectionConfig);
				connManager.setMaxTotal(200);
				connManager.setDefaultMaxPerRoute(20);
			} catch (KeyManagementException e) {

			} catch (NoSuchAlgorithmException e) {

			}
		}
	}

	public HttpClientWrapper(HttpProxy proxy) {
		super();
		//client                 = HttpClientBuilder.create().build();//不使用连接池
		client = this.getCloseableHttpClient(proxy);
		this.contentBodies = new ArrayList<ContentBody>();
		this.nameValuePostBodies = new LinkedList<NameValuePair>();
	}

	private CloseableHttpClient getCloseableHttpClient(HttpProxy proxy) {
		if (null != proxy) {
			HttpHost proxyHost = new HttpHost(proxy.getHost(), proxy.getPort());
			CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
			if (null != proxy.getUser() && null != proxy.getPassword()) {
				credentialsProvider.setCredentials(new AuthScope(proxy.getHost(), proxy.getPort()),
						new UsernamePasswordCredentials(proxy.getUser(), proxy.getPassword()));
			}
			return HttpClients.custom().setProxy(proxyHost).setDefaultCredentialsProvider(credentialsProvider).build();
		} else {
			return HttpClients.custom().setConnectionManager(connManager).build();
		}
	}

	/**
	 * Get方式访问URL
	 * 
	 * @param url
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public ResponseStatus sendRequest(String url) throws HttpException, IOException {
		return this.sendRequest(url, "UTF-8", HttpMethod.GET, null);
	}

	/**
	 * Get方式访问URL
	 * 
	 * @param url
	 * @param urlEncoding
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public ResponseStatus sendRequest(String url, String urlEncoding) throws HttpException, IOException {
		return this.sendRequest(url, urlEncoding, HttpMethod.GET, null);
	}

	/**
	 * POST方式发送名值对请求URL
	 * 
	 * @param url
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public ResponseStatus postNV(String url) throws HttpException, IOException {
		return this.sendRequest(url, "UTF-8", HttpMethod.POST, null);
	}

	public ResponseStatus postNV(String url, String contentType) throws HttpException, IOException {
		return sendRequest(url, "UTF-8", HttpMethod.POST, contentType);
	}

	/**
	 * 根据url编码，请求方式，请求URL
	 * 
	 * @param urlstr
	 * @param urlEncoding
	 * @param bodyType
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public ResponseStatus sendRequest(String urlstr, String urlEncoding, HttpMethod bodyType, String contentType)
			throws HttpException, IOException {

		if (urlstr == null)
			return null;

		String url = urlstr;
		if (urlEncoding != null)
			url = HttpClientWrapper.encodeURL(url.trim(), urlEncoding);
		
		HttpEntity entity = null;
		HttpRequestBase request = null;
		CloseableHttpResponse response = null;
		try {
			if (HttpMethod.GET == bodyType) {
				request = new HttpGet(url);
			} else if (HttpMethod.POST == bodyType) {
				this.parseUrl(url);
				HttpPost httpPost = new HttpPost(toUrl());
				List<NameValuePair> nvBodyList = this.getNVBodies();
				httpPost.setEntity(new UrlEncodedFormEntity(nvBodyList, urlEncoding));
				request = httpPost;
			}

			if (contentType != null) {
				request.addHeader(HttpHeaders.CONTENT_TYPE, contentType);
			}
			
			//setTimeOut(request, timeout);
			request.addHeader(HttpHeaders.USER_AGENT,
					"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)");

			response = client.execute(request);
			entity = response.getEntity(); // 获取响应实体
			StatusLine statusLine = response.getStatusLine();
			ResponseStatus ret = new ResponseStatus();
			ret.setStatusCode(statusLine.getStatusCode());
			ret.setEncoding(urlEncoding);
			getResponseStatus(entity, ret);
			return ret;
		} finally {
			close(entity, request, response);
		}
	}
	
	private void getResponseStatus(HttpEntity entity, ResponseStatus ret) throws IOException {
		Header enHeader = entity.getContentEncoding();
		if (enHeader != null) {
			String charset = enHeader.getValue().toLowerCase();
			ret.setEncoding(charset);
		}
		String contenttype = this.getResponseStatusType(entity);
		ret.setContentType(contenttype);
		ret.setContentTypeString(this.getResponseStatusTypeString(entity));
		ret.setContentBytes(EntityUtils.toByteArray(entity));
	}

	public ResponseStatus postEntity(String url) throws HttpException, IOException {
		return this.postEntity(url, "UTF-8");
	}

	/**
	 * POST方式发送名值对请求URL,上传文件（包括图片）
	 * 
	 * @param url
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public ResponseStatus postEntity(String url, String urlEncoding) throws HttpException, IOException {
		if (url == null)
			return null;

		HttpEntity entity = null;
		HttpRequestBase request = null;
		CloseableHttpResponse response = null;
		try {
			this.parseUrl(url);
			HttpPost httpPost = new HttpPost(toUrl());

			//对请求的表单域进行填充  
			MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();
			entityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
			for (NameValuePair nameValuePair : this.getNVBodies()) {
				entityBuilder.addPart(nameValuePair.getName(),
						new StringBody(nameValuePair.getValue(), ContentType.create("text/plain", urlEncoding)));
			}
			for (ContentBody contentBody : getContentBodies()) {
				entityBuilder.addPart("file", contentBody);
			}
			entityBuilder.setCharset(CharsetUtils.get(urlEncoding));
			httpPost.setEntity(entityBuilder.build());
			request = httpPost;
			response = client.execute(request);

			//响应状态
			StatusLine statusLine = response.getStatusLine();
			// 获取响应对象
			entity = response.getEntity();
			ResponseStatus ret = new ResponseStatus();
			ret.setStatusCode(statusLine.getStatusCode());
			getResponseStatus(entity, ret);
			return ret;
		} finally {
			close(entity, request, response);
		}
	}

	private void close(HttpEntity entity, HttpRequestBase request, CloseableHttpResponse response) throws IOException {
		if (request != null)
			request.releaseConnection();
		if (entity != null)
			entity.getContent().close();
		if (response != null)
			response.close();
	}

	public NameValuePair[] getNVBodyArray() {
		List<NameValuePair> list = this.getNVBodies();
		if (list == null || list.isEmpty())
			return null;
		NameValuePair[] nvps = new NameValuePair[list.size()];
		Iterator<NameValuePair> it = list.iterator();
		int count = 0;
		while (it.hasNext()) {
			NameValuePair nvp = it.next();
			nvps[count++] = nvp;
		}
		return nvps;
	}

	public List<NameValuePair> getNVBodies() {
		return Collections.unmodifiableList(this.nameValuePostBodies);
	}

	private String getResponseStatusType(HttpEntity method) {
		Header contenttype = method.getContentType();
		if (contenttype == null)
			return null;
		String ret = null;
		try {
			HeaderElement[] hes = contenttype.getElements();
			if (hes != null && hes.length > 0) {
				ret = hes[0].getName();
			}
		} catch (Exception e) {
		}
		return ret;
	}

	private String getResponseStatusTypeString(HttpEntity method) {
		Header contenttype = method.getContentType();
		if (contenttype == null)
			return null;
		return contenttype.getValue();
	}

	static Set<Character> BEING_ESCAPED_CHARS = new HashSet<Character>();
	static {
		char[] signArray = { ' ', '\\', '‘', ']', '!', '^', '#', '`', '$', '{', '%', '|', '}', '(', '+', ')', '<', '>',
				';', '[' };
		for (int i = 0; i < signArray.length; i++) {
			BEING_ESCAPED_CHARS.add(new Character(signArray[i]));
		}
	}

	public static String encodeURL(String url, String encoding) {
		if (url == null)
			return null;
		if (encoding == null)
			return url;

		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < url.length(); i++) {
			char c = url.charAt(i);
			if (c == 10) {
				continue;
			} else if (BEING_ESCAPED_CHARS.contains(new Character(c)) || c == 13 || c > 126) {
				try {
					sb.append(URLEncoder.encode(String.valueOf(c), encoding));
				} catch (Exception e) {
					sb.append(c);
				}
			} else {
				sb.append(c);
			}
		}
		return sb.toString().replaceAll("\\+", "%20");
	}

	private String protocol;
	private String host;
	private int port;
	private String dir;
	private String uri;
	private final static int DefaultPort = 80;
	private final static String ProtocolSeparator = "://";
	private final static String PortSeparator = ":";
	private final static String HostSeparator = "/";
	private final static String DirSeparator = "/";

	private void parseUrl(String url) {
		this.protocol = null;
		this.host = null;
		this.port = DefaultPort;
		this.dir = "/";
		this.uri = dir;

		if (url == null || url.length() == 0)
			return;
		String u = url.trim();
		boolean MeetProtocol = false;
		int pos = u.indexOf(ProtocolSeparator);
		if (pos > 0) {
			MeetProtocol = true;
			this.protocol = u.substring(0, pos);
			pos += ProtocolSeparator.length();
		}
		int posStartDir = 0;
		if (MeetProtocol) {
			int pos2 = u.indexOf(PortSeparator, pos);
			if (pos2 > 0) {
				this.host = u.substring(pos, pos2);
				pos2 = pos2 + PortSeparator.length();
				int pos3 = u.indexOf(HostSeparator, pos2);
				String PortStr = null;
				if (pos3 > 0) {
					PortStr = u.substring(pos2, pos3);
					posStartDir = pos3;
				} else {
					int pos4 = u.indexOf("?");
					if (pos4 > 0) {
						PortStr = u.substring(pos2, pos4);
						posStartDir = -1;
					} else {
						PortStr = u.substring(pos2);
						posStartDir = -1;
					}
				}
				try {
					this.port = Integer.parseInt(PortStr);
				} catch (Exception e) {
				}
			} else {
				pos2 = u.indexOf(HostSeparator, pos);
				if (pos2 > 0) {
					this.host = u.substring(pos, pos2);
					posStartDir = pos2;
				} else {
					this.host = u.substring(pos);
					posStartDir = -1;
				}
			}

			pos = u.indexOf(HostSeparator, pos);
			pos2 = u.indexOf("?");
			if (pos > 0 && pos2 > 0) {
				this.uri = u.substring(pos, pos2);
			} else if (pos > 0 && pos2 < 0) {
				this.uri = u.substring(pos);
			}
		}

		if (posStartDir >= 0) {
			int pos2 = u.lastIndexOf(DirSeparator, posStartDir);
			if (pos2 > 0) {
				this.dir = u.substring(posStartDir, pos2 + 1);
			}
		}

	}

	private String toUrl() {
		StringBuffer ret = new StringBuffer();
		if (this.protocol != null) {
			ret.append(this.protocol);
			ret.append(ProtocolSeparator);
			if (this.host != null)
				ret.append(this.host);
			if (this.port != DefaultPort) {
				ret.append(PortSeparator);
				ret.append(this.port);
			}
		}
		ret.append(this.uri);
		return ret.toString();
	}

	public void addNV(String name, String value) {
		BasicNameValuePair nvp = new BasicNameValuePair(name, value);
		this.nameValuePostBodies.add(nvp);
	}

	public void clearNVBodies() {
		this.nameValuePostBodies.clear();
	}

	public List<ContentBody> getContentBodies() {
		return contentBodies;
	}

}

package com.httpclint.util;

public class HttpProxy {

	private String host;
	private int port;
	private String user;
	private String password;

	public HttpProxy(String ipAndPort) {
		this.host = ipAndPort.split(":")[0];
		this.port = Integer.parseInt(ipAndPort.split(":")[1]);
	}

	public HttpProxy(String host, int port) {
		super();
		this.host = host;
		this.port = port;
	}

	public HttpProxy(String host, int port, String user, String password) {
		super();
		this.host = host;
		this.port = port;
		this.user = user;
		this.password = password;
	}

	public String getHost() {
		return host;
	}

	public void setHost(String host) {
		this.host = host;
	}

	public int getPort() {
		return port;
	}

	public void setPort(int port) {
		this.port = port;
	}

	public String getUser() {
		return user;
	}

	public void setUser(String user) {
		this.user = user;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

}

package com.httpclint.util;
 
import java.io.UnsupportedEncodingException;
 
/**
 * 封装HttpClient返回数据
 * <p>
 * @author   yangjian1004
 * @Date     Aug 5, 2014     
 */
public class ResponseStatus {
	
    private String encoding;
 
    private byte[] contentBytes;
 
    private int statusCode;
 
    private String contentType;
 
    private String contentTypeString;
 
    public String getEncoding() {
        return encoding;
    }
 
    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }
 
    public String getContentType() {
        return this.contentType;
    }
 
    public void setContentType(String contentType) {
        this.contentType = contentType;
    }
 
    public String getContentTypeString() {
        return this.contentTypeString;
    }
 
    public void setContentTypeString(String contenttypeString) {
        this.contentTypeString = contenttypeString;
    }
 
    public String getContent() throws UnsupportedEncodingException {
        return this.getContent(this.encoding);
    }
 
    public String getContent(String encoding) throws UnsupportedEncodingException {
        if (encoding == null) {
            return new String(contentBytes);
        }
        return new String(contentBytes, encoding);
    }
 
    public String getUTFContent() throws UnsupportedEncodingException {
        return this.getContent("UTF-8");
    }
 
    public byte[] getContentBytes() {
        return contentBytes;
    }
 
    public void setContentBytes(byte[] contentBytes) {
        this.contentBytes = contentBytes;
    }
 
    public int getStatusCode() {
        return statusCode;
    }
 
    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }
 
}

http://download.csdn.net/detail/jelly_8090/7923537