HTTP工具

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.net.ssl.SSLContext;

import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
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.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
/**   
 * @ClassName:     HttpUtils   
 * @Description:   http工具类
 * @author:        wl
 * @date:          2016年11月27日 下午9:00:39  
 * 本代码实现java原生的HttpsURLConnection请求   ，以及框架HttpClient
 * 本工具类为了方便单个使用，使学习者更加方便学习，因此不做代码抽取
 */  
public class HttpUtils {
    private static String ENCODED = "UTF-8";
    //请求超时时间
    private static int CONNECTTIMEOUT = 10000;
    private static int READTIMEOUT = 10000;

    //提交的类型
    private static String FORM = "form";
    private static String JSON = "json";

    /** 
    * @Title: HttpURLConnectionPost 
    * @Description: java原生HTTP post请求
    * @param @param address 请求地址
    * @param @param data    请求数据 根据Content-Type决定data的格式(普通的表单或者json)
    * @param @param property请求参数设置(类型多种) 
    * @return Map<Integer,String>    返回类型  Integer为返回的状态码，String为返回的数据
    * @throws 
    */ 
    public static Map<Integer, String> HttpURLConnectionPost(String address,String data,Map<String,String> property) throws Exception{
        //获取访问地址
        URL url = new URL(address);
        //获取连接
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        //设置连接参数
        connection.setDoInput(true);
        connection.setDoOutput(true);
        connection.setConnectTimeout(CONNECTTIMEOUT);
        connection.setReadTimeout(READTIMEOUT);
        connection.setRequestMethod("POST");
        for (Entry<String, String> pro : property.entrySet()) {
            connection.setRequestProperty(pro.getKey(), pro.getValue());
        }
        connection.connect();
        if(StringUtils.isNotEmpty(data)){
            //获取输出流
            OutputStream outputStream = connection.getOutputStream();
            outputStream.write(data.getBytes());
            outputStream.flush();
            outputStream.close();
        }
        StringBuilder builder = new StringBuilder();
        Map<Integer, String> result = new HashedMap();
        //获取返回的数据
        if (connection.getResponseCode() == 200) {
            //将返回的流输出
            builder.append(new String(getByte(connection.getInputStream()),ENCODED));
        }else {
            //将错误信息返回
            builder.append(new String(getByte(connection.getErrorStream()),ENCODED));
        }   
        result.put(connection.getResponseCode(), builder.toString());
        return result;
    }

    public static Map<Integer,String> HttpURLConnectionGet(String address,Map<String,String> property) throws Exception{
        //获取访问地址
        URL url = new URL(address);
        //获取连接
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        //设置连接参数
        connection.setDoInput(true);
        connection.setDoOutput(true);
        connection.setConnectTimeout(CONNECTTIMEOUT);
        connection.setReadTimeout(READTIMEOUT);
        connection.setRequestMethod("GET");
        //设置请求信息
        for (Entry<String, String> pro : property.entrySet()) {
            connection.setRequestProperty(pro.getKey(), pro.getValue());
        }
        connection.connect();
        StringBuilder builder = new StringBuilder();
        Map<Integer,String> result = new HashedMap();
        //获取返回的数据
        if (connection.getResponseCode() == 200) {
            //将返回的流输出
            builder.append(new String(getByte(connection.getInputStream()),ENCODED));
            System.out.println("yes++");
        }else {
            //将返错误码
            builder.append(new String(getByte(connection.getErrorStream()),ENCODED));
            System.out.println("no++");
        }       
        result.put(connection.getResponseCode(), builder.toString());
        return result;      
    }


    //httpclient
    public static Map<Integer,String> HttpClientGet(String address) throws Exception{
        //信任所有证书
        HttpClient client = createSSLClientDefault();
        HttpGet httpGet = new HttpGet(address);
        HttpResponse response = client.execute(httpGet);
        int code = response.getStatusLine().getStatusCode();
        Map<Integer,String> result = new HashedMap();
        StringBuilder builder = new StringBuilder();
        if(code==200){
            builder.append(new String(getByte(response.getEntity().getContent()),"UTF-8"));
        }else {
        }
        result.put(code, builder.toString());
        return result;
    }

    @SuppressWarnings("deprecation")
    public static Map<Integer,String> HttpClientPost(String address,String type,String json,Map<String,String> form) throws Exception{
        HttpClient client = new DefaultHttpClient();
        client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT,CONNECTTIMEOUT);//连接时间
        client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT,READTIMEOUT);//数据传输时间
        HttpPost httpPost = new HttpPost(address);
        if(type !=null && type.equals(FORM) ){
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
            //parameters 是键值对的形式
            List<NameValuePair> parameters = new ArrayList<NameValuePair>();
            for (Entry<String, String> forms : form.entrySet()) {
                parameters.add(new BasicNameValuePair(forms.getKey(), forms.getValue()));
            }
            UrlEncodedFormEntity encodedFormEntity = new UrlEncodedFormEntity(parameters,"UTF-8");
            httpPost.setEntity(encodedFormEntity);
        }
        if(type !=null && type.equals(JSON) ){
            //接收json形式的参数
            StringEntity entity = new StringEntity(json);
            entity.setContentEncoding("UTF-8");
            entity.setContentType("application/json");
            httpPost.setEntity(entity);
        }

        HttpResponse response = client.execute(httpPost);
        int code = response.getStatusLine().getStatusCode();
        Map<Integer,String> result = new HashedMap();
        StringBuilder builder = new StringBuilder();
        if(code==200){
            builder.append(new String(getByte(response.getEntity().getContent()),"UTF-8"));
        }if(code==302){
            Header header = response.getFirstHeader("Location");
            builder.append(HttpClientGet(header.toString().substring(10)).get(200));
        }else {
            //获取错误信息
            builder.append(new String(getByte(response.getEntity().getContent()),"UTF-8"));
        }
        result.put(code, builder.toString());
        return result;
    }

    public static byte[] getByte(InputStream inputStream) throws Exception{
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        int len = 0;
        byte[] b = new byte[1024];
        while ((len = inputStream.read(b))!=-1) {
            byteArrayOutputStream.write(b, 0, len);
            byteArrayOutputStream.flush();
        }
        inputStream.close();
        byteArrayOutputStream.close();
        return byteArrayOutputStream.toByteArray();
    } 

    /** 
    * @Title: createSSLClientDefault 
    * @Description: 认证所有的证书
    * @throws 
    */ 
    public static CloseableHttpClient createSSLClientDefault(){
        try {
                    SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                         //信任所有证书
                         public boolean isTrusted(X509Certificate[] chain,
                                         String authType) throws CertificateException {
                             return true;
                         }
                     }).build();
                     SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
                     return HttpClients.custom().setSSLSocketFactory(sslsf).build();
                 } catch (KeyManagementException e) {
                     e.printStackTrace();
                 } catch (NoSuchAlgorithmException e) {
                     e.printStackTrace();
                 } catch (KeyStoreException e) {
                     e.printStackTrace();
                 }
                 return  HttpClients.createDefault();
        }   
}