RestTemplate 远程调用工具封装

一、 前言

我们平时在使用SpringCloud 、SpringCloudAlibaba 或其他微服务框架时，如果在同一个项目中可能会采用feign / openfeign ，但是当把项目单独出来再去和原微服务架构体系进行集成时就不大灵活，今天我就介绍一种，远程调用工具RestTemplate 不仅可以用在微服务之间，也可以调用第三方接口。

二、框架

SpringBoot 2.6.6 + SpringCloud 2021.0.3 + SpringCloud alibaba 2021.0.1.0
+mysql 8.0.27

三、配置

RestTemplateConfig

package com.lq.common.config;

import com.lq.common.filter.HeaderRequestInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;

@Configuration
public class RestTemplateConfig {
    @Autowired
    HeaderRequestInterceptor headerRequestInterceptor;

    //实现远程调用
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        List<HttpMessageConverter<?>> converterList  = restTemplate.getMessageConverters();
        // 重新设置StringHttpMessageConverter字符集为UTF-8，解决中文乱码问题
        HttpMessageConverter<?> converterTarget = null;
        for (HttpMessageConverter<?> item : converterList) {
            if (StringHttpMessageConverter.class == item.getClass()) {
                converterTarget = item;
                break;
            }
        }
        if (null != converterTarget) {
            converterList.remove(converterTarget);
        }
        converterList.add(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));

        restTemplate.setInterceptors(Collections.singletonList(headerRequestInterceptor));
        restTemplate.setRequestFactory(getOkHttp3ClientHttpRequestFactory());
        return restTemplate;

    }


    // 设置超时时间
    private SimpleClientHttpRequestFactory getClientHttpRequestFactory() {
        SimpleClientHttpRequestFactory clientHttpRequestFactory = new SimpleClientHttpRequestFactory();
        // Connect timeout 6s
        clientHttpRequestFactory.setConnectTimeout(100000);
        // Read timeout 6s
        clientHttpRequestFactory.setReadTimeout(100000);
        return clientHttpRequestFactory;
    }

    private OkHttp3ClientHttpRequestFactory getOkHttp3ClientHttpRequestFactory(){
        OkHttp3ClientHttpRequestFactory okHttp3ClientHttpRequestFactory = new OkHttp3ClientHttpRequestFactory();
        okHttp3ClientHttpRequestFactory.setConnectTimeout(100000);
        okHttp3ClientHttpRequestFactory.setReadTimeout(100000);
        return okHttp3ClientHttpRequestFactory;
    }


}

RestApiUtil

package com.lq.common.util;


import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.lq.common.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import javax.annotation.PostConstruct;
import java.util.*;


/**
 * @Description 远程调用工具类
 * @Author hqd
 * @Date 2023-12-02
 */
@Slf4j
@Component
public class RestApiUtil {
    @Autowired
    private RestTemplate restTemplate;
    private static RestTemplate restTemplate2;
    @PostConstruct
    public void init(){
        restTemplate2 = restTemplate;
    }

    /**
     *  查询 返回对象
     * @param httpMethod： 方法类型 get / post
     * @param serverName:  服务名
     * @param uri：服务地址
     * @param paramsMap： get 请求参数
     * @param body： body 请求参数
     * @param responseTypeClazz： 返回类型
     * @return <T>
     */
    public static <T> T requsetForObject(HttpMethod httpMethod,String serverName, String uri,Map<String,Object> paramsMap,Object body, Class<T> responseTypeClazz) throws Exception {
        T t = null;
//        try {
            if (ObjectUtil.isNotEmpty(paramsMap)){
                StringBuilder sb = new StringBuilder();
                sb.append(uri+"?");
                for (Map.Entry entry:paramsMap.entrySet()){
                    sb.append(entry.getKey()+"={"+entry.getKey()+"}"+"&");
                }
                uri =sb.substring(0,sb.length()-1).toString();
            }
            HttpEntity httpEntity =null;
            if (ObjectUtil.isNotEmpty(body)){
                httpEntity = new HttpEntity(body);
            }
             t= restTemplate2.exchange("http://"+serverName+uri , httpMethod,httpEntity, responseTypeClazz,paramsMap).getBody();
//        }catch (Exception e){
//            e.printStackTrace();
//            log.error(e.getMessage());
//        }
        return t;
    }

    /**
     * 查询返回List
     * @param httpMethod ：方法类型 get / post
     * @param serverName： 服务名
     * @param uri：服务地址
     * @param paramsMap：get 请求参数
     * @param body：body 请求参数
     * @return <T>
     */
    public static <T> List<T>  requestForList(HttpMethod httpMethod,String serverName, String uri,Map<String,Object> paramsMap,Object body,Class<T> clazz) throws Exception {
        List<T> result = null;
//        try {
            if (ObjectUtil.isNotEmpty(paramsMap)){
                StringBuilder sb = new StringBuilder();
                sb.append(uri+"?");
                for (Map.Entry entry:paramsMap.entrySet()){
                    sb.append(entry.getKey()+"={"+entry.getKey()+"}"+"&");
                }
                uri =sb.substring(0,sb.length()-1).toString();
            }
            HttpEntity httpEntity =null;
            if (ObjectUtil.isNotEmpty(body)){
                httpEntity = new HttpEntity(body);
            }
            if (ObjectUtil.isNull(paramsMap)){
                paramsMap = new HashMap<>();
            }
            ParameterizedTypeReference<List<T>> responseType = new ParameterizedTypeReference<List<T>>() {};
            result = restTemplate2.exchange("http://" + serverName + uri, httpMethod, httpEntity, responseType, paramsMap).getBody();
            if(CollectionUtil.isNotEmpty(result)){
               for (int i =0;i<result.size();i++){
                   result.set(i,JSONObject.parseObject(JSONObject.toJSONBytes(result.get(i)), clazz));
               }
            }
//            result.stream().map(v->{
//                v= JSONObject.parseObject(JSONObject.toJSONBytes(v), clazz);
//                return v;
//            });
//        }catch (Exception e){
//            e.printStackTrace();
//            log.error(e.getMessage());
//        }

        return result;
    }

    /**
     * 查询返回Map
     * @param httpMethod: 请求类型 Get / Post
     * @param serverName：服务名
     * @param uri：请求方法路径
     * @param paramsMap：get 请求参数
     * @param body： 请求body
     * @return Map<String,Object>
     */

    public static Map<String,Object> requestForMap(HttpMethod httpMethod,String serverName, String uri, Map<String,Object> paramsMap,Object body) throws Exception {
        Map<String, Object> result = null;
//        try {
            if (ObjectUtil.isNotEmpty(paramsMap)){
                StringBuilder sb = new StringBuilder();
                sb.append(uri+"?");
                for (Map.Entry entry:paramsMap.entrySet()){
                    sb.append(entry.getKey()+"={"+entry.getKey()+"}"+"&");
                }
                uri =sb.substring(0,sb.length()-1).toString();
            }
            HttpEntity httpEntity =null;
            if (ObjectUtil.isNotEmpty(body)){
                httpEntity = new HttpEntity(body);
            }
            if (ObjectUtil.isNull(paramsMap)){
                paramsMap = new HashMap<>();
            }
            ParameterizedTypeReference<Map<String, Object>> responseType = new ParameterizedTypeReference<Map<String, Object>>() {};
            result = restTemplate2.exchange("http://" + serverName + uri, httpMethod, httpEntity, responseType, paramsMap).getBody();
//        }catch (Exception e){
//            e.printStackTrace();
//            log.error(e.getMessage());
//        }

        return result;
    }

    /**
     *  查询Map<String,List<T>>
     * @param httpMethod: 请求类型 Get / Post
     * @param serverName：服务名
     * @param uri：请求方法路径
     * @param paramsMap：get 请求参数
     * @param body： 请求body
     * @param clazz: T class 类型
     * @return <T>
     */

    public static <T> Map<String,List<T>> requestForMapListT(HttpMethod httpMethod,String serverName, String uri,Map<String,?> paramsMap,Object body,Class<T> clazz) throws Exception {
        Map<String, List<T>> result = null;
//        try {
            if (ObjectUtil.isNotEmpty(paramsMap)){
                StringBuilder sb = new StringBuilder();
                sb.append(uri+"?");
                for (Map.Entry entry:paramsMap.entrySet()){
                    sb.append(entry.getKey()+"={"+entry.getKey()+"}"+"&");
                }
                uri =sb.substring(0,sb.length()-1).toString();
            }
            HttpEntity httpEntity =null;
            if (ObjectUtil.isNotEmpty(body)){
                httpEntity = new HttpEntity(body);
            }
            if (ObjectUtil.isNull(paramsMap)){
                paramsMap = new HashMap<>();
            }
            ParameterizedTypeReference<Map<String, List<T>>> responseType = new ParameterizedTypeReference<Map<String, List<T>>>() {};
            result = restTemplate2.exchange("http://" + serverName + uri, httpMethod, httpEntity, responseType, paramsMap).getBody();
            if (ObjectUtil.isNotEmpty(result)){
                Set<Map.Entry<String, List<T>>> entries = result.entrySet();
                for (Map.Entry entry: entries){
                    List<LinkedHashMap> _result = (List<LinkedHashMap>) entry.getValue();
                    List<T> list = new ArrayList<>();
                    if (CollectionUtil.isNotEmpty(_result)){
                        for (LinkedHashMap map : _result){
                            T  t = JSONObject.parseObject(JSONObject.toJSONBytes(map), clazz);
                            list.add(t);
                        }
                    }
                    entry.setValue(list);

                }
            }

//        }catch (Exception e){
//            e.printStackTrace();
//            log.error(e.getMessage());
//        }

        return result;
    }

    /**
     * 查询返回自定义Result<T>
     * @param httpMethod: 请求类型 Get / Post
     * @param serverName：服务名
     * @param uri：请求方法路径
     * @param paramsMap：get 请求参数
     * @param body： 请求body
     * @return <T>
     */
    public static <T> Result<T> requestForResult(HttpMethod httpMethod,String serverName, String uri, Map<String, Object> paramsMap,Object body,Class<T> clazz) throws Exception {
        Result<T> result = null;
//        try {
            if (ObjectUtil.isNotEmpty(paramsMap)){
                StringBuilder sb = new StringBuilder();
                sb.append(uri+"?");
                for (Map.Entry entry:paramsMap.entrySet()){
                    sb.append(entry.getKey()+"={"+entry.getKey()+"}"+"&");
                }
                uri =sb.substring(0,sb.length()-1).toString();
            }
            HttpEntity httpEntity =null;
            if (ObjectUtil.isNotEmpty(body)){
                httpEntity = new HttpEntity(body);
            }
            if (ObjectUtil.isNull(paramsMap)){
                paramsMap = new HashMap<>();
            }
            ParameterizedTypeReference<Result<T>> responseType = new ParameterizedTypeReference<Result<T>>() {};
            result = restTemplate2.exchange("http://" + serverName + uri, httpMethod, httpEntity, responseType, paramsMap).getBody();
            T t = JSONObject.parseObject(JSONObject.toJSONBytes(result.getResult()), clazz);
            result.setResult(t);
//        }catch (Exception e){
//            e.printStackTrace();
//            log.error(e.getMessage());
//        }

        return result;
    }

    public static <T> Result<List<T>> requestForResultList(HttpMethod httpMethod,String serverName, String uri, Map<String, Object> paramsMap,Object body,Class<T> clazz) throws Exception {
        Result<List<T>> result = null;
//        try {
        if (ObjectUtil.isNotEmpty(paramsMap)){
            StringBuilder sb = new StringBuilder();
            sb.append(uri+"?");
            for (Map.Entry entry:paramsMap.entrySet()){
                sb.append(entry.getKey()+"={"+entry.getKey()+"}"+"&");
            }
            uri =sb.substring(0,sb.length()-1).toString();
        }
        HttpEntity httpEntity =null;
        if (ObjectUtil.isNotEmpty(body)){
            httpEntity = new HttpEntity(body);
        }
        if (ObjectUtil.isNull(paramsMap)){
            paramsMap = new HashMap<>();
        }
        ParameterizedTypeReference<Result<List<T>>> responseType = new ParameterizedTypeReference<Result<List<T>>>() {};
        result = restTemplate2.exchange("http://" + serverName + uri, httpMethod, httpEntity, responseType, paramsMap).getBody();
        List<T> t = JSONArray.parseArray(JSONObject.toJSONString(result.getResult()), clazz);

//        T t = JSONObject.parseObject(JSONObject.toJSONBytes(result.getResult()), clazz);
        result.setResult(t);
//        }catch (Exception e){
//            e.printStackTrace();
//            log.error(e.getMessage());
//        }

        return result;
    }




}