基于springboot的RestTemplate、okhttp和HttpClient对比

快来打我* 2022-11-30 05:55 242阅读 0赞

1、HttpClient：代码复杂，还得操心资源回收等。代码很复杂，冗余代码多，不建议直接使用。

@RequestMapping("/doPostGetJson")
    public String doPostGetJson() throws ParseException {
       //此处将要发送的数据转换为json格式字符串
       String jsonText = "{id：1}";
       JSONObject json = (JSONObject) JSONObject.parse(jsonText);
       JSONObject sr = this.doPost(json);
       System.out.println("返回参数：" + sr);
       return sr.toString();
    }
    
    public static JSONObject doPost(JSONObject date) {
       HttpClient client = HttpClients.createDefault();
       // 要调用的接口方法
       String url = "http://192.168.1.101:8080/getJson";
       HttpPost post = new HttpPost(url);
       JSONObject jsonObject = null;
       try {
          StringEntity s = new StringEntity(date.toString());
          s.setContentEncoding("UTF-8");
          s.setContentType("application/json");
          post.setEntity(s);
          post.addHeader("content-type", "text/xml");
          HttpResponse res = client.execute(post);
          String response1 = EntityUtils.toString(res.getEntity());
          System.out.println(response1);
          if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
             String result = EntityUtils.toString(res.getEntity());// 返回json格式：
             jsonObject = JSONObject.parseObject(result);
          }
       } catch (Exception e) {
          throw new RuntimeException(e);
       }
       return jsonObject;
    }

2、RestTemplate： 是 Spring 提供的用于访问Rest服务的客户端， RestTemplate 提供了多种便捷访问远程Http服务的方法,能够大大提高客户端的编写效率。

引入jar包：

<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

添加初始化配置（也可以不配，有默认的）--注意RestTemplate只有初始化配置，没有什么连接池

package com.itunion.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.client.ClientHttpRequestFactory;
    import org.springframework.http.client.SimpleClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    @Configuration
    public class ApiConfig {
        @Bean
        public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
            return new RestTemplate(factory);
        }
    
        @Bean
        public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
            SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();//默认的是JDK提供http连接，需要的话可以//通过setRequestFactory方法替换为例如Apache HttpComponents、Netty或//OkHttp等其它HTTP library。
            factory.setReadTimeout(5000);//单位为ms
            factory.setConnectTimeout(5000);//单位为ms
            return factory;
        }
    }

1）get请求（不带参的即把参数取消即可）

// 1-getForObject()
    User user1 = this.restTemplate.getForObject(uri, User.class);
    
    // 2-getForEntity()
    ResponseEntity<User> responseEntity1 = this.restTemplate.getForEntity(uri, User.class);
    HttpStatus statusCode = responseEntity1.getStatusCode();
    HttpHeaders header = responseEntity1.getHeaders();
    User user2 = responseEntity1.getBody();
      
    // 3-exchange()
    RequestEntity requestEntity = RequestEntity.get(new URI(uri)).build();
    ResponseEntity<User> responseEntity2 = this.restTemplate.exchange(requestEntity, User.class);
    User user3 = responseEntity2.getBody();

方式一：

Notice notice = restTemplate.getForObject("http://fantj.top/notice/list/{1}/{2}"
                    , Notice.class,1,5);

方式二：

Map<String,String> map = new HashMap();
            map.put("start","1");
            map.put("page","5");
            Notice notice = restTemplate.getForObject("http://fantj.top/notice/list/"
                    , Notice.class,map);

2）post请求：

// 1-postForObject()
    User user1 = this.restTemplate.postForObject(uri, user, User.class);
    
    // 2-postForEntity()
    ResponseEntity<User> responseEntity1 = this.restTemplate.postForEntity(uri, user, User.class);
    
    // 3-exchange()
    RequestEntity<User> requestEntity = RequestEntity.post(new URI(uri)).body(user);
    ResponseEntity<User> responseEntity2 = this.restTemplate.exchange(requestEntity, User.class);

方式一：

String url = "http://demo/api/book/";
            HttpHeaders headers = new HttpHeaders();
            MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
            headers.setContentType(type);
            String requestJson = "{...}";
            HttpEntity<String> entity = new HttpEntity<String>(requestJson,headers);
            String result = restTemplate.postForObject(url, entity, String.class);
            System.out.println(result);

方式二：

@Test
    public void rtPostObject(){
        RestTemplate restTemplate = new RestTemplate();
        String url = "http://47.xxx.xxx.96/register/checkEmail";
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        MultiValueMap<String, String> map= new LinkedMultiValueMap<>();
        map.add("email", "844072586@qq.com");
     
        HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(map, headers);
        ResponseEntity<String> response = restTemplate.postForEntity( url, request , String.class );
        System.out.println(response.getBody());
    }

其它：还支持上传和下载功能；

3、okhttp：OkHttp是一个高效的HTTP客户端，允许所有同一个主机地址的请求共享同一个socket连接；连接池减少请求延时；透明的GZIP压缩减少响应数据的大小；缓存响应内容，避免一些完全重复的请求

当网络出现问题的时候OkHttp依然坚守自己的职责，它会自动恢复一般的连接问题，如果你的服务有多个IP地址，当第一个IP请求失败时，OkHttp会交替尝试你配置的其他IP，OkHttp使用现代TLS技术(SNI, ALPN)初始化新的连接，当握手失败时会回退到TLS 1.0。

1）使用：它的请求/响应 API 使用构造器模式builders来设计，它支持阻塞式的同步请求和带回调的异步请求。

引入jar包：

<dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>3.10.0</version>
    </dependency>

2）配置文件：

import okhttp3.ConnectionPool;
    import okhttp3.OkHttpClient;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLSocketFactory;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.X509TrustManager;
    import java.security.KeyManagementException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.concurrent.TimeUnit;
    
    @Configuration
    public class OkHttpConfiguration {
    
        @Bean
        public OkHttpClient okHttpClient() {
            return new OkHttpClient.Builder()
                    //.sslSocketFactory(sslSocketFactory(), x509TrustManager())
                    .retryOnConnectionFailure(false)
                    .connectionPool(pool())
                    .connectTimeout(30, TimeUnit.SECONDS)
                    .readTimeout(30, TimeUnit.SECONDS)
                    .writeTimeout(30,TimeUnit.SECONDS)
                    .build();
        }
    
        @Bean
        public X509TrustManager x509TrustManager() {
            return new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                }
                @Override
                public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                }
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[0];
                }
            };
        }
    
        @Bean
        public SSLSocketFactory sslSocketFactory() {
            try {
                //信任任何链接
                SSLContext sslContext = SSLContext.getInstance("TLS");
                sslContext.init(null, new TrustManager[]{x509TrustManager()}, new SecureRandom());
                return sslContext.getSocketFactory();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (KeyManagementException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * Create a new connection pool with tuning parameters appropriate for a single-user application.
         * The tuning parameters in this pool are subject to change in future OkHttp releases. Currently
         */
        @Bean
        public ConnectionPool pool() {
            return new ConnectionPool(200, 5, TimeUnit.MINUTES);
        }
    }

3）util工具：

import okhttp3.*;
    import org.apache.commons.lang3.exception.ExceptionUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.File;
    import java.util.Iterator;
    import java.util.Map;
    
    public class OkHttpUtil{
        private static final Logger logger = LoggerFactory.getLogger(OkHttpUtil.class);
        
        private static OkHttpClient  okHttpClient;
    
        @Autowired
        public OkHttpUtil(OkHttpClient  okHttpClient) {
            OkHttpUtil.okHttpClient= okHttpClient;
        } 
        
        /**
         * get
         * @param url     请求的url
         * @param queries 请求的参数，在浏览器？后面的数据，没有可以传null
         * @return
         */
        public static  String get(String url, Map<String, String> queries) {
            String responseBody = "";
            StringBuffer sb = new StringBuffer(url);
            if (queries != null && queries.keySet().size() > 0) {
                boolean firstFlag = true;
                Iterator iterator = queries.entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry entry = (Map.Entry<String, String>) iterator.next();
                    if (firstFlag) {
                        sb.append("?" + entry.getKey() + "=" + entry.getValue());
                        firstFlag = false;
                    } else {
                        sb.append("&" + entry.getKey() + "=" + entry.getValue());
                    }
                }
            }
            Request request = new Request.Builder()
                    .url(sb.toString())
                    .build();
            Response response = null;
            try { 
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 put error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * post
         *
         * @param url    请求的url
         * @param params post form 提交的参数
         * @return
         */
        public static String post(String url, Map<String, String> params) {
            String responseBody = "";
            FormBody.Builder builder = new FormBody.Builder();
            //添加参数
            if (params != null && params.keySet().size() > 0) {
                for (String key : params.keySet()) {
                    builder.add(key, params.get(key));
                }
            }
            Request request = new Request.Builder()
                    .url(url)
                    .post(builder.build())
                    .build();
            Response response = null;
            try { 
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 post error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * get
         * @param url     请求的url
         * @param queries 请求的参数，在浏览器？后面的数据，没有可以传null
         * @return
         */
        public static String getForHeader(String url, Map<String, String> queries) {
            String responseBody = "";
            StringBuffer sb = new StringBuffer(url);
            if (queries != null && queries.keySet().size() > 0) {
                boolean firstFlag = true;
                Iterator iterator = queries.entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry entry = (Map.Entry<String, String>) iterator.next();
                    if (firstFlag) {
                        sb.append("?" + entry.getKey() + "=" + entry.getValue());
                        firstFlag = false;
                    } else {
                        sb.append("&" + entry.getKey() + "=" + entry.getValue());
                    }
                }
            }
            Request request = new Request.Builder()
                    .addHeader("key", "value")
                    .url(sb.toString())
                    .build();
            Response response = null;
            try { 
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 put error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * Post请求发送JSON数据....{"name":"zhangsan","pwd":"123456"}
         * 参数一：请求Url
         * 参数二：请求的JSON
         * 参数三：请求回调
         */
        public static String postJsonParams(String url, String jsonParams) {
            String responseBody = "";
            RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonParams);
            Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            Response response = null;
            try { 
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 post error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * Post请求发送xml数据....
         * 参数一：请求Url
         * 参数二：请求的xmlString
         * 参数三：请求回调
         */
        public static String postXmlParams(String url, String xml) {
            String responseBody = "";
            RequestBody requestBody = RequestBody.create(MediaType.parse("application/xml; charset=utf-8"), xml);
            Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            Response response = null;
            try { 
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 post error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    }