Java OkHttp3

准备工作

Maven项目在pom文件中引入jar包

  1. <dependency>
  2.     <groupId>com.squareup.okhttp3</groupId>
  3.     <artifactId>okhttp</artifactId>
  4.     <version>3.10.0</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>com.alibaba</groupId>
  8.     <artifactId>fastjson</artifactId>
  9.     <version>1.2.60</version>
  10. </dependency>

引入json是因为工具类中有些地方用到了，现在通信都流行使用json传输，也少不了要这个jar包

工具类代码

  1. import com.alibaba.fastjson.JSON;
  2. import okhttp3.*;
  4. import javax.net.ssl.SSLContext;
  5. import javax.net.ssl.SSLSocketFactory;
  6. import javax.net.ssl.TrustManager;
  7. import javax.net.ssl.X509TrustManager;
  8. import java.io.IOException;
  9. import java.net.URLEncoder;
  10. import java.security.SecureRandom;
  11. import java.security.cert.X509Certificate;
  12. import java.util.LinkedHashMap;
  13. import java.util.Map;
  14. import java.util.concurrent.Semaphore;
  15. import java.util.concurrent.TimeUnit;
  17. public class OkHttpUtils {
  18.     private static volatile OkHttpClient okHttpClient = null;
  19.     private static volatile Semaphore semaphore = null;
  20.     private Map<String, String> headerMap;
  21.     private Map<String, String> paramMap;
  22.     private String url;
  23.     private Request.Builder request;
  25.     /**
  26.      * 初始化okHttpClient，并且允许https访问
  27.      */
  28.     private OkHttpUtils() {
  29.         if (okHttpClient == null) {
  30.             synchronized (OkHttpUtils.class) {
  31.                 if (okHttpClient == null) {
  32.                     TrustManager[] trustManagers = buildTrustManagers();
  33.                     okHttpClient = new OkHttpClient.Builder()
  34.                             .connectTimeout(15, TimeUnit.SECONDS)
  35.                             .writeTimeout(20, TimeUnit.SECONDS)
  36.                             .readTimeout(20, TimeUnit.SECONDS)
  37.                             .sslSocketFactory(createSSLSocketFactory(trustManagers), (X509TrustManager) trustManagers[0])
  38.                             .hostnameVerifier((hostName, session) -> true)
  39.                             .retryOnConnectionFailure(true)
  40.                             .build();
  41.                     addHeader("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36");
  42.                 }
  43.             }
  44.         }
  45.     }
  47.     /**
  48.      * 用于异步请求时，控制访问线程数，返回结果
  49.      *
  50.      * @return
  51.      */
  52.     private static Semaphore getSemaphoreInstance() {
  53.         //只能1个线程同时访问
  54.         synchronized (OkHttpUtils.class) {
  55.             if (semaphore == null) {
  56.                 semaphore = new Semaphore(0);
  57.             }
  58.         }
  59.         return semaphore;
  60.     }
  62.     /**
  63.      * 创建OkHttpUtils
  64.      *
  65.      * @return
  66.      */
  67.     public static OkHttpUtils builder() {
  68.         return new OkHttpUtils();
  69.     }
  71.     /**
  72.      * 添加url
  73.      *
  74.      * @param url
  75.      * @return
  76.      */
  77.     public OkHttpUtils url(String url) {
  78.         this.url = url;
  79.         return this;
  80.     }
  82.     /**
  83.      * 添加参数
  84.      * 
  85.      * @param key   参数名
  86.      * @param value 参数值
  87.      * @return
  88.      */
  89.     public OkHttpUtils addParam(String key, String value) {
  90.         if (paramMap == null) {
  91.             paramMap = new LinkedHashMap<>(16);
  92.         }
  93.         paramMap.put(key, value);
  94.         return this;
  95.     }
  97.     /**
  98.      * 添加请求头
  99.      *
  100.      * @param key   参数名
  101.      * @param value 参数值
  102.      * @return
  103.      */
  104.     public OkHttpUtils addHeader(String key, String value) {
  105.         if (headerMap == null) {
  106.             headerMap = new LinkedHashMap<>(16);
  107.         }
  108.         headerMap.put(key, value);
  109.         return this;
  110.     }
  112.     /**
  113.      * 初始化get方法
  114.      *
  115.      * @return
  116.      */
  117.     public OkHttpUtils get() {
  118.         request = new Request.Builder().get();
  119.         StringBuilder urlBuilder = new StringBuilder(url);
  120.         if (paramMap != null) {
  121.             urlBuilder.append("?");
  122.             try {
  123.                 for (Map.Entry<String, String> entry : paramMap.entrySet()) {
  124.                     urlBuilder.append(URLEncoder.encode(entry.getKey(), "utf-8")).
  125.                             append("=").
  126.                             append(URLEncoder.encode(entry.getValue(), "utf-8")).
  127.                             append("&");
  128.                 }
  129.             } catch (Exception e) {
  130.                 e.printStackTrace();
  131.             }
  132.             urlBuilder.deleteCharAt(urlBuilder.length() - 1);
  133.         }
  134.         request.url(urlBuilder.toString());
  135.         return this;
  136.     }
  138.     /**
  139.      * 初始化post方法
  140.      *
  141.      * @param isJsonPost true等于json的方式提交数据，类似postman里post方法的raw
  142.      *                   false等于普通的表单提交
  143.      * @return
  144.      */
  145.     public OkHttpUtils post(boolean isJsonPost) {
  146.         RequestBody requestBody;
  147.         if (isJsonPost) {
  148.             String json = "";
  149.             if (paramMap != null) {
  150.                 json = JSON.toJSONString(paramMap);
  151.             } 
  152.             requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);
  153.         } else {
  154.             FormBody.Builder formBody = new FormBody.Builder();
  155.             if (paramMap != null) {
  156.                 paramMap.forEach(formBody::add);
  157.             }
  158.             requestBody = formBody.build();
  159.         }
  160.         request = new Request.Builder().post(requestBody).url(url);
  161.         return this;
  162.     }
  164.     /**
  165.      * 同步请求
  166.      *
  167.      * @return
  168.      */
  169.     public String sync() {
  170.         setHeader(request);
  171.         try {
  172.             Response response = okHttpClient.newCall(request.build()).execute();
  173.             assert response.body() != null;
  174.             return response.body().string();
  175.         } catch (IOException e) {
  176.             e.printStackTrace();
  177.             return "请求失败：" + e.getMessage();
  178.         }
  179.     }
  181.     /**
  182.      * 异步请求，有返回值
  183.      */
  184.     public String async() {
  185.         StringBuilder buffer = new StringBuilder("");
  186.         setHeader(request);
  187.         okHttpClient.newCall(request.build()).enqueue(new Callback() {
  188.             @Override
  189.             public void onFailure(Call call, IOException e) {
  190.                 buffer.append("请求出错：").append(e.getMessage());
  191.             }
  193.             @Override
  194.             public void onResponse(Call call, Response response) throws IOException {
  195.                 assert response.body() != null;
  196.                 buffer.append(response.body().string());
  197.                 getSemaphoreInstance().release();
  198.             }
  199.         });
  200.         try {
  201.             getSemaphoreInstance().acquire();
  202.         } catch (InterruptedException e) {
  203.             e.printStackTrace();
  204.         }
  205.         return buffer.toString();
  206.     }
  208.     /**
  209.      * 异步请求，带有接口回调
  210.      *
  211.      * @param callBack
  212.      */
  213.     public void async(ICallBack callBack) {
  214.         setHeader(request);
  215.         okHttpClient.newCall(request.build()).enqueue(new Callback() {
  216.             @Override
  217.             public void onFailure(Call call, IOException e) {
  218.                 callBack.onFailure(call, e.getMessage());
  219.             }
  221.             @Override
  222.             public void onResponse(Call call, Response response) throws IOException {
  223.                 assert response.body() != null;
  224.                 callBack.onSuccessful(call, response.body().string());
  225.             }
  226.         });
  227.     }
  229.     /**
  230.      * 为request添加请求头
  231.      *
  232.      * @param request
  233.      */
  234.     private void setHeader(Request.Builder request) {
  235.         if (headerMap != null) {
  236.             try {
  237.                 for (Map.Entry<String, String> entry : headerMap.entrySet()) {
  238.                     request.addHeader(entry.getKey(), entry.getValue());
  239.                 }
  240.             } catch (Exception e) {
  241.                 e.printStackTrace();
  242.             }
  243.         }
  244.     }
  247.     /**
  248.      * 生成安全套接字工厂，用于https请求的证书跳过
  249.      *
  250.      * @return
  251.      */
  252.     private static SSLSocketFactory createSSLSocketFactory(TrustManager[] trustAllCerts) {
  253.         SSLSocketFactory ssfFactory = null;
  254.         try {
  255.             SSLContext sc = SSLContext.getInstance("SSL");
  256.             sc.init(null, trustAllCerts, new SecureRandom());
  257.             ssfFactory = sc.getSocketFactory();
  258.         } catch (Exception e) {
  259.             e.printStackTrace();
  260.         }
  261.         return ssfFactory;
  262.     }
  264.     private static TrustManager[] buildTrustManagers() {
  265.         return new TrustManager[]{
  266.                 new X509TrustManager() {
  267.                     @Override
  268.                     public void checkClientTrusted(X509Certificate[] chain, String authType) {
  269.                     }
  271.                     @Override
  272.                     public void checkServerTrusted(X509Certificate[] chain, String authType) {
  273.                     }
  275.                     @Override
  276.                     public X509Certificate[] getAcceptedIssuers() {
  277.                         return new X509Certificate[]{};
  278.                     }
  279.                 }
  280.         };
  281.     }
  283.     /**
  284.      * 自定义一个接口回调
  285.      */
  286.     public interface ICallBack {
  288.         void onSuccessful(Call call, String data);
  290.         void onFailure(Call call, String errorMsg);
  292.     }
  293. }

使用教程

  1. public static void main(String[] args) {
  2.     // get请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
  3.     OkHttpUtils.builder().url("请求地址，http/https都可以")
  4.             // 有参数的话添加参数，可多个
  5.             .addParam("参数名", "参数值")
  6.             .addParam("参数名", "参数值")
  7.             // 也可以添加多个
  8.             .addHeader("Content-Type", "application/json; charset=utf-8")
  9.             .get()
  10.             // 可选择是同步请求还是异步请求
  11.             //.async();
  12.             .sync();
  14.     // post请求，分为两种，一种是普通表单提交，一种是json提交
  15.     OkHttpUtils.builder().url("请求地址，http/https都可以")
  16.             // 有参数的话添加参数，可多个
  17.             .addParam("参数名", "参数值")
  18.             .addParam("参数名", "参数值")
  19.             // 也可以添加多个
  20.             .addHeader("Content-Type", "application/json; charset=utf-8")
  21.             // 如果是true的话，会类似于postman中post提交方式的raw，用json的方式提交，不是表单
  22.             // 如果是false的话传统的表单提交
  23.             .post(true)
  24.             .sync();
  26.     // 选择异步有两个方法，一个是带回调接口，一个是直接返回结果
  27.     OkHttpUtils.builder().url("")
  28.             .post(false)
  29.             .async();
  31.     OkHttpUtils.builder().url("").post(false).async(new OkHttpUtils.ICallBack() {
  32.         @Override
  33.         public void onSuccessful(Call call, String data) {
  34.             // 请求成功后的处理
  35.         }
  37.         @Override
  38.         public void onFailure(Call call, String errorMsg) {
  39.             // 请求失败后的处理
  40.         }
  41.     });
  42. }