关于HTTP请求的那些事

使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可。

1. 创建HttpClient对象。

2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。

3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HetpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。

4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。

5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

6. 释放连接。无论执行方法是否成功，都必须释放连接

    package com.test;  
      
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.IOException;  
    import java.io.UnsupportedEncodingException;  
    import java.security.KeyManagementException;  
    import java.security.KeyStore;  
    import java.security.KeyStoreException;  
    import java.security.NoSuchAlgorithmException;  
    import java.security.cert.CertificateException;  
    import java.util.ArrayList;  
    import java.util.List;  
      
    import javax.net.ssl.SSLContext;  
      
    import org.apache.http.HttpEntity;  
    import org.apache.http.NameValuePair;  
    import org.apache.http.ParseException;  
    import org.apache.http.client.ClientProtocolException;  
    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.conn.ssl.SSLConnectionSocketFactory;  
    import org.apache.http.conn.ssl.SSLContexts;  
    import org.apache.http.conn.ssl.TrustSelfSignedStrategy;  
    import org.apache.http.entity.ContentType;  
    import org.apache.http.entity.mime.MultipartEntityBuilder;  
    import org.apache.http.entity.mime.content.FileBody;  
    import org.apache.http.entity.mime.content.StringBody;  
    import org.apache.http.impl.client.CloseableHttpClient;  
    import org.apache.http.impl.client.HttpClients;  
    import org.apache.http.message.BasicNameValuePair;  
    import org.apache.http.util.EntityUtils;  
    import org.junit.Test;  
      
    public class HttpClientTest {  
      
        @Test  
        public void jUnitTest() {  
            get();  
        }  
      
        /** 
         * HttpClient连接SSL 
         */  
        public void ssl() {  
            CloseableHttpClient httpclient = null;  
            try {  
                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());  
                FileInputStream instream = new FileInputStream(new File("d:\\tomcat.keystore"));  
                try {  
                    // 加载keyStore d:\\tomcat.keystore    
                    trustStore.load(instream, "123456".toCharArray());  
                } catch (CertificateException e) {  
                    e.printStackTrace();  
                } finally {  
                    try {  
                        instream.close();  
                    } catch (Exception ignore) {  
                    }  
                }  
                // 相信自己的CA和所有自签名的证书  
                SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()).build();  
                // 只允许使用TLSv1协议  
                SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,  
                        SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);  
                httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();  
                // 创建http请求(get方式)  
                HttpGet httpget = new HttpGet("https://localhost:8443/myDemo/Ajax/serivceJ.action");  
                System.out.println("executing request" + httpget.getRequestLine());  
                CloseableHttpResponse response = httpclient.execute(httpget);  
                try {  
                    HttpEntity entity = response.getEntity();  
                    System.out.println("----------------------------------------");  
                    System.out.println(response.getStatusLine());  
                    if (entity != null) {  
                        System.out.println("Response content length: " + entity.getContentLength());  
                        System.out.println(EntityUtils.toString(entity));  
                        EntityUtils.consume(entity);  
                    }  
                } finally {  
                    response.close();  
                }  
            } catch (ParseException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } catch (KeyManagementException e) {  
                e.printStackTrace();  
            } catch (NoSuchAlgorithmException e) {  
                e.printStackTrace();  
            } catch (KeyStoreException e) {  
                e.printStackTrace();  
            } finally {  
                if (httpclient != null) {  
                    try {  
                        httpclient.close();  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  
      
        /** 
         * post方式提交表单（模拟用户登录请求） 
         */  
        public void postForm() {  
            // 创建默认的httpClient实例.    
            CloseableHttpClient httpclient = HttpClients.createDefault();  
            // 创建httppost    
            HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");  
            // 创建参数队列    
            List<namevaluepair> formparams = new ArrayList<namevaluepair>();  
            formparams.add(new BasicNameValuePair("username", "admin"));  
            formparams.add(new BasicNameValuePair("password", "123456"));  
            UrlEncodedFormEntity uefEntity;  
            try {  
                uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");  
                httppost.setEntity(uefEntity);  
                System.out.println("executing request " + httppost.getURI());  
                CloseableHttpResponse response = httpclient.execute(httppost);  
                try {  
                    HttpEntity entity = response.getEntity();  
                    if (entity != null) {  
                        System.out.println("--------------------------------------");  
                        System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));  
                        System.out.println("--------------------------------------");  
                    }  
                } finally {  
                    response.close();  
                }  
            } catch (ClientProtocolException e) {  
                e.printStackTrace();  
            } catch (UnsupportedEncodingException e1) {  
                e1.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                // 关闭连接,释放资源    
                try {  
                    httpclient.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
      
        /** 
         * 发送 post请求访问本地应用并根据传递参数不同返回不同结果 
         */  
        public void post() {  
            // 创建默认的httpClient实例.    
            CloseableHttpClient httpclient = HttpClients.createDefault();  
            // 创建httppost    
            HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");  
            // 创建参数队列    
            List<namevaluepair> formparams = new ArrayList<namevaluepair>();  
            formparams.add(new BasicNameValuePair("type", "house"));  
            UrlEncodedFormEntity uefEntity;  
            try {  
                uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");  
                httppost.setEntity(uefEntity);  
                System.out.println("executing request " + httppost.getURI());  
                CloseableHttpResponse response = httpclient.execute(httppost);  
                try {  
                    HttpEntity entity = response.getEntity();  
                    if (entity != null) {  
                        System.out.println("--------------------------------------");  
                        System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));  
                        System.out.println("--------------------------------------");  
                    }  
                } finally {  
                    response.close();  
                }  
            } catch (ClientProtocolException e) {  
                e.printStackTrace();  
            } catch (UnsupportedEncodingException e1) {  
                e1.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                // 关闭连接,释放资源    
                try {  
                    httpclient.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
      
        /** 
         * 发送 get请求 
         */  
        public void get() {  
            CloseableHttpClient httpclient = HttpClients.createDefault();  
            try {  
                // 创建httpget.    
                HttpGet httpget = new HttpGet("http://www.baidu.com/");  
                System.out.println("executing request " + httpget.getURI());  
                // 执行get请求.    
                CloseableHttpResponse response = httpclient.execute(httpget);  
                try {  
                    // 获取响应实体    
                    HttpEntity entity = response.getEntity();  
                    System.out.println("--------------------------------------");  
                    // 打印响应状态    
                    System.out.println(response.getStatusLine());  
                    if (entity != null) {  
                        // 打印响应内容长度    
                        System.out.println("Response content length: " + entity.getContentLength());  
                        // 打印响应内容    
                        System.out.println("Response content: " + EntityUtils.toString(entity));  
                    }  
                    System.out.println("------------------------------------");  
                } finally {  
                    response.close();  
                }  
            } catch (ClientProtocolException e) {  
                e.printStackTrace();  
            } catch (ParseException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                // 关闭连接,释放资源    
                try {  
                    httpclient.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
      
        /** 
         * 上传文件 
         */  
        public void upload() {  
            CloseableHttpClient httpclient = HttpClients.createDefault();  
            try {  
                HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceFile.action");  
      
                FileBody bin = new FileBody(new File("F:\\image\\sendpix0.jpg"));  
                StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);  
      
                HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();  
      
                httppost.setEntity(reqEntity);  
      
                System.out.println("executing request " + httppost.getRequestLine());  
                CloseableHttpResponse response = httpclient.execute(httppost);  
                try {  
                    System.out.println("----------------------------------------");  
                    System.out.println(response.getStatusLine());  
                    HttpEntity resEntity = response.getEntity();  
                    if (resEntity != null) {  
                        System.out.println("Response content length: " + resEntity.getContentLength());  
                    }  
                    EntityUtils.consume(resEntity);  
                } finally {  
                    response.close();  
                }  
            } catch (ClientProtocolException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    httpclient.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }

（2）使用JDK自带特性

package net.parse.tool;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.CookieManager;
import java.net.CookieStore;
import java.net.HttpCookie;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.util.List;
import java.util.Map;

public class HttpTools {
	/**
	 * 返回响应头信息
	 * @param url
	 * @return
	 */
	public static String GetHttpHeader(String url,String referer){
			String result = "";
			try {
				URL u = new URL(url);
				HttpURLConnection conn = (HttpURLConnection)u.openConnection();
				conn.setRequestMethod("GET"); 
				conn.addRequestProperty("Referer", referer);
				conn.setRequestProperty("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/600.1.3 (KHTML, like Gecko) Version/8.0 Mobile/12A4345d Safari/600.1.4");
				//必须设置false，否则会自动redirect到重定向后的地址 
	            conn.setInstanceFollowRedirects(false);
	            conn.connect();
	            if (conn.getResponseCode() == 302 || conn.getResponseCode() == 301) { 
	                //如果会重定向，保存302重定向地址，以及Cookies,然后重新发送请求(模拟请求)
	                result = conn.getHeaderField("Location"); 
	            //    Map<String, List<String>> map = conn.getHeaderFields();
	        //        for (String key : map.keySet()) {
	        //        	System.out.println(key+"    ----->"+ map.get(key));
	        //        }
	        //        GetHttpHeader(result,"");
	            }
	            
			} catch (Exception e) {
				e.printStackTrace();
			}
			return result;
	}
	
	/**
	 * 获取网站返回内容
	 * @param url
	 * @return
	 */
	public static String Getcode(String url,String encode,String referer){
		if(encode==""){encode="UTF-8";}
		String result = "";
		String temp="";
		try {
			URL u = new URL(url);
			HttpURLConnection conn = (HttpURLConnection)u.openConnection();
			conn.setRequestProperty("Referer", referer);
			conn.setRequestProperty("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1");
            InputStreamReader isr = new InputStreamReader(conn.getInputStream(),encode);
            BufferedReader br = new BufferedReader(isr);  
            while((temp = br.readLine()) != null){  
			result +=temp+"\n";
			}
           if (isr!=null) {
        	   isr.close();
           }
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	
	 /**
     * 向指定 URL 发送POST方法的请求
     * 
     * @param url
     *            发送请求的 URL
     * @param param
     *            请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendPost(String url, String param,String referer,String Cookies) {
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("Accept", "*/*");
//            conn.setRequestProperty("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8");
            conn.setRequestProperty("Connection", "Keep-Alive");
            conn.setRequestProperty("User-Agent","Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.76 Mobile Safari/537.36");
            conn.setRequestProperty("Cookie", Cookies);
            conn.setRequestProperty("Referer", referer);
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // 获取URLConnection对象对应的输出流
            out = new PrintWriter(conn.getOutputStream());
            // 发送请求参数
            out.print(param);
            // flush输出流的缓冲
            out.flush();
            // 定义BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line+"\n";
            }
        } catch (Exception e) {
            System.out.println("发送 POST 请求出现异常！"+e);
            e.printStackTrace();
        }
        //使用finally块来关闭输出流、输入流
        finally{
            try{
                if(out!=null){
                    out.close();
                }
                if(in!=null){
                    in.close();
                }
            }
            catch(IOException ex){
                ex.printStackTrace();
            }
        }
        return result;
    }    
	
}

package net.parse.tool;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;




public class HttpsTools {
	/**
	 * 获取网站返回内容
	 * @param url
	 * @return
	 */
	public static String Getcode(String requsturl,String requestMethod,String encode,String referer,String outputStr){
        StringBuffer buffer = new StringBuffer();
        if (null==requestMethod) {
        	requestMethod="GET";
		}
        if(encode==null){
        	encode="UTF-8";
        }
		 try {  
	            // 创建SSLContext对象，并使用我们指定的信任管理器初始化  
	            TrustManager[] tm = { new MyX509TrustManager() };  
	            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");  
	            sslContext.init(null, tm, new java.security.SecureRandom());  
	            // 从上述SSLContext对象中得到SSLSocketFactory对象  
	            SSLSocketFactory ssf = sslContext.getSocketFactory();  
	  
	            URL url = new URL(requsturl);  
	            HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();  
	            httpUrlConn.setSSLSocketFactory(ssf);  
	            httpUrlConn.setRequestProperty("referer", referer);
	            httpUrlConn.setDoOutput(true);  
	            httpUrlConn.setDoInput(true);  
	            httpUrlConn.setUseCaches(false);  
	            // 设置请求方式（GET/POST）  
	            httpUrlConn.setRequestMethod(requestMethod);  
	  
	            if ("GET".equalsIgnoreCase(requestMethod))  
	                httpUrlConn.connect();  
	  
	            // 当有数据需要提交时  
	            if (null != outputStr) {  
	                OutputStream outputStream = httpUrlConn.getOutputStream();  
	                // 注意编码格式，防止中文乱码  
	                outputStream.write(outputStr.getBytes(encode));  
	                outputStream.close();  
	            }  
	  
	            // 将返回的输入流转换成字符串  
	            InputStream inputStream = httpUrlConn.getInputStream();  
	            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, encode);  
	            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);  
	  
	            String str = null;  
	            while ((str = bufferedReader.readLine()) != null) {  
	                buffer.append(str+"\n");  
	            }  
	            bufferedReader.close();  
	            inputStreamReader.close();  
	            // 释放资源  
	            inputStream.close();  
	            inputStream = null;  
	            httpUrlConn.disconnect();  
	  
	        } catch (Exception e) {  
	            e.printStackTrace();
	        }  
	        return buffer.toString();  
  
	}
	
}