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