HttpUtils——助力高效网络通信

HttpUtils——助力高效网络通信

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

• 1、创建HttpClient对象。
  2、创建请求方法的实例，并指定请求URL。如果需要发送GET请求，
  创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。
  3、如果需要发送请求参数，可调用HttpGet、HttpPost
  共同的setParams(HttpParams params)方法来添加请求参数；
  对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)
  方法来设置请求参数。
  4、调用HttpClient对象的execute(HttpUriRequest request)
  发送请求，该方法返回一个HttpResponse。
  5、调用HttpResponse的getAllHeaders()、getHeaders(String name)
  等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，
  该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
  6、释放连接。无论执行方法是否成功，都必须释放连接
  

• 引入依赖

•   
      
          org.apache.httpcomponents
          httpclient
          4.5.13
      
  

• 工具类

• @Slf4j
  public class HttpUtils {
  
      public static String defaultEncoding = "utf-8";
  
      /**
       * 发送http post请求，并返回响应实体
       *
       * @param url 请求地址
       * @return url响应实体
       */
      public static String postRequest(String url) {
          return postRequest(url, null, null);
      }
  
      /**
       * 
  方法名: postRequest
       * 
  描述: 发送httpPost请求
       *
       * @param url
       * @param params
       * @return
       */
      public static String postRequest(String url, Map params) {
          return postRequest(url, null, params);
      }
  
      /**
       * 发送http post请求，并返回响应实体
       *
       * @param url     访问的url
       * @param headers 请求需要添加的请求头
       * @param params  请求参数
       * @return
       */
      public static String postRequest(String url, Map headers,
                                       Map params) {
          String result = null;
          CloseableHttpClient httpClient = buildHttpClient();
          HttpPost httpPost = new HttpPost(url);
          if (null != headers && headers.size() > 0) {
              for (Entry entry : headers.entrySet()) {
                  String key = entry.getKey();
                  String value = entry.getValue();
                  httpPost.addHeader(new BasicHeader(key, value));
              }
          }
  
          if(isJSON(params.toString())){
              /**
               * json格式
               */
              StringEntity requestEntity = new StringEntity(params.toString(), "utf-8");
              requestEntity.setContentEncoding("UTF-8");
              httpPost.setHeader("Content-type", "application/json");
              httpPost.setEntity(requestEntity);
          }else{
              /**
               * 名称值对节点类型
               */
              if (null != params && params.size() > 0) {
                  List pairList = new ArrayList(params.size());
                  for (Map.Entry entry : params.entrySet()) {
                      NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue().toString());
                      pairList.add(pair);
                  }
                  httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName(defaultEncoding)));
              }
          }
  
  
          try {
              CloseableHttpResponse response = httpClient.execute(httpPost);
              try {
                  HttpEntity entity = response.getEntity();
                  if (entity != null) {
                      log.info("【POST请求信息】,请求地址:{},请求参数:{}", url, params);
                      result = EntityUtils.toString(entity, Charset.forName(defaultEncoding));
                      log.info("【POST请求信息】,请求地址:{},请求参数:{},返回结果:{}", url, params,result);
                  }
              } finally {
                  response.close();
              }
          } catch (Exception ex) {
              ex.printStackTrace();
          } finally {
              try {
                  httpClient.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
  
          return result;
      }
  
      /**
       * 发送http get请求
       *
       * @param url 请求url
       * @return url返回内容
       */
      public static String getRequest(String url) {
          return getRequest(url, null);
      }
  
  
      /**
       * 发送http get请求
       *
       * @param url    请求的url
       * @param params 请求的参数
       * @return
       */
      public static String getRequest(String url, Map params) {
          return getRequest(url, null, params);
      }
  
      /**
       * 发送http get请求
       *
       * @param url        请求的url
       * @param headersMap 请求头
       * @param params     请求的参数
       * @return
       */
      public static String getRequest(String url, Map headersMap, Map params) {
          String result = null;
          CloseableHttpClient httpClient = buildHttpClient();
          try {
              String apiUrl = url;
              if (null != params && params.size() > 0) {
                  StringBuffer param = new StringBuffer();
                  int i = 0;
                  for (String key : params.keySet()) {
                      if (i == 0)
                          param.append("?");
                      else
                          param.append("&");
                      param.append(key).append("=").append(params.get(key));
                      i++;
                  }
                  apiUrl += param;
              }
  
              HttpGet httpGet = new HttpGet(apiUrl);
              if (null != headersMap && headersMap.size() > 0) {
                  for (Entry entry : headersMap.entrySet()) {
                      String key = entry.getKey();
                      String value = entry.getValue();
                      httpGet.addHeader(new BasicHeader(key, value));
                  }
              }
              CloseableHttpResponse response = httpClient.execute(httpGet);
              try {
                  HttpEntity entity = response.getEntity();
                  if (null != entity) {
                      log.info("【GET请求信息】,请求地址:{},请求参数:{}", url, params);
                      result = EntityUtils.toString(entity, defaultEncoding);
                      log.info("【GET请求信息】,请求地址:{},请求参数:{},返回结果:{}", url, params,result);
                  }
              } 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();
              }
          }
          return result;
      }
  
      /**
       * 创建httpclient,支持http、https
       *
       * @return
       */
      public static CloseableHttpClient buildHttpClient() {
          try {
              RegistryBuilder builder = RegistryBuilder
                      .create();
              ConnectionSocketFactory factory = new PlainConnectionSocketFactory();
              builder.register("http", factory);
              KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
              SSLContext context = SSLContexts.custom().useTLS()
                      .loadTrustMaterial(trustStore, new TrustStrategy() {
                          public boolean isTrusted(X509Certificate[] chain,
                                                   String authType) throws CertificateException {
                              return true;
                          }
                      }).build();
              LayeredConnectionSocketFactory sslFactory = new SSLConnectionSocketFactory(
                      context,
                      SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
              builder.register("https", sslFactory);
              Registry registry = builder.build();
              PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager(registry);
              ConnectionConfig connConfig = ConnectionConfig.custom()
                      .setCharset(Charset.forName(defaultEncoding)).build();
              SocketConfig socketConfig = SocketConfig.custom()
                      .setSoTimeout(100000).build();
              manager.setDefaultConnectionConfig(connConfig);
              manager.setDefaultSocketConfig(socketConfig);
              return HttpClientBuilder.create().setConnectionManager(manager)
                      .build();
          } catch (KeyStoreException e) {
              e.printStackTrace();
          } catch (KeyManagementException e) {
              e.printStackTrace();
          } catch (NoSuchAlgorithmException e) {
              e.printStackTrace();
          }
          return null;
      }
  
  
      public static boolean isJSON(String str) {
          boolean result = false;
          try {
              Object obj=JSON.parse(str);
              result = true;
          } catch (Exception e) {
              result=false;
          }
          return result;
      }
  
      public static void main(String[] args) {
          String url1 = "http://192.168.56.101:8196/test/get1";
          String result = HttpUtils.getRequest(url1);
          System.out.println(result);
  
          String url2 = "http://192.168.56.101:8196/test/get2";
          Map params = new HashMap<>();
          params.put("name", "一安未来1");
          params.put("addr", "北京1");
          String result2 = HttpUtils.postRequest(url2, null,params);
          System.out.println(result2);
  
          String url3 = "http://192.168.56.101:8196/test/get3";
          JSONObject jsonObject = new JSONObject();
          jsonObject.put("name", "一安未来2");
          jsonObject.put("addr", "北京2");
          String result3 = HttpUtils.postRequest(url3, null,jsonObject);
          System.out.println(result3);
      }
  
  【GET请求信息】,请求地址:http://192.168.56.101:8196/test/get1,请求参数:null
  【GET请求信息】,请求地址:https://192.168.56.101:8196/test/get1,请求参数:null,返回结果:{"result":"success"}
  
  【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get2,请求参数:{name=一安未来1, addr=北京1}
  【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get2,请求参数:{name=一安未来1, addr=北京1},返回结果:{"name":"一安未来1","addr":"北京1"}
  
  【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get3,请求参数:{"name":"一安未来2","addr":"北京2"}
  【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get3,请求参数:{"name":"一安未来2","addr":"北京2"},返回结果:{"name":"一安未来2","addr":"北京2"}
  
  }
  

• 接口类

• @RestController
  public class TestController {
  
  
      @GetMapping("get1")
      public String test1(){
          return "{\"result\":\"success\"}";
      }
  
  
      @PostMapping("get2")
      private Map test2(@RequestParam Map map){
          return map;
      }
  
      @PostMapping("get3")
      private Map test3(@RequestBody Map map){
          return map;
      }
  
  }