【Feign】Feign重写Client，从服务注册中心动态获取服务，实现请求动态转发

最新推荐文章于 2024-05-16 17:32:43 发布
最新推荐文章于 2024-05-16 17:32:43 发布
阅读量1.7k 收藏 4
点赞数
文章标签： java spring cloud eureka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38602383/article/details/128588509
版权

对应场景：

  1. 服务注册中心（Nacos|Eureka）的服务个数是动态增减，服务是动态增加的。比如：消费服务A，消费服务B…，消费服务在Nacos上是动态增加的。
  2. 客户端调用，需要适配将请求转发到对应的消费服务上；

实现方式思路：

  1. feign接口配置中，在请求头（Headers）中添加需要转发到消费服务的名称；
  2. 在feignClient中，从请求头中获取到对应的服务名称，然后从服务注册中心检索到服务的ip和端口等信息，然后转发请求到对应的服务中。

feignClient重写代码如下：

  1. 请求feignClient
package feign;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.*;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.http.HttpStatus;
import org.springframework.util.Assert;
import org.springframework.web.util.UriComponentsBuilder;

import java.io.IOException;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
/**
 * feign client
 */
public class FeignCustomLoadBalancerClient implements Client {
    private static final Log LOG = LogFactory.getLog(FeignCustomLoadBalancerClient.class);

    private final Client delegate;

    private final LoadBalancerClient loadBalancerClient;

    private final LoadBalancerClientFactory loadBalancerClientFactory;

    private final String SERVICE_NAME_HEADER_KEY = "NACOS_SERVICE_NAME";


    public FeignCustomLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient, LoadBalancerClientFactory loadBalancerClientFactory) {
        this.delegate = delegate;
        this.loadBalancerClient = loadBalancerClient;
        this.loadBalancerClientFactory = loadBalancerClientFactory;
    }

    /**
     * 重写该方法=：支持动态从nacos上通过服务名称，获取对应服务信息
     */
    @Override
    public Response execute(Request request, Request.Options options) throws IOException {
        URI originalUri = URI.create(request.url());

        //从header中获取对应的服务名称
        Optional<String> optionalServiceId = request.headers().getOrDefault(SERVICE_NAME_HEADER_KEY, Collections.singletonList(originalUri.getHost())).stream().findFirst();

        String serviceId = null;
        if(optionalServiceId.isPresent()){
            serviceId = optionalServiceId.get();
            if(!serviceId.equals(originalUri.getHost())){
                request = buildRequest(request, UriComponentsBuilder.fromUri(originalUri).host(serviceId).toUriString());
            }
        }
        Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
        String hint = this.getHint(serviceId);
        DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(new RequestDataContext(LoadBalancerUtils.buildRequestData(request), hint));
        Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator.getSupportedLifecycleProcessors(this.loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class), RequestDataContext.class, ResponseData.class, ServiceInstance.class);
        supportedLifecycleProcessors.forEach((lifecycle) -> {
            lifecycle.onStart(lbRequest);
        });
        //通过serviceId检索服务信息：一般情况下，是注册在服务注册中心的对应服务名称（e.g:nacos|eureka）；
        ServiceInstance instance = this.loadBalancerClient.choose(serviceId, lbRequest);
        org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(instance);
        String message;
        if (instance == null) {
            message = "Load balancer does not contain an instance for the service " + serviceId;
            if (LOG.isWarnEnabled()) {
                LOG.warn(message);
            }

            supportedLifecycleProcessors.forEach((lifecycle) -> {
                lifecycle.onComplete(new CompletionContext(CompletionContext.Status.DISCARD, lbRequest, lbResponse));
            });
            return Response.builder().request(request).status(HttpStatus.SERVICE_UNAVAILABLE.value()).body(message, StandardCharsets.UTF_8).build();
        } else {
            message = this.loadBalancerClient.reconstructURI(instance, originalUri).toString();
            Request newRequest = this.buildRequest(request, message);
            LoadBalancerProperties loadBalancerProperties = this.loadBalancerClientFactory.getProperties(serviceId);
            return LoadBalancerUtils.executeWithLoadBalancerLifecycleProcessing(this.delegate, options, newRequest, lbRequest, lbResponse, supportedLifecycleProcessors, loadBalancerProperties.isUseRawStatusCodeInResponseData());
        }
    }

    protected Request buildRequest(Request request, String reconstructedUrl) {
        return Request.create(request.httpMethod(), reconstructedUrl, request.headers(), request.body(), request.charset(), request.requestTemplate());
    }

    public Client getDelegate() {
        return this.delegate;
    }

    private String getHint(String serviceId) {
        LoadBalancerProperties properties = this.loadBalancerClientFactory.getProperties(serviceId);
        String defaultHint = (String) properties.getHint().getOrDefault("default", "default");
        String hintPropertyValue = (String) properties.getHint().get(serviceId);
        return hintPropertyValue != null ? hintPropertyValue : defaultHint;
    }
}
  1. 重试RetryClient
package feign;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.*;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.cloud.openfeign.loadbalancer.LoadBalancerResponseStatusCodeException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpRequest;
import org.springframework.retry.RetryListener;
import org.springframework.retry.RetryPolicy;
import org.springframework.retry.backoff.BackOffPolicy;
import org.springframework.retry.backoff.NoBackOffPolicy;
import org.springframework.retry.policy.NeverRetryPolicy;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.util.Assert;
import org.springframework.util.StreamUtils;
import org.springframework.web.util.UriComponentsBuilder;

import java.io.IOException;
import java.net.URI;
import java.util.*;

public class RetryFeignCustomLoadBalancerClient implements Client{
    private static final Log LOG = LogFactory.getLog(RetryFeignCustomLoadBalancerClient.class);
    private final Client delegate;
    private final LoadBalancerClient loadBalancerClient;
    private final LoadBalancedRetryFactory loadBalancedRetryFactory;
    private final LoadBalancerClientFactory loadBalancerClientFactory;

    private final String SERVICE_NAME_HEADER_KEY = "NACOS_SERVICE_NAME";

    /** @deprecated */
    @Deprecated
    public RetryFeignCustomLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient, LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerProperties properties, LoadBalancerClientFactory loadBalancerClientFactory) {
        this.delegate = delegate;
        this.loadBalancerClient = loadBalancerClient;
        this.loadBalancedRetryFactory = loadBalancedRetryFactory;
        this.loadBalancerClientFactory = loadBalancerClientFactory;
    }

    public RetryFeignCustomLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient, LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory) {
        this.delegate = delegate;
        this.loadBalancerClient = loadBalancerClient;
        this.loadBalancedRetryFactory = loadBalancedRetryFactory;
        this.loadBalancerClientFactory = loadBalancerClientFactory;
    }

    public Response execute(Request request, Request.Options options) throws IOException {
        URI originalUri = URI.create(request.url());

        //从header中获取对应的服务名称
        Optional<String> optionalServiceId = request.headers().getOrDefault(SERVICE_NAME_HEADER_KEY, Collections.singletonList(originalUri.getHost())).stream().findFirst();

        String serviceId = null;
        if(optionalServiceId.isPresent()){
            serviceId = optionalServiceId.get();
            if(!serviceId.equals(originalUri.getHost())){
                request = buildRequest(request, UriComponentsBuilder.fromUri(originalUri).host(serviceId).toUriString());
            }
        }

        Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
        LoadBalancedRetryPolicy retryPolicy = this.loadBalancedRetryFactory.createRetryPolicy(serviceId, this.loadBalancerClient);
        RetryTemplate retryTemplate = this.buildRetryTemplate(serviceId, request, retryPolicy);

        String finalServiceId = serviceId;
        Request finalRequest = request;
        return (Response)retryTemplate.execute((context) -> {
            Request feignRequest = null;
            ServiceInstance retrievedServiceInstance = null;
            Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator.getSupportedLifecycleProcessors(this.loadBalancerClientFactory.getInstances(finalServiceId, LoadBalancerLifecycle.class), RetryableRequestContext.class, ResponseData.class, ServiceInstance.class);
            String hint = this.getHint(finalServiceId);
            DefaultRequest<RetryableRequestContext> lbRequest = new DefaultRequest<>(new RetryableRequestContext((ServiceInstance)null, LoadBalancerUtils.buildRequestData(feignRequest), hint));
            if (context instanceof LoadBalancedRetryContext) {
                LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext)context;
                ServiceInstance serviceInstance = lbContext.getServiceInstance();
                if (serviceInstance == null) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Service instance retrieved from LoadBalancedRetryContext: was null. Reattempting service instance selection");
                    }

                    ServiceInstance previousServiceInstance = lbContext.getPreviousServiceInstance();
                    ((RetryableRequestContext)lbRequest.getContext()).setPreviousServiceInstance(previousServiceInstance);
                    supportedLifecycleProcessors.forEach((lifecycle) -> {
                        lifecycle.onStart(lbRequest);
                    });
                    retrievedServiceInstance = this.loadBalancerClient.choose(finalServiceId, lbRequest);
                    if (LOG.isDebugEnabled()) {
                        LOG.debug(String.format("Selected service instance: %s", retrievedServiceInstance));
                    }

                    lbContext.setServiceInstance(retrievedServiceInstance);
                }

                if (retrievedServiceInstance == null) {
                    if (LOG.isWarnEnabled()) {
                        LOG.warn("Service instance was not resolved, executing the original request");
                    }

                    org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponsex = new DefaultResponse(retrievedServiceInstance);
                    supportedLifecycleProcessors.forEach((lifecycle) -> {
                        lifecycle.onComplete(new CompletionContext(CompletionContext.Status.DISCARD, lbRequest, lbResponsex));
                    });
                    feignRequest = finalRequest;
                } else {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug(String.format("Using service instance from LoadBalancedRetryContext: %s", retrievedServiceInstance));
                    }

                    String reconstructedUrl = this.loadBalancerClient.reconstructURI(retrievedServiceInstance, originalUri).toString();
                    feignRequest = this.buildRequest(finalRequest, reconstructedUrl);
                }
            }

            org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(retrievedServiceInstance);
            LoadBalancerProperties loadBalancerProperties = this.loadBalancerClientFactory.getProperties(finalServiceId);
            Response response = LoadBalancerUtils.executeWithLoadBalancerLifecycleProcessing(this.delegate, options, feignRequest, lbRequest, lbResponse, supportedLifecycleProcessors, retrievedServiceInstance != null, loadBalancerProperties.isUseRawStatusCodeInResponseData());
            int responseStatus = response.status();
            if (retryPolicy != null && retryPolicy.retryableStatusCode(responseStatus)) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug(String.format("Retrying on status code: %d", responseStatus));
                }

                byte[] byteArray = response.body() == null ? new byte[0] : StreamUtils.copyToByteArray(response.body().asInputStream());
                response.close();
                throw new LoadBalancerResponseStatusCodeException(finalServiceId, response, byteArray, URI.create(finalRequest.url()));
            } else {
                return response;
            }
        }, new LoadBalancedRecoveryCallback<Response, Response>() {
            protected Response createResponse(Response response, URI uri) {
                return response;
            }
        });
    }

    protected Request buildRequest(Request request, String reconstructedUrl) {
        return Request.create(request.httpMethod(), reconstructedUrl, request.headers(), request.body(), request.charset(), request.requestTemplate());
    }

    private RetryTemplate buildRetryTemplate(String serviceId, Request request, LoadBalancedRetryPolicy retryPolicy) {
        RetryTemplate retryTemplate = new RetryTemplate();
        BackOffPolicy backOffPolicy = this.loadBalancedRetryFactory.createBackOffPolicy(serviceId);
        retryTemplate.setBackOffPolicy((BackOffPolicy)(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy));
        RetryListener[] retryListeners = this.loadBalancedRetryFactory.createRetryListeners(serviceId);
        if (retryListeners != null && retryListeners.length != 0) {
            retryTemplate.setListeners(retryListeners);
        }

        retryTemplate.setRetryPolicy((RetryPolicy)(retryPolicy == null ? new NeverRetryPolicy() : new InterceptorRetryPolicy(this.toHttpRequest(request), retryPolicy, this.loadBalancerClient, serviceId)));
        return retryTemplate;
    }

    public Client getDelegate() {
        return this.delegate;
    }

    private HttpRequest toHttpRequest(Request request) {
        return new HttpRequest() {
            public HttpMethod getMethod() {
                return HttpMethod.resolve(request.httpMethod().name());
            }

            public String getMethodValue() {
                return this.getMethod().name();
            }

            public URI getURI() {
                return URI.create(request.url());
            }

            public HttpHeaders getHeaders() {
                Map<String, List<String>> headers = new HashMap();
                Map<String, Collection<String>> feignHeaders = request.headers();
                Iterator var3 = feignHeaders.keySet().iterator();

                while(var3.hasNext()) {
                    String key = (String)var3.next();
                    headers.put(key, new ArrayList((Collection)feignHeaders.get(key)));
                }

                HttpHeaders httpHeaders = new HttpHeaders();
                httpHeaders.putAll(headers);
                return httpHeaders;
            }
        };
    }

    private String getHint(String serviceId) {
        LoadBalancerProperties properties = this.loadBalancerClientFactory.getProperties(serviceId);
        String defaultHint = (String)properties.getHint().getOrDefault("default", "default");
        String hintPropertyValue = (String)properties.getHint().get(serviceId);
        return hintPropertyValue != null ? hintPropertyValue : defaultHint;
    }
}
  1. 负载工具类
package feign;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.CompletionContext;
import org.springframework.cloud.client.loadbalancer.LoadBalancerLifecycle;
import org.springframework.cloud.client.loadbalancer.RequestData;
import org.springframework.cloud.client.loadbalancer.ResponseData;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.util.MultiValueMap;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class LoadBalancerUtils {

    private LoadBalancerUtils() {
        throw new IllegalStateException("Can't instantiate a utility class");
    }

    static Response executeWithLoadBalancerLifecycleProcessing(Client feignClient,
                                                               Request.Options options,
                                                               Request feignRequest,
                                                               org.springframework.cloud.client.loadbalancer.Request lbRequest,
                                                               org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse,
                                                               Set<LoadBalancerLifecycle> supportedLifecycleProcessors,
                                                               boolean loadBalanced,
                                                               boolean useRawStatusCodes) throws IOException {
        supportedLifecycleProcessors.forEach((lifecycle) -> {
            lifecycle.onStartRequest(lbRequest, lbResponse);
        });

        try {
            Response response = feignClient.execute(feignRequest, options);
            if (loadBalanced) {
                supportedLifecycleProcessors.forEach((lifecycle) -> {
                    lifecycle.onComplete(new CompletionContext(CompletionContext.Status.SUCCESS, lbRequest, lbResponse, buildResponseData(response)));
                });
            }

            return response;
        } catch (Exception var9) {
            if (loadBalanced) {
                supportedLifecycleProcessors.forEach((lifecycle) -> {
                    lifecycle.onComplete(new CompletionContext(CompletionContext.Status.FAILED, var9, lbRequest, lbResponse));
                });
            }

            throw var9;
        }
    }

    static ResponseData buildResponseData(Response response) {
        HttpHeaders responseHeaders = new HttpHeaders();
        response.headers().forEach((key, value) -> {
            responseHeaders.put(key, new ArrayList(value));
        });
        return  new ResponseData(HttpStatus.resolve(response.status()),responseHeaders, null,buildRequestData(response.request()));
    }

    static RequestData buildRequestData(Request request) {
        HttpHeaders requestHeaders = new HttpHeaders();
        request.headers().forEach((key, value) -> {
            requestHeaders.put(key, new ArrayList(value));
        });
        return new RequestData(HttpMethod.resolve(request.httpMethod().name()), URI.create(request.url()), requestHeaders, (MultiValueMap)null, new HashMap());
    }

    static Response executeWithLoadBalancerLifecycleProcessing(Client feignClient,
                                                               Request.Options options,
                                                               Request feignRequest,
                                                               org.springframework.cloud.client.loadbalancer.Request lbRequest,
                                                               org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse,
                                                               Set<LoadBalancerLifecycle> supportedLifecycleProcessors,
                                                               boolean useRawStatusCodes) throws IOException {
        return executeWithLoadBalancerLifecycleProcessing(feignClient, options, feignRequest, lbRequest, lbResponse, supportedLifecycleProcessors, true, useRawStatusCodes);
    }
}
  1. 将重写的Client 注入到IOC容器中；替代Feign默认的负载客户端；
package feign;

import feign.okhttp.OkHttpClient;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.cloud.openfeign.clientconfig.OkHttpFeignConfiguration;
import org.springframework.cloud.openfeign.loadbalancer.RetryableFeignBlockingLoadBalancerClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;

@Configuration
public class FeignCustomLoadBalancerConfiguration {

    @ConditionalOnClass(OkHttpClient.class)
    @ConditionalOnProperty("feign.okhttp.enabled")
    @Configuration(proxyBeanMethods = false)
    @Import(OkHttpFeignConfiguration.class)
    static class OkHttpConfiguration{
        @Bean
        @Primary
        @ConditionalOnProperty(
                value = {"spring.cloud.loadbalancer.retry.enabled"},
                havingValue = "false"
        )
        public Client feignClient(okhttp3.OkHttpClient okHttpClient, LoadBalancerClient loadBalancerClient, LoadBalancerClientFactory loadBalancerClientFactory) {
            OkHttpClient delegate = new OkHttpClient(okHttpClient);
            return new FeignCustomLoadBalancerClient(delegate, loadBalancerClient, loadBalancerClientFactory);
        }

        @Bean
        @Primary
        @ConditionalOnClass(
                name = {"org.springframework.retry.support.RetryTemplate"}
        )
        @ConditionalOnProperty(
                value = {"spring.cloud.loadbalancer.retry.enabled"},
                havingValue = "true",
                matchIfMissing = true
        )
        public Client feignRetryClient(LoadBalancerClient loadBalancerClient, okhttp3.OkHttpClient okHttpClient, LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory) {
            OkHttpClient delegate = new OkHttpClient(okHttpClient);
            return new RetryFeignCustomLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory, loadBalancerClientFactory);
        }
    }


    @EnableConfigurationProperties({LoadBalancerClientsProperties.class})
    @ConditionalOnProperty( value = "feign.okhttp.enabled",
            havingValue = "false",
            matchIfMissing = true
    )
    @Configuration(proxyBeanMethods = false)
    static class customDefaultFeignLoadBalancerConfiguration{

        @Bean
        @Primary
        @ConditionalOnProperty(
                value = {"spring.cloud.loadbalancer.retry.enabled"},
                havingValue = "false"
        )
        public Client feignClient(okhttp3.OkHttpClient okHttpClient, LoadBalancerClient loadBalancerClient, LoadBalancerClientFactory loadBalancerClientFactory) {
            return new FeignCustomLoadBalancerClient(new Client.Default(null,null), loadBalancerClient, loadBalancerClientFactory);
        }

        @Bean
        @Primary
        @ConditionalOnClass(
                name = {"org.springframework.retry.support.RetryTemplate"}
        )
        @ConditionalOnProperty(
                value = {"spring.cloud.loadbalancer.retry.enabled"},
                havingValue = "true",
                matchIfMissing = true
        )
        public Client feignRetryClient(LoadBalancerClient loadBalancerClient, okhttp3.OkHttpClient okHttpClient, LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory) {
            return new RetryableFeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient, loadBalancedRetryFactory, loadBalancerClientFactory);
        }

    }


}
  1. 在对应的Feign接口的配置中，Configuration或者全局的Intercepter中，在请求头中添加上述示例中的"NACOS_SERVICE_NAME"信息；

package feign;

import org.springframework.context.annotation.Configuration;

@Configuration
public class FeignInterceptor implements RequestInterceptor{

    private final String SERVICE_NAME_HEADER_KEY = "NACOS_SERVICE_NAME";

    @Override
    public void apply(RequestTemplate requestTemplate) {
        //其他操作
        //在header中写入需要将请求转发到对应的服务的服务名称；
        requestTemplate.header(SERVICE_NAME_HEADER_KEY,"xxxx");
    }
}
stay_running
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringCloud Feign服务调用请求方式总结
08-19
SpringCloud Feign服务调用请求方式总结 SpringCloud Feign服务调用请求方式总结主要介绍了Feign服务调用方式的概要，通过示例代码进行了详细的介绍，对大家的学习或者工作具有一定的参考学习价值。 Feign服务...
Feign客户端调用服务遇到的问题
qq_31404603的博客
03-12 6644
feign客户端调用eureka服务时首先会在注册中心获取服务列表，从而确定服务基本信息以及地址信息，所以首先必须保证你的feign客户端是可以注册到eureka注册中心上的，单独注册feign客户端服务是可以注册进去。 在2.0之后feign客户端依赖信息修改，2019-03-12的依赖信息（当日亲测可用）： &lt;?xml version="1.0" encoding="UTF-8"?...
feign源码解析--fegin的执行过程
Instanceztt的博客
07-11 2081
通过上篇文章分析我们知道,fegin客户端在初始化的时候,会通过jdk动态代理未为每个feignClient生成一个代理类,jdk动态代理主要是通过InvocationHandler接口的实现代理的增强.我们来看看生成代理时InvocationHandler接口的实现是如何创建的 通过InvocationHandlerFactory 我们可以发现创建的是ReflectiveFeign.FeignInvocationHandler,通过ReflectiveFeign.FeignInvocationHandle
OpenFeign和Nacos实现注册中心、远程调用_openfeign注册中心
2301_77033340的博客
05-16 228
server-addr: 192.168.150.101:8848 # nacos地址。@FeignClient(“item-service”)//参数值：配置文件的服务名称。//ItemDTO远程调用的返回值类型 ，Collection ids传递的参数。@GetMapping(“/items”)//远程调用接口的请求方式，url。name: item-service # 服务名称。OK http 的依赖。
【无标题】
qq_33815591的博客
08-16 1264
【代码】【无标题】
重写feign客户端实现本地与开发/测试环境联调
c10498的博客
09-04 808
重写feign客户端实现本地与开发/测试环境联调。
使用nacos作为注册中心实现@FeignClient
qq_45752401的博客
08-23 4922
创建两个工程，一个接口提供者，一个接口调用者 接口提供者环境准备 1，pom.xml <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> <!-- Spring Cloud 版本信息 --> <sp
Spring boot2X Consul如何使用Feign实现服务调用
08-25
主要介绍了spring boot2X Consul如何使用Feign实现服务调用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring cloud 之 Feign 使用HTTP请求远程服务的实现方法
08-30
Spring Cloud 之 Feign 使用 HTTP 请求远程服务的实现方法 Feign 是一种声明式、模板化的 HTTP 客户端，用于简化微服务之间的远程调用。在 Spring Cloud 中使用 Feign，可以实现与调用本地方法一样的编码体验，...
SpringCloud Feign 服务调用的实现
08-26
Feign是一个声明性web服务客户端。本文记录多个服务之间使用Feign调用，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
基于Dockerfile的云车间-feign Java服务设计源码
最新发布
05-25
本源码为基于Dockerfile的云车间-feign Java服务设计，包含58个Java文件、4个YAML文件等，共64个文件。该项目旨在为用户提供一个全面、便捷的云车间-feign Java服务解决方案，通过Dockerfile和Java技术的结合，为...
feign 根据环境动态指定服务名
wangooo的博客
08-27 9081
分布式系统中，网关层或应用层调用后端的微服务，大家普遍使用SpringCloud Feign去调用，过程简单方便。 开发环境和测试环境共用一套nacos，通过服务提供方的serviceId加环境后缀作为区分，比如基础信息服务其开发环境serviceId为 baseinfo-dev，测试环境为 baseinfo-test。每次服务提供方发布的时候，会根据发布环境，手动的更改serviceId。 消费方feign调用时，直接通过 @FeignClient(name = "baseinfo-dev")
【feign】重写OpenFeign的Client记录日志
hkk666123的博客
03-24 1850
文章目录概述重写`FeignClient`记录日志在FeignClient中配置编写FeignConfiguration重写Client使用`Aspect`切面记录日志参考 概述 项目里使用了Feign进行远程调用，有时为了便于排查问题，需要记录请求和响应日志，下面简介一下如何保存Feign日志到数据库(Redis/MongoDB)： 重写FeignClient记录日志 使用Aspect切面记录日志 本文依赖: spring-boot-starter-parent:2.4.2 spring-clou
Eureka注册中心 与 OpenFeign调用接口
宋冠巡的博客
07-27 2254
# 需求 一个应用通过接口，调用另一个应用的接口。使用OpenFeign来实现接口调用。 # 说明 通过OpenFeign（本文接下来简称Feign）调用远程接口，需要Eureka注册中心的支持。
Feign 微服务调用 (nacos 作为注册中心)
MXqihang的博客
05-08 2836
Feign 微服务调用 (nacos 作为注册中心) Feign 是 spring Cloud Netflix 组件中的一量级 Restful的HTTP 服务客户端，实现了负载均衡和 Rest 调用的开源框架，封装了Ribbon和RestTemplate,实现WebService的面向接口编程。 Feign 简化了RestTemplate代码，是声明式服务调用组件：核心就是像调用本地方法一样调用远程方法。让开发者无需关注，远程调用过程，和交互细节。 Feign 本身并不支持spring MVC注解，它有一
【Feign】HTTP服务远程调用学习记录
m0_46628950的博客
10-24 812
自定义配置一般修改日志，日志可以yml文件和bean注入配合注解使用。
feign动态服务名、路径(亲测可用)
qq_48721706的博客
03-20 5764
业务：同一个服务，需要部署在两台服务器上，连的是同一个nacos，现需要根据配置，将数据存储在各自服务器上,所以我们需要将其中一个服务改个服务名和路径部署，需要在业务上就判断他是存在属于哪个服务上的，才能去调用那个服务的feign接口。重新再放个feign接口也不动态，万一后面又加了很多个服务，又要改代码，所以我们的解决办法就是动态服务名和路径。 我们都知道feign调用的时候路径是 http://服务名/路径 / 所以我们如果要动态的调用，就需要替换服务名和路径。 1、新增替换url的配置 就是把有/
实现feign接口并重写里面的方法 有什么用
06-13
实现Feign接口并重写其中的方法的主要目的是为了自定义Feign客户端的行为，以满足特定的业务需求。 通过继承Feign接口并重写其中的方法，我们可以实现以下功能： 1. 自定义请求头和请求参数。我们可以在重写的方法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

stay_running

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值