Java 使用HttpClient进行模拟请求

阳光穿透心脏的1/2处 2021-09-27 06:30 709阅读 0赞

一、 环境

jdk版本： jdk1.8+

HttpClient版本： httpClient4.5+

推荐一个Java学习的网站 ： http://how2j.cn?p=17361

二、 下载jar包

1、 下载HttpClient的jar包，在apache官网

  1.    **下载地址**： [http://hc.apache.org/downloads.cgi][http_hc.apache.org_downloads.cgi]

三、 使用步骤（转）

  1. 创建HttpClient对象，HttpClients.createDefault()。
  2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象，HttpPost httpPost = new HttpPost(url)。
  3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HetpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。List valuePairs = new LinkedList();valuePairs.add(new BasicNameValuePair(entry.getKey(),entry.getValue()))；httpPost.setEntity(formEntity)。
  4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。
  5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

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

    HttpClient在4.3版本以后声明HttpClient的方法和以前略有区别，不再是直接声明new DefaultHttpClient() .

四、 代码示例

  1. package util;
  3. import org.apache.http.*;
  4. import org.apache.http.client.ClientProtocolException;
  5. import org.apache.http.client.CookieStore;
  6. import org.apache.http.client.HttpClient;
  7. import org.apache.http.client.config.CookieSpecs;
  8. import org.apache.http.client.config.RequestConfig;
  9. import org.apache.http.client.entity.UrlEncodedFormEntity;
  10. import org.apache.http.client.methods.CloseableHttpResponse;
  11. import org.apache.http.client.methods.HttpGet;
  12. import org.apache.http.client.methods.HttpPost;
  13. import org.apache.http.client.protocol.HttpClientContext;
  14. import org.apache.http.config.Registry;
  15. import org.apache.http.config.RegistryBuilder;
  16. import org.apache.http.conn.socket.ConnectionSocketFactory;
  17. import org.apache.http.conn.socket.PlainConnectionSocketFactory;
  18. import org.apache.http.conn.ssl.NoopHostnameVerifier;
  19. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  20. import org.apache.http.cookie.Cookie;
  21. import org.apache.http.impl.client.BasicCookieStore;
  22. import org.apache.http.impl.client.CloseableHttpClient;
  23. import org.apache.http.impl.client.HttpClientBuilder;
  24. import org.apache.http.impl.client.HttpClients;
  25. import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  26. import org.apache.http.message.BasicHeader;
  27. import org.apache.http.message.BasicNameValuePair;
  28. import org.apache.http.ssl.SSLContextBuilder;
  29. import org.apache.http.ssl.TrustStrategy;
  30. import org.apache.http.util.EntityUtils;
  32. import javax.net.ssl.SSLContext;
  33. import javax.net.ssl.TrustManager;
  34. import javax.net.ssl.X509TrustManager;
  35. import java.io.*;
  36. import java.security.KeyManagementException;
  37. import java.security.KeyStoreException;
  38. import java.security.NoSuchAlgorithmException;
  39. import java.security.cert.CertificateException;
  40. import java.security.cert.X509Certificate;
  41. import java.util.ArrayList;
  42. import java.util.HashMap;
  43. import java.util.List;
  44. import java.util.Map;
  45. import java.util.concurrent.TimeUnit;
  47. /**
  48.  * 模拟请求工具类
  49.  */
  50. public class HttpUtil {
  52.     /**
  53.      * http get请求
  54.      *
  55.      * @param url
  56.      * @return
  57.      */
  58.     public static String httpGet(String url) throws IOException, ClassNotFoundException, NoSuchAlgorithmException, KeyStoreException, KeyManagementException {
  59.         return httpGet(url, null, false);
  60.     }
  62.     /**、
  63.      * https get 请求
  64.      * @param url
  65.      * @return
  66.      * @throws ClassNotFoundException
  67.      * @throws KeyManagementException
  68.      * @throws NoSuchAlgorithmException
  69.      * @throws KeyStoreException
  70.      * @throws IOException
  71.      */
  72.     public static String httpsGet(String url) throws ClassNotFoundException, KeyManagementException, NoSuchAlgorithmException, KeyStoreException, IOException {
  73.         return httpGet(url, null, true);
  74.     }
  76.     /**
  77.      * http post 请求
  78.      * @param url
  79.      * @param params
  80.      * @return
  81.      * @throws NoSuchAlgorithmException
  82.      * @throws KeyStoreException
  83.      * @throws KeyManagementException
  84.      */
  85.     public static String httpPost(String url, HashMap<String, String> params) throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException, IOException {
  86.         return httpPost(url, params, null, false);
  87.     }
  89.     /**
  90.      * https post 请求
  91.      * @param url
  92.      * @param params
  93.      * @return
  94.      * @throws NoSuchAlgorithmException
  95.      * @throws KeyStoreException
  96.      * @throws KeyManagementException
  97.      */
  98.     public static String httpsPost(String url, HashMap<String, String> params) throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException, IOException {
  99.         return httpPost(url, params, null, true);
  100.     }
  102.     /**
  103.      * @param @return 参数
  104.      * @return String    返回类型
  105.      * @throws
  106.      * @Title: httpGet
  107.      * @Description: TODO(http get请求)
  108.      */
  109.     public static String httpGet(String url, HashMap<String, Object> maps, boolean https) throws IOException, ClassNotFoundException, KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
  110.         // 创建HttpClient上下文
  111.         HttpClientContext context = HttpClientContext.create();
  113.         // 创建一个CloseableHttpClient
  114.         CloseableHttpClient httpClient = null;
  115.         if(https){
  116.             httpClient = getCloseableHttpClient();
  117.         }else{
  118.             httpClient = HttpClients.createDefault();
  119.         }
  120.         // get method
  121.         HttpGet httpGet = new HttpGet(url);
  123.         //设置header
  124.         if (maps != null) {
  125.             if (maps.containsKey(HttpHeaders.REFERER)) {
  126.                 httpGet.setHeader(HttpHeaders.REFERER, (String) maps.get(HttpHeaders.REFERER));
  127.             }
  128.             if (maps.containsKey(HttpHeaders.HOST)) {
  129.                 httpGet.setHeader(HttpHeaders.HOST, (String) maps.get(HttpHeaders.HOST));
  130.             }
  131.             if (maps.containsKey(HttpHeaders.USER_AGENT)) {
  132.                 httpGet.setHeader(HttpHeaders.USER_AGENT, (String) maps.get(HttpHeaders.USER_AGENT));
  133.             }
  134.             if (maps.containsKey(HttpHeaders.ACCEPT)) {
  135.                 httpGet.setHeader(HttpHeaders.ACCEPT, (String) maps.get(HttpHeaders.ACCEPT));
  136.             }
  137.         }
  139.         //response
  140.         CloseableHttpResponse response = null;
  141.         //get response into String
  142.         String result = "";
  144.         response = httpClient.execute(httpGet, context);
  145.         HttpEntity entity = response.getEntity();
  146.         result = EntityUtils.toString(entity, "UTF-8");
  148.         //释放连接
  149.         httpGet.releaseConnection();
  150.         httpClient.close();
  151.         return result;
  152.     }
  154.     /**
  155.      * 创建CloseableHttpClient
  156.      * @return
  157.      * @throws KeyStoreException
  158.      * @throws NoSuchAlgorithmException
  159.      * @throws KeyManagementException
  160.      */
  161.     private static CloseableHttpClient getCloseableHttpClient() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
  162.         // 全局请求设置
  163.         RequestConfig globalConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).setConnectionRequestTimeout(10000).setConnectTimeout(10000).setSocketTimeout(10000).build();
  165.         //SSL 过滤
  166.         SSLContextBuilder builder = new SSLContextBuilder();
  167.         builder.loadTrustMaterial(null, new TrustStrategy() {
  168.             public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
  169.                 return true;
  170.             }
  171.         });
  172.         SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(builder.build(), new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"}, null, NoopHostnameVerifier.INSTANCE);
  173.         Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.INSTANCE).register("https", trustAllHttpsCertificates()).build();
  174.         PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager(registry);
  175.         manager.setMaxTotal(200);
  177.         // http 请求默认设置
  178.         HttpClientBuilder custom = HttpClients.custom();
  179.         custom.setDefaultRequestConfig(globalConfig);
  180.         custom.setSSLSocketFactory(sslConnectionSocketFactory);
  181.         custom.setConnectionManager(manager);
  182.         custom.setConnectionManagerShared(true);
  183.         return custom.build();
  184.     }
  186.     /**
  187.      * SSL  https 构建
  188.      * @return
  189.      */
  190.     private static SSLConnectionSocketFactory trustAllHttpsCertificates() {
  191.         SSLConnectionSocketFactory socketFactory = null;
  192.         TrustManager[] trustAllCerts = new TrustManager[1];
  193.         TrustManager tm = new miTM();
  194.         trustAllCerts[0] = tm;
  195.         SSLContext sc = null;
  196.         try {
  197.             sc = SSLContext.getInstance("TLS");//sc = SSLContext.getInstance("TLS")
  198.             sc.init(null, trustAllCerts, null);
  199.             socketFactory = new SSLConnectionSocketFactory(sc, NoopHostnameVerifier.INSTANCE);
  200.             //HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  201.         } catch (NoSuchAlgorithmException e) {
  202.             e.printStackTrace();
  203.         } catch (KeyManagementException e) {
  204.             e.printStackTrace();
  205.         }
  206.         return socketFactory;
  207.     }
  209.     static class miTM implements TrustManager, X509TrustManager {
  211.         public X509Certificate[] getAcceptedIssuers() {
  212.             return null;
  213.         }
  215.         public void checkServerTrusted(X509Certificate[] certs, String authType) {
  216.             //don't check
  217.         }
  219.         public void checkClientTrusted(X509Certificate[] certs, String authType) {
  220.             //don't check
  221.         }
  223.     }
  226.     /**
  227.      * @param @return 参数
  228.      * @return String    返回类型
  229.      * @throws
  230.      * @Title: httpPost
  231.      * @Description: TODO(http post请求)
  232.      */
  233.     public static String httpPost(String url, HashMap<String, String> params, HashMap<String, Object> config, boolean https) throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException, IOException {
  234.         //httpClient
  235.         //HttpClient httpClient = getCloseableHttpClient();
  236.         HttpClient httpClient = null;
  237.         if(https){
  238.             httpClient = getCloseableHttpClient();
  239.         }else{
  240.             httpClient = HttpClients.createDefault();
  241.         }
  243.         // get method
  244.         HttpPost httpPost = new HttpPost(url);
  246.         //设置header
  247.         if (config != null) {
  248.             if (config.containsKey(HttpHeaders.REFERER)) {
  249.                 httpPost.setHeader(HttpHeaders.REFERER, (String) config.get(HttpHeaders.REFERER));
  250.             }
  251.             if (config.containsKey(HttpHeaders.HOST)) {
  252.                 httpPost.setHeader(HttpHeaders.HOST, (String) config.get(HttpHeaders.HOST));
  253.             }
  254.             if (config.containsKey(HttpHeaders.USER_AGENT)) {
  255.                 httpPost.setHeader(HttpHeaders.USER_AGENT, (String) config.get(HttpHeaders.USER_AGENT));
  256.             }
  257.             if (config.containsKey(HttpHeaders.ACCEPT)) {
  258.                 httpPost.setHeader(HttpHeaders.ACCEPT, (String) config.get(HttpHeaders.ACCEPT));
  259.             }
  260.             if(config.containsKey(HttpHeaders.CONTENT_TYPE)){
  261.                 httpPost.setHeader(HttpHeaders.CONTENT_TYPE, (String) config.get(HttpHeaders.CONTENT_TYPE));
  262.             }
  263.             if(config.containsKey("Origin")){
  264.                 httpPost.setHeader("Origin", (String) config.get("Origin"));
  265.             }
  266.         }
  268.         //set params post参数
  269.         List<NameValuePair> listParams = new ArrayList<NameValuePair>();
  271.         //添加post参数
  272.         for (Map.Entry<String, String> entry : params.entrySet()) {
  273.             listParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
  274.         }
  275.         String result = "";
  276.         try {
  277.             //response
  278.             httpPost.setEntity(new UrlEncodedFormEntity(listParams, "UTF-8"));
  279.             HttpResponse response = null;
  280.             response = httpClient.execute(httpPost);
  281.             //get response into String
  283.             HttpEntity entity = response.getEntity();
  284.             result = EntityUtils.toString(entity, "UTF-8");
  285.         } catch (UnsupportedEncodingException e) {
  286.             e.printStackTrace();
  287.         } catch (ClientProtocolException e) {
  288.             e.printStackTrace();
  289.         } catch (IOException e) {
  290.             e.printStackTrace();
  291.         }finally {
  292.             httpPost.releaseConnection();
  293.             ((CloseableHttpClient) httpClient).close();
  294.         }
  295.         return result;
  296.     }
  299. }

发表评论

表情：
评论列表 （有 0 条评论，709人围观）

还没有评论，来说两句吧...

相关阅读