使用RestTemplate进行feignclient调用（附源码）

已于 2022-05-31 16:51:19 修改
阅读量1.3w 收藏 2
点赞数
分类专栏： java开发常遇问题 文章标签： spring cloud java spring boot
于 2022-05-31 16:49:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cucgyfjklx/article/details/125068959
版权

使用RestTemplate进行feignclient调用（附源码）

问题背景

feignclient的本质其实也是http调用，只是进行了封装，通过nacos可以进行服务名调用，并且可以使用负载均衡，除了使用注解@FeignClient进行feign调用，也可以使用RestTemplate进行调用，本篇介绍使用RestTemplate进行调用feign
注意事项：

项目搭建

1 引入pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yg</groupId>
    <artifactId>resttemplate</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>resttemplate</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--StringUtils RandomStringUtils-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
        <!--Lists Maps-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.0.1-jre</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
            <exclusions>
                <exclusion>
                    <artifactId>commons-codec</artifactId>
                    <groupId>commons-codec</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--Feign LoadBalanced-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>2.2.5.RELEASE</version>
            <exclusions>
                <exclusion>
                    <artifactId>spring-cloud-context</artifactId>
                    <groupId>org.springframework.cloud</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>archaius-core</artifactId>
                    <groupId>com.netflix.archaius</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jsr305</artifactId>
                    <groupId>com.google.code.findbugs</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--MapUtils-->
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
        <!--注册中心-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-nacos-discovery</artifactId>
            <version>2.2.0.RELEASE</version>
            <exclusions>
                <exclusion>
                    <artifactId>guava</artifactId>
                    <groupId>com.google.guava</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>HdrHistogram</artifactId>
                    <groupId>org.hdrhistogram</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-cloud-commons</artifactId>
                    <groupId>org.springframework.cloud</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-codec</artifactId>
                    <groupId>commons-codec</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-lang3</artifactId>
                    <groupId>org.apache.commons</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>httpclient</artifactId>
                    <groupId>org.apache.httpcomponents</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-cloud-starter</artifactId>
                    <groupId>org.springframework.cloud</groupId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2 添加bootstrap连接注册中心

server:
  port: ${SERVER_PORT:1994}

spring:
  application:
    name: resttemplate-feign
  cloud:
    nacos:
      discovery:
        server-addr: ${REGISTER_HOST:10.10.196.247}:${REGISTER_PORT:8848}
      config:
        server-addr: ${REGISTER_HOST:10.10.196.247}:${REGISTER_PORT:8848}
        file-extension: yml

3 RestTemplate配置类

package com.yg.resttemplate.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * @Author suolong
 * @Date 2022/5/30 21:53
 * @Version 2.0
 */
@Configuration
public class RestTemplateConfig {

    @Bean
    @LoadBalanced //添加该注解，可以直接通过服务名找到对应的IP地址
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

4 启动类，需要使能feign

package com.yg.resttemplate;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients
@EnableConfigurationProperties
@SpringBootApplication
public class ResttemplateApplication {

    public static void main(String[] args) {
        SpringApplication.run(ResttemplateApplication.class, args);
    }

}

5 http工具类

package com.yg.resttemplate.utils;


import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.yg.resttemplate.plugins.CustomJacksonHttpMessageConverter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.stereotype.Service;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.*;

@Slf4j
@Service
public class HttpClientPoolUtils implements InitializingBean {

    private PoolingHttpClientConnectionManager poolConnManager;
    private RequestConfig requestConfig;
    private CloseableHttpClient httpClient;

    /**
     * Spring封装的http请求对象。
     */
    private static RestTemplate restTemplate;

    /**
     * 并发控制锁对象。
     */
    private static final Object LOCK_REST_TEMPLATE = new Object();

    // region 获取全局对象

    /**
     * 获取Spring封装的http请求对象。
     *
     * @return http请求对象。
     */
    @Bean
    @LoadBalanced
    private static RestTemplate getRestTemplate() {
        if (null == restTemplate) {
            synchronized (LOCK_REST_TEMPLATE) {
                if (null == restTemplate) {

                    // endregion

                    restTemplate = new RestTemplate();
                    restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {
                        /**
                         * 返回的状态不等于200,不抛出异常
                         *
                         * @param response
                         * @throws IOException
                         */
                        @Override
                        public void handleError(ClientHttpResponse response) throws IOException {
                        }

                        /**
                         * 忽略非200错误
                         *
                         * @param response
                         */
                        @Override
                        public boolean hasError(ClientHttpResponse response) throws IOException {
                            return true;
                        }
                    });

                    // 替换默认的 Jackson 消息转换器实现
                    List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
                    Iterator<HttpMessageConverter<?>> iterator = messageConverters.iterator();
                    while (iterator.hasNext()) {
                        HttpMessageConverter<?> next = iterator.next();
                        if (next instanceof MappingJackson2HttpMessageConverter) {
                            iterator.remove();
                            break;
                        }
                    }
                    messageConverters.add(new CustomJacksonHttpMessageConverter());
                }
            }
        }

        return restTemplate;
    }

    // endregion

    private static void config(HttpRequestBase httpRequestBase, Map<String, Object> header) {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(20000)
                .setConnectTimeout(20000)
                .setSocketTimeout(20000).build();
        httpRequestBase.addHeader("Content-Type", "application/json;charset=UTF-8");
        if (MapUtils.isNotEmpty(header)) {
            for (Map.Entry<String, Object> entry : header.entrySet()) {
                httpRequestBase.addHeader(entry.getKey(), String.valueOf(entry.getValue()));
            }
        }
        httpRequestBase.setConfig(requestConfig);
    }

    private void initPool() {
        try {
            restTemplate = getRestTemplate();

            SSLContextBuilder builder = new SSLContextBuilder();
            builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create().register(
                    "http", PlainConnectionSocketFactory.getSocketFactory()).register(
                    "https", sslsf).build();
            poolConnManager = new PoolingHttpClientConnectionManager(
                    socketFactoryRegistry);
            poolConnManager.setMaxTotal(500);
            poolConnManager.setDefaultMaxPerRoute(500);

            int socketTimeout = 1200000;
            int connectTimeout = 100000;
            int connectionRequestTimeout = 100000;
            requestConfig = RequestConfig.custom().setConnectionRequestTimeout(
                    connectionRequestTimeout).setSocketTimeout(socketTimeout).setConnectTimeout(
                    connectTimeout).build();
            httpClient = getConnection();
        } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) {
            e.printStackTrace();
        }
    }

    private CloseableHttpClient getConnection() {
        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(poolConnManager)
                .setDefaultRequestConfig(requestConfig)

                .setRetryHandler(new DefaultHttpRequestRetryHandler(2, false))
                .build();
        return httpClient;
    }

    public String postForForm(String url, Map<String, String> reqMap) {
        long start = System.currentTimeMillis();
        CloseableHttpResponse response = null;
        String result = StringUtils.EMPTY;
        HttpPost httpPost = null;

        try {
            // 创建httpPost
            httpPost = new HttpPost(url);
            httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded");
            ArrayList<NameValuePair> nameValuePairs = new ArrayList<>();
            for (Map.Entry<String, String> entry : reqMap.entrySet()) {
                nameValuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
            //发送post请求
            response = httpClient.execute(httpPost);

            if (null == response) {
                return "请求撞库平台异常";
            }
            if (null != response.getStatusLine() && response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                result = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);

                return result;
            } else {
                log.error("bad response, result: {}", EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8));
            }
        } catch (Exception e) {
            log.error("=============[\"异常\"]======================", e);
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;

    }


    public String postRestTemplateForm(String url, MultiValueMap<String, String> params, JSONObject header) {
        try {
            HttpHeaders headers = new HttpHeaders();
            List<String> values = Lists.newArrayList();
            values.add("application/x-www-form-urlencoded");
            values.add(String.format("multipart/form-data;boundary=%s", RandomStringUtils.randomNumeric(14)));
            headers.put("Content-Type", values);
            List<MediaType> mediaTypeList = new ArrayList<>();
            mediaTypeList.add(MediaType.ALL);
            headers.setAccept(mediaTypeList);

            org.springframework.http.HttpEntity<MultiValueMap<String, String>> requestEntity = new org.springframework.http.HttpEntity<>(params, headers);

            ResponseEntity<JSONObject> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, JSONObject.class);
            if (null != response.getBody()) {
                return response.getBody().toJSONString();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("resttemplate表单提交失败:{}", ex.getLocalizedMessage());
        }
        return null;
    }


    public String postRestTemplateJson(String url, String jsonStr, Map<String, Object> headerMap) {
        try {
            HttpHeaders headers = new HttpHeaders();
            if (MapUtils.isNotEmpty(headerMap)) {
                for (Map.Entry<String, Object> entry : headerMap.entrySet()) {
                    final String key = entry.getKey();
                    final String value = (String) entry.getValue();
                    if (StringUtils.isAnyEmpty(key, value)) {
                        continue;
                    }
                    headers.add(key, value);
                }
            }
            MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
            headers.setContentType(type);
            headers.add("Accept", MediaType.APPLICATION_JSON.toString());
            // headers.add("GlobalId", globalId);
            org.springframework.http.HttpEntity<String> requestEntity = new org.springframework.http.HttpEntity<>(jsonStr, headers);
            return Objects.requireNonNull(restTemplate.postForObject(url, requestEntity, String.class));
        } catch (Exception ex) {
            log.error("resttemplate表单提交失败:{}", ex.getLocalizedMessage());
        }
        return null;
    }

    public String restTemplateMock(String url, String jsonStr) {
        String response = restTemplate.postForObject(url, jsonStr, String.class);
        log.info("response={}", response);
        return response;
    }


    public String postForJson(String url, String jsonStr, Map<String, Object> headerMap) {
        long start = System.currentTimeMillis();
        CloseableHttpResponse response = null;
        try {

            // 创建httpPost
            HttpPost httpPost = new HttpPost(url);
            if (MapUtils.isNotEmpty(headerMap)) {
                for (Map.Entry<String, Object> entry : headerMap.entrySet()) {
                    final String key = entry.getKey();
                    final String value = (String) entry.getValue();
                    if (StringUtils.isAnyEmpty(key, value)) {
                        continue;
                    }
                    httpPost.setHeader(key, value);
                }
            }
            httpPost.setHeader("Accept", "application/json");

            StringEntity entity = new StringEntity(jsonStr, "UTF-8");
            entity.setContentType("application/json");
            entity.setContentEncoding(new BasicHeader("Content-Type", "application/json"));
            httpPost.setEntity(entity);
            //发送post请求
            response = httpClient.execute(httpPost);

            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                String result = EntityUtils.toString(response.getEntity());
                log.debug("request success cost = {}， result = {}", System.currentTimeMillis() - start, result);
                return result;
            } else {
                log.error("bad response: {}", JSONObject.parseObject(EntityUtils.toString(response.getEntity())));
            }
        } catch (Exception e) {
            log.error("=============[\"异常\"]======================, e: {}", e);
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    public String post(String url, String jsonStr) {
        log.debug("url = " + url + " ,  json = " + jsonStr);
        long start = System.currentTimeMillis();
        CloseableHttpResponse response = null;
        String result = StringUtils.EMPTY;
        try {
            // 创建httpPost
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Accept", "application/json");

            StringEntity entity = new StringEntity(jsonStr, "UTF-8");
            entity.setContentType("application/json");
            entity.setContentEncoding(new BasicHeader("Content-Type", "application/json"));
            httpPost.setEntity(entity);
            //发送post请求
            response = httpClient.execute(httpPost);

            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                result = EntityUtils.toString(response.getEntity());
                log.debug("request success cost = {}， result = {}", System.currentTimeMillis() - start, result);
                return result;
            } else {
                log.error("bad response, result: {}", EntityUtils.toString(response.getEntity()));
            }
        } catch (Exception e) {
            log.error("=============[\"异常\"]======================, e: {}", e);
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public String get(String url) {
        HttpGet httpGet = new HttpGet(url);
        config(httpGet, null);
        return getResponse(httpGet);
    }

    public String getWithHeader(String url, Map<String, Object> header) {
        HttpGet httpGet = new HttpGet(url);
        config(httpGet, header);
        return getResponse(httpGet);
    }

    private String getResponse(HttpRequestBase request) {
        CloseableHttpResponse response = null;
        try {

            response = httpClient.execute(request,
                    HttpClientContext.create());
            HttpEntity entity = response.getEntity();
            String result = EntityUtils.toString(entity, "UTF-8");
            EntityUtils.consume(entity);

            return result;
        } catch (IOException e) {
            log.error("send http error", e);
            return "";
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }


        }
    }


    public JSONObject postForJsonObject(String url, String jsonStr) throws Exception {
        log.debug("url = " + url + " ,  json = " + jsonStr);
        long start = System.currentTimeMillis();
        // 创建httpPost
        HttpPost httpPost = new HttpPost(url);
        httpPost.setHeader("Accept", "application/json");

        StringEntity entity = new StringEntity(jsonStr, "UTF-8");
        entity.setContentType("application/json");
        entity.setContentEncoding(new BasicHeader("Content-Type", "application/json"));
        httpPost.setEntity(entity);
        //发送post请求
        CloseableHttpResponse response = httpClient.execute(httpPost);

        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            JSONObject result = JSONObject.parseObject(EntityUtils.toString(response.getEntity()));
            log.debug("request success cost = {}， result = {}", System.currentTimeMillis() - start, result);
            return result;
        } else {
            log.error("bad response: {}", JSONObject.parseObject(EntityUtils.toString(response.getEntity())));
        }

        return null;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        initPool();
    }

}

6 测试controller，get和post接口

package com.yg.resttemplate.controller;

import com.alibaba.fastjson.JSON;
import com.yg.resttemplate.service.RestTemplateService;
import com.yg.resttemplate.utils.HttpClientPoolUtils;
import lombok.extern.slf4j.Slf4j;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @Author suolong
 * @Date 2022/5/30 21:36
 * @Version 2.0
 */
@Slf4j
@RestController
@RequestMapping("resttemplate")
public class RestTemplateController {

    @Autowired
    RestTemplateService restTemplateService;

    @Autowired
    HttpClientPoolUtils httpClientPoolUtils;

    @GetMapping("/getRestTemplateTest")
    public String getRestTemplateTest() {
        log.info("I am getRestTemplateTest");
        return "I am getRestTemplateTest";
    }


    @PostMapping("/postRestTemplateTest")
    public String postRestTemplateTest(@RequestBody String msg) {
        String res = "I am postRestTemplateTest " + msg;
        log.info(res);
        return res;
    }

    @PostMapping("/select")
    public String select(@RequestParam Integer number) {
        String res = null;
        switch (number) {
            case 1:
                res = restTemplateService.restTemplateGet1();
                break;
            case 2:
                res = restTemplateService.restTemplatePost1();
                break;
            case 3:
                res = restTemplateService.restTemplateGet2();
                break;
            case 4:
                res = restTemplateService.restTemplatePost2();
                break;
            case 5:
                res = restTemplateService.restTemplateGet3();
                break;
            case 6:
                res = restTemplateService.restTemplatePost3();
                break;
            case 7:
                res = httpClientPoolUtils.postRestTemplateJson("http://resttemplate-feign/resttemplate/postRestTemplateTest", "I am yuange", null);
                break;
        }
        log.info(res);
        return res;
    }
}

7 转换插件

package com.yg.resttemplate.plugins;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import java.util.ArrayList;
import java.util.List;


public class CustomJacksonHttpMessageConverter extends MappingJackson2HttpMessageConverter {
    public CustomJacksonHttpMessageConverter() {
        this(Jackson2ObjectMapperBuilder.json().build());
    }

    public CustomJacksonHttpMessageConverter(ObjectMapper objectMapper) {
        super(objectMapper);
        // 这里是重点，增加支持的类型，看你的情况加
        // 我这里目前只需要加个 TEXT/PLAIN
        List<MediaType> mediaTypes = new ArrayList<>();
        mediaTypes.add(MediaType.ALL);
        setSupportedMediaTypes(mediaTypes);
    }
}

8 各种http测试方法

package com.yg.resttemplate.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author suolong
 * @Date 2022/5/30 21:31
 * @Version 2.0
 */
@Slf4j
@Service
public class RestTemplateService {

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Autowired
    private RestTemplate restTemplate;


    public String restTemplateGet1() {
        // 新建对象
        RestTemplate restTemplate = new RestTemplate();

        String response = restTemplate.getForObject("http://localhost:1994/resttemplate/getRestTemplateTest", String.class);
        log.info("response: {}", response);
        return response;
    }


    public String restTemplatePost1() {
        // 新建对象
        RestTemplate restTemplate = new RestTemplate();
        //请求目标地址
        String requestMsg = "方式一 POST 请求";
        String response = restTemplate.postForObject("http://localhost:1994/resttemplate/postRestTemplateTest", requestMsg, String.class);
        log.info("response: {}", response);
        return response;
    }


    public String restTemplateGet2() {
        // 获取IP地址
        ServiceInstance choose = loadBalancerClient.choose("resttemplate-feign");
        String url = String.format("http://%s:%s", choose.getHost(), choose.getPort() + "/resttemplate/getRestTemplateTest");
        log.info("url: {}", url);
        RestTemplate restTemplate = new RestTemplate();
        String response = restTemplate.getForObject(url, String.class);
        log.info("response: {}", response);
        return response;
    }


    public String restTemplatePost2() {
        // 获取IP地址
        ServiceInstance choose = loadBalancerClient.choose("resttemplate-feign");
        // 组装URL
        String url = String.format("http://%s:%s", choose.getHost(), choose.getPort() + "/resttemplate/postRestTemplateTest");
        RestTemplate restTemplate = new RestTemplate();
        String requestMsg = "方式二 POST loadBalancerClient";
        String response = restTemplate.postForObject(url, requestMsg, String.class);
        log.info("response: {}", response);
        return response;
    }


    public String restTemplateGet3() {

        String requestMsg = "方式三 GET";
        String response = restTemplate.getForObject("http://resttemplate-feign/resttemplate/getRestTemplateTest", String.class);
        log.info("response: {}", response);
        return response;
    }


    public String restTemplatePost3() {

        String requestMsg = "方式三 POST";
        String response = restTemplate.postForObject("http://resttemplate-feign/resttemplate/postRestTemplateTest", requestMsg, String.class);
        log.info("response: {}", response);
        return response;
    }
}

9 项目目录结构

项目测试

1 打开postman，选择1-7，输入测试的方法

        switch (number) {
            case 1:                                           //直接使用url调用
                res = restTemplateService.restTemplateGet1();
                break;
            case 2:                                          //直接使用url调用
                res = restTemplateService.restTemplatePost1();
                break;
            case 3:                                          //使用LoadBalancerClient自动选择一个url和port调用
                res = restTemplateService.restTemplateGet2();
                break;
            case 4:                                          //使用LoadBalancerClient自动选择一个url和port调用
                res = restTemplateService.restTemplatePost2();
                break;
            case 5:                                          //使用服务名自己调用
                res = restTemplateService.restTemplateGet3();
                break;
            case 6:                                          //使用服务名自己调用
                res = restTemplateService.restTemplatePost3();
                break;
            case 7:                                          //使用服务名自己调用
                res = httpClientPoolUtils.postRestTemplateJson("http://resttemplate-feign/resttemplate/postRestTemplateTest", "I am yuange", null);
                break;

心得

第一次使用RestTemplate调用feign，感觉还不错哦




作为程序员第 146 篇文章，每次写一句歌词记录一下，看看人生有几首歌的时间，wahahaha …

Lyric： 有一条热昏头的响尾蛇

时间是一种解药
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenFeign快速上手 与restTemplate简单比较
羽的博客
11-08 2416
OpenFeign     在使用restTemplate访问远程接口的时候，我们难以将接口管理起来，当接口变动的时候我们可能会修改多处。Spring Cloud 提供OpenFeign来解决这个问题。 (一) OpenFeign简介     OpenFeign是一种声明式、模板化的HTTP客户端。在Spring Cloud中使用OpenFeign，可以做到使用HTTP请求访问远程服务，就像调用本地方法一样的。 需要引入依赖：
使用RestTemplate进行feignclient调用
05-31
本文将深入探讨如何使用 RestTemplate 进行 FeignClient 调用。 首先，让我们了解什么是 RestTemplate。RestTemplate 是 Spring 提供的一个工具类，用于简化 RESTful 服务的客户端开发。它可以发送 GET、POST、PUT...
SpringCloud 利用 RestTemplate 或 Feign 发起http请求 请求服务提供者的接口
05-11 1144
2，服务远程调用 RestTemplate 3，RestTemplate常用方法: 3.1 Get请求之getForObject。以JSON形式自动化转换responseType指定返回类型 3.2 POST之postForObject 3.3 exchange自定义请求方式 Feign介绍: Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feign1,引入依赖 2，在服务启动类里添加注解开启Feign的功
微服务之间的调用方式RestTemplate和FeignClient
诚的博客
10-20 1051
SpringCloud服务间的调用有两种方式：RestTemplate和FeignClient。不管是什么方式，他都是通过REST接口调用服务的http接口，参数和结果默认都是通过jackson序列化和反序列化。因为Spring MVC的RestController定义的接口，返回的数据都是通过Jackson序列化成JSON数据。 一、RestTemplate 使用这种方式，只需要定义一个RestTemplate的Bean，设置成LoadBalanced即可。 如下示例： 1 2
org.springframework.web.client.HttpServerErrorException: 500服务器端HTTP调用错误的解决方法，亲测有效，嘿嘿嘿
最新发布
PythonAigc的博客
05-13 1751
org.springframework.web.client.HttpServerErrorException: 500 这个异常通常表示客户端在尝试与服务器进行HTTP通信时，服务器遇到了一个意外的情况，导致它无法完成请求。HTTP状态码500是服务器内部错误的标志，意味着服务器遇到了一个它没有预料到的情况，因此它无法完成请求。
JAVA使用RestTemplate类实现SSL双向/单向认证（国际）
qq_47275692的博客
03-28 3677
双向/单向认证、国际、SSL
FeignClient的调用过程
xueshanfeitian的博客
03-20 4082
前言 小猿对于远程调用一直感到非常神秘，今天小猿就视图解析一下远程调用的整个过程。 调用过程 1、在保证服务没有错误的前提下开始远程调用，首先程序会进入ReflectiveFeign中的invoke方法，并执行invoke函数中的先决条件验证，如果说toString方法或者hashCode方法一样再或者说是统一FeignClient，就不继续往下执行。 2、构建模板并开始调用远程方法并对放回结果进行解码 如果第一次请求失败，那么会启动重试机制，重试默认最大次数为5 3、记录相关日志，并调用client
微服务springcloud：eureka整合gateway、RestTemplate和FeignClient
11-15
3. 使用RestTemplate或FeignClient：在需要调用其他微服务的地方，我们可以通过RestTemplate直接构造请求，或者使用FeignClient定义接口，让Spring自动注入实现。 4. 配置FeignClient：在使用FeignClient的微服务中...
Java开发基于RestTemplate的微服务调用Demo源码(课程设计).zip
10-12
Java开发基于RestTemplate的微服务调用Demo源码(课程设计).zipJava开发基于RestTemplate的微服务调用Demo源码(课程设计).zipJava开发基于RestTemplate的微服务调用Demo源码(课程设计).zipJava开发基于RestTemplate的...
Spring cloud踩坑记录之使用feignclient远程调用服务404的方法
08-26
总的来说，解决FeignClient远程调用服务404的问题需要从服务注册、配置、接口定义、请求参数等多个角度进行排查。在微服务环境中，良好的日志记录和监控系统可以帮助快速定位问题，提升故障排查效率。
spring rest mvc使用RestTemplate调用
04-13
本文将深入探讨`RestTemplate`的使用方法，以及如何在实际项目中有效地利用它。 首先，`RestTemplate`是Spring对HTTP客户端的轻量级抽象，它简化了发送HTTP请求和处理响应的过程。通过`RestTemplate`，我们可以执行...
Spring Cloud - Feign RequestInterceptor 拦截器
牧码的博客
04-21 1971
代码案例 实现接口代码 注解方式代码 1、yml 配置：feign.client.config.default.requestInterceptors （会覆盖 Java 配置方式） 2、Application.java 全局配置：@EnableFeignClients 属性 defaultConfiguration = XXX.class 3、注解配置：@Configuration + @Bean4、@FeignClient 配置：属性 configuration = X
SpringCloud微服务之间的通讯，Feign和RestTemplate概念实例详解
alan_liuyue的博客
09-19 8809
前言： 在springcloud微服务的实际项目开发中，多个微服务之间不仅是相对独立的，而且也是相对关联的；也就是说，微服务之间需要相互访问，多个微服务之间的接口可能会被互相多次调用，我们称之为微服务之间的通信； 微服务之间的通信方式有很多，一般使用以下两种方法：一种是RestTemplate,另一种是Feign； 概念简介： RestTemplate，是spring中方便使用rest资源的...
远程调用（feignClient、restTemplate）设置header头信息
小葫芦的博客
08-06 1万+
现在基本上所有的接口都需要权限验证（token、session等），所以在远程调用时，也需要把相应的参数传递过去。 一、feignClient + jwt-token 增加拦截配置： import org.apache.commons.lang.StringUtils; import feign.RequestInterceptor; import feign.RequestTemplat...
Spring Cloud Open Feign系列【18】RequestTemplate（请求模板）源码分析
热门推荐
记录知识、锤炼自我
01-05 1万+
文章目录前言核心类RequestTemplate源码分析1. 进入工厂类2. 请求参数为对象【POST】3. 请求参数为对象【GET】4. @RequestParam 注解【GET】5. 转换为Request 前言 紧接上文，之前分析了方法处理器是如何进行加载及执行的，其中提到了，在调用Feign 接口方法时，会根据方法参数创建请求模板（RequestTemplate），接下来我们分析下这个是如何加载及执行的。 核心类 RequestTemplate Feign 中存在各种各样的模板类，RequestT
Springboot使用Feign客户端发送HTTP请求，代替​RestTemplate​远程调用
Xmi2599的博客
06-12 2663
在 Spring Boot 中，可以使用 Feign 来创建 HTTP 客户端，通过简单的注解方式即可实现服务间的远程调用。Feign是一种声明式、模板化的HTTP客户端，在往常的 HTTP 调用中，一直都是使用的官方提供的来进行远程调用，该调用方式将组装代码冗余到正常业务代码中，不够优雅，因此，可以考虑用Feign来替代。
Feign请求及响应拦截器
fivehundredyearsago的博客
06-11 1万+
feign请求响应拦截
微服务之间调用方式@FeignClient
核桃欠敲的博客
01-25 1万+
springboot微服务之间调用方式
使用@FeignClient进行微服务间调用
这里记录着我一点一滴的进步
01-15 1万+
通过@FeignClient注解可以调用外部微服务接口 总共分为5步： 第一步：加载Jar包 第二步：新建一个Feign接口类( ClearBatchFeign.java),并且注明接口实现类 第三步:创建一个Feign接口实现类（ClearBatchFeignFallback.java），实现Feign接口， 需要加上注解@Component自动注入 第四步，定义DTO类来接...
restTemplate进行远程调用
09-28
RestTemplate是Spring提供的一个远程调用工具，常常Eureka等组件一起使用。它可以用于发送HTTP请求并获取响应数据。在使用RestTemplate时，首先需要创建一个实例，并通过@Autowired注解将其注入到Controller中。然后可以使用RestTemplate的各种方法，如getForObject、postForObject等，来发送不同类型的请求。在远程调用时，需要指定请求的URL和返回的类型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值