Feign框架的初步了解和Feign代理对象的加载过程

xl649138628

于 2024-09-25 19:26:33 发布

阅读量768

点赞数 17

本文链接：https://blog.csdn.net/xl649138628/article/details/141365997

版权

java 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

Feign

1 篇文章 0 订阅

订阅专栏

springcloud作为近来最为流行的分布式框架在众多的项目中被使用。通过AI搜索引擎搜索我们可以得到如下结果：

Feign是一个声明式的Web Service客户端，它的主要目的是让Web Service调用变得更加简单。以下是对Feign的详细介绍：

一、Feign的基本概念和特点

概念：Feign的英文表意为“假装，伪装，变形”，是一个HTTP请求调用的轻量级框架。它以Java接口注解的方式调用HTTP请求，而不需要像传统方式那样通过封装HTTP请求报文直接调用。
特点：
- 声明式调用：通过简单的接口和注解来定义HTTP请求，让调用过程更加直观和简洁。
- 模板化请求：Feign通过处理注解，将请求模板化。在实际调用时，传入参数，根据参数再应用到请求上，进而转化成真正的请求。
- 集成Ribbon和Eureka：Feign默认集成了Ribbon，支持负载均衡；同时，它也支持Eureka，可以很容易地与Spring Cloud生态中的服务发现组件集成。
- 支持多种注解：Feign不仅支持Spring MVC注解，还支持JAX-RS注解，提供了更灵活的注解支持。

二、Feign的使用场景

微服务调用：在微服务架构中，Feign可以用于服务之间的调用，使得服务间的通信更加简单和高效。
HTTP客户端：Feign也可以作为一个独立的HTTP客户端使用，通过配置不同的解码器和编码器，支持多种HTTP请求和响应格式。

三、Feign的基本使用步骤

添加依赖：在项目的pom.xml文件中添加Feign的依赖。
开启Feign客户端扫描：在Spring Boot的启动类上添加@EnableFeignClients注解，以开启Feign客户端的扫描。
定义Feign接口：创建一个接口，并使用@FeignClient注解来配置它。在该接口中，使用Spring MVC注解来定义HTTP请求的方法。
注入Feign客户端：在服务消费者中，通过@Autowired注解注入Feign客户端接口，然后就可以像调用本地方法一样调用远程服务了。

四、Feign的底层原理

动态代理：Feign底层通过基于面向接口的动态代理方式生成实现类，将请求调用委托给动态代理实现类。
解析注解：Feign根据接口类上的方法和注解，解析成内部的MethodHandler处理方式，进而转换成HTTP请求。
发送请求：通过配置的客户端（如HttpClient、OkHttp等）发送HTTP请求，并接收响应结果。

五、Feign的优化

开启日志：可以通过配置Feign的日志级别来查看请求和响应的详细信息，有助于调试和排错。
超时设置：Feign的负载均衡底层使用的是Ribbon，因此可以通过配置Ribbon的超时时间来设置Feign的请求超时时间。
连接池：Feign支持配置HTTP连接池，以提高请求的性能和稳定性。

六、Feign框架的加载逻辑

Feign是一个功能强大的HTTP客户端，它通过声明式的方式简化了服务间的调用过程。在微服务架构中，Feign的使用可以大大提高开发效率和系统的可维护性。同时，Feign也提供了丰富的配置选项和扩展点，以满足不同场景下的需求。

Feign的英文表意为“假装，伪装，变形”，是一个HTTP请求调用的轻量级框架可以集成到springcloud中。它以Java接口注解的方式调用HTTP请求，而不需要像传统方式那样通过封装HTTP请求报文直接调用。

本文主要讲解Feign代理对象的组装和生成过程。

在pom文件中引入以下依赖：

 <properties>
        <feign.version>8.18.0</feign.version>
    </properties> 
<!--feign-->
        <dependency>
            <groupId>com.netflix.feign</groupId>
            <artifactId>feign-jackson</artifactId>
            <version>${feign.version}</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.feign</groupId>
            <artifactId>feign-core</artifactId>
            <version>${feign.version}</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.feign</groupId>
            <artifactId>feign-httpclient</artifactId>
            <version>${feign.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>3.1.2</version> <!-- 使用合适的版本 -->
        </dependency>

在Application启动类中加入@EnableFeignClients注解。

@SpringBootApplication
@EnableSwagger2
@EnableFeignClients
@ComponentScans(value={@ComponentScan(value="com.changshin.xu")})
public class Application {

    public static void main(String[] args) {
        try {
            SpringApplication.run(Application.class, args);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

点击@EnableFeignClients注解可见如下内容：

@Import({FeignClientsRegistrar.class})
public @interface EnableFeignClients {

通过@Import注解，FeignClientsRegistrar会在服务器启动时被spring容器扫描到。进入FeignClientsRegistrar类。可以看到以下方法。当FeignClientsRegistrar被扫描到后会调用以下的registerBeanDefinitions方法。

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        //注册的默认的配置信息，主要是向容器中注入通过EnableFeignClients申明的配置信息
        this.registerDefaultConfiguration(metadata, registry);
        //向容器中注入FeignClient对象即FeignClient的代理对象。
        this.registerFeignClients(metadata, registry);
    }

分析registerFeignClients方法。

    public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        //创建组件扫描类
        ClassPathScanningCandidateComponentProvider scanner = this.getScanner();
        scanner.setResourceLoader(this.resourceLoader);
        Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
        //创建注解类型过滤器
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
        Class<?>[] clients = attrs == null ? null : (Class[])((Class[])attrs.get("clients"));
        Object basePackages;
        if (clients != null && clients.length != 0) {
            final Set<String> clientClasses = new HashSet();
            basePackages = new HashSet();
            Class[] var9 = clients;
            int var10 = clients.length;

            for(int var11 = 0; var11 < var10; ++var11) {
                Class<?> clazz = var9[var11];
                ((Set)basePackages).add(ClassUtils.getPackageName(clazz));
                clientClasses.add(clazz.getCanonicalName());
            }

            AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
                protected boolean match(ClassMetadata metadata) {
                    String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                    return clientClasses.contains(cleaned);
                }
            };
            scanner.addIncludeFilter(new FeignClientsRegistrar.AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
        } else {
            //设置过滤器
            scanner.addIncludeFilter(annotationTypeFilter);
            //获取要扫描的包列表，EnableFeignClients注解中的basePackages和basePackageClasses属性中声明的包会读取并去重放到列表中，如果basePackages和basePackageClasses属性都没有申明，则使用basePackages的值是EnableFeignClients注解使用的目录即Application启动类所在的包。
            basePackages = this.getBasePackages(metadata);
        }

        Iterator var17 = ((Set)basePackages).iterator();

        while(var17.hasNext()) {
            String basePackage = (String)var17.next();
            //获取basePackages包列表下所有的bean定义并根据AnnotationTypeFilter过滤类型为FeignClient的bean定义
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
            Iterator var21 = candidateComponents.iterator();

            while(var21.hasNext()) {
                BeanDefinition candidateComponent = (BeanDefinition)var21.next();
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition)candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");
                    Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());
                    //获取feignclient的名称默认使用@FeignClient中申明的value值
                    String name = this.getClientName(attributes);
                    //向spring容器中注入FeignClient配置
                    this.registerClientConfiguration(registry, name, attributes.get("configuration"));
                    //向容器中注入FeignClient类型的bean
                    this.registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }

    }

分析registerFeignClient方法，在该方法中重点关注FeignClientFactoryBean类。

    private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        String className = annotationMetadata.getClassName();
        //申明一个bean定义构建者，该bean定义对应的beanClass为FeignClientFactoryBean
        BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
        //校验FeignClient注解中的fallback和fallbackFactory属性
        this.validate(attributes);
        //bean定义设置属性值url，该url对应的值为FeignClient注解中的申明的url
        definition.addPropertyValue("url", this.getUrl(attributes));
        definition.addPropertyValue("path", this.getPath(attributes));
        String name = this.getName(attributes);
        definition.addPropertyValue("name", name);
        definition.addPropertyValue("type", className);
        definition.addPropertyValue("decode404", attributes.get("decode404"));
        definition.addPropertyValue("fallback", attributes.get("fallback"));
        definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
        definition.setAutowireMode(2);
        //生成别名
        String alias = name + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
        boolean primary = (Boolean)attributes.get("primary");
        beanDefinition.setPrimary(primary);
        String qualifier = this.getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }
        //设置bean定义持有者，定义了bean定义的对应的bean名和对应的别名
        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[]{alias});
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

FeignClientFactoryBean是一个特殊的类。该类实现了FactoryBean。如果一个 Bean 实现了此接口，它将被用作要公开的对象的工厂，而不是直接用作将自身公开的 Bean 实例。在spring容器加载的时候在FactoryBean中的getObject方法用于返回一个bean的实例。FeignClientFactoryBean类的getObject方法。

 public Object getObject() throws Exception {
        return this.getTarget();
    }

分析getTarget方法。

    <T> T getTarget() {
        FeignContext context = (FeignContext)this.applicationContext.getBean(FeignContext.class);
        Builder builder = this.feign(context);
        String url;
        if (!StringUtils.hasText(this.url)) {
            if (!this.name.startsWith("http")) {
                url = "http://" + this.name;
            } else {
                url = this.name;
            }

            url = url + this.cleanPath();
            return this.loadBalance(builder, context, new HardCodedTarget(this.type, this.name, url));
        } else {
            if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
                this.url = "http://" + this.url;
            }

            url = this.url + this.cleanPath();
            Client client = (Client)this.getOptional(context, Client.class);
            if (client != null) {
                if (client instanceof LoadBalancerFeignClient) {
                    client = ((LoadBalancerFeignClient)client).getDelegate();
                }

                builder.client(client);
            }

            Targeter targeter = (Targeter)this.get(context, Targeter.class);
            return targeter.target(this, builder, context, new HardCodedTarget(this.type, this.name, url));
        }
    }

在getTarget方法返回的是ReflectiveFeign类型的对象。下面我们对getTarget方法重点分析。

在spring.factories文件中可以看到将FeignAutoConfiguration类引入了spring容器管理。在该类可以看到以下内容。

    @Bean
    public FeignContext feignContext() {
        FeignContext context = new FeignContext();
        context.setConfigurations(this.configurations);
        return context;
    }

该方法向spring容器注入了一个FeignContext类型的对象。

继续分析getTarget方法，在该方法中的Builder builder = this.feign(context);这段代码中继续进入可以发现调用了以下代码

    protected Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = (FeignLoggerFactory)this.get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);
        Builder builder = ((Builder)this.get(context, Builder.class)).logger(logger).encoder((Encoder)this.get(context, Encoder.class)).decoder((Decoder)this.get(context, Decoder.class)).contract((Contract)this.get(context, Contract.class));
        this.configureFeign(context, builder);
        return builder;
    }

分析以下代码
Builder builder = ((Builder)this.get(context, Builder.class)).logger(logger).encoder((Encoder)this.get(context, Encoder.class)).decoder((Decoder)this.get(context, Decoder.class)).contract((Contract)this.get(context, Contract.class));

继续查看this.get方法发现在该方法内部调用了T instance = context.getInstance(this.name, type);

方法。在该方法中获取到了Build类型的bean对象。

该对象是在FeignClientsConfiguration类中通过以下代码注入的。

    @Bean
    @Scope("prototype")
    @ConditionalOnMissingBean
    public Builder feignBuilder(Retryer retryer) {
        return Feign.builder().retryer(retryer);
    }

在上面的代码中初始化了一个Feign调用中重要的属性。

比如拦截器、日志级别、客户端、编码器、解码器等。

然后调用this.configureFeign(context, builder)方法将FeignClientProperties配置的属性值赋值给Builder。

继续分析getTarget方法。我们发现根据@FeignClient里配置的url属性是否存在分别走负载均衡和普通的发送请求功能。

我们先分析走负载均衡的代码即if部分的内容在getTarget方法中的下面一段代码

return this.loadBalance(builder, context, new HardCodedTarget(this.type, this.name, url));、

返回了一个Targeter,如果Feign打开了hystrix则返回的时HystrixTargeter,没有打开返回的是DefaultTargeter。

    @Configuration
    @ConditionalOnMissingClass({"feign.hystrix.HystrixFeign"})
    protected static class DefaultFeignTargeterConfiguration {
        protected DefaultFeignTargeterConfiguration() {
        }

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new DefaultTargeter();
        }
    }

    @Configuration
    @ConditionalOnClass(
        name = {"feign.hystrix.HystrixFeign"}
    )
    protected static class HystrixFeignTargeterConfiguration {
        protected HystrixFeignTargeterConfiguration() {
        }

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new HystrixTargeter();
        }
    }

本文以DefaultTargeter进行分析。

查看loadBalance方法。

 protected <T> T loadBalance(Builder builder, FeignContext context, HardCodedTarget<T> target) {
        Client client = (Client)this.getOptional(context, Client.class);
        if (client != null) {
            builder.client(client);
            Targeter targeter = (Targeter)this.get(context, Targeter.class);
            return targeter.target(this, builder, context, target);
        } else {
            throw new IllegalStateException("No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
        }
    }

在上面的方法中this.get返回的是DefaultTargeter类型，跟踪DefaultTargeter的target方法

public <T> T target(Target<T> target) {
            return this.build().newInstance(target);
        }

        public Feign build() {
            Factory synchronousMethodHandlerFactory = new Factory(this.client, this.retryer, this.requestInterceptors, this.logger, this.logLevel, this.decode404);
            ParseHandlersByName handlersByName = new ParseHandlersByName(this.contract, this.options, this.encoder, this.decoder, this.errorDecoder, synchronousMethodHandlerFactory);
            return new ReflectiveFeign(handlersByName, this.invocationHandlerFactory);
        }

发现this.build方法返回的是一个ReflectiveFeign类的实例。this.build().newInstance方法调用的是

ReflectiveFeign类里的newInstance方法。分析ReflectiveFeign类里的newInstance方法

    public <T> T newInstance(Target<T> target) {
      
        Map<String, MethodHandler> nameToHandler = this.targetToHandlersByName.apply(target);
        Map<Method, MethodHandler> methodToHandler = new LinkedHashMap();
        List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList();
        Method[] var5 = target.type().getMethods();
        int var6 = var5.length;

        for(int var7 = 0; var7 < var6; ++var7) {
            Method method = var5[var7];
            if (method.getDeclaringClass() != Object.class) {
                if (Util.isDefault(method)) {
                    DefaultMethodHandler handler = new DefaultMethodHandler(method);
                    defaultMethodHandlers.add(handler);
                    methodToHandler.put(method, handler);
                } else {
                    methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
                }
            }
        }
        
        InvocationHandler handler = this.factory.create(target, methodToHandler);
        T proxy = Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);
        Iterator var12 = defaultMethodHandlers.iterator();

        while(var12.hasNext()) {
            DefaultMethodHandler defaultMethodHandler = (DefaultMethodHandler)var12.next();
            defaultMethodHandler.bindTo(proxy);
        }

        return proxy;
    }

this.targetToHandlersByName.apply(target)方法中可以找到以下代码块

List<MethodMetadata> metadata = this.contract.parseAndValidatateMetadata(key.type());

上面的代码块根据key.type获取到了HardCodedTarget中的type类型即FeignClient注解所在的类名。type的值是在FeignClientsRegistrar类中的registerFeignClient方法中设置到bean属性里的。设置的值是@FeignClient注解类的类名。

然后通过parseAndValidatateMetadata得到了方法的元数据。

this.factory.create(key, md, (Factory)buildTemplate, this.options, this.decoder, this.errorDecoder)

该代码块调用了SynchronousMethodHandler类中的create方法

 public MethodHandler create(Target<?> target, MethodMetadata md, feign.RequestTemplate.Factory buildTemplateFromArgs, Options options, Decoder decoder, ErrorDecoder errorDecoder) {
            return new SynchronousMethodHandler(target, this.client, this.retryer, this.requestInterceptors, this.logger, this.logLevel, md, buildTemplateFromArgs, options, decoder, errorDecoder, this.decode404);
        }

返回了一个SynchronousMethodHandler类型的实例，该实例代理了target,即前面上送过来的HardCodedTarget。

那么在ReflectiveFeign类里的newInstance方法中的以下代码

result.put(md.configKey(), this.factory.create(key, md, (Factory)buildTemplate, this.options, this.decoder, this.errorDecoder))
该代码实际上存放的是以类名+方法名+入参拼接的字符串为key,SynchronousMethodHandler实例为value的Map

Map<Method, MethodHandler> methodToHandler = new LinkedHashMap();通过下面的循环存放的是以方法对象为key,SynchronousMethodHandler类型实例的MAP.

继续分析

InvocationHandler handler = this.factory.create(target, methodToHandler);

方法。

InvocationHandler create(Target var1, Map<Method, InvocationHandlerFactory.MethodHandler> var2);

    public static final class Default implements InvocationHandlerFactory {
        public Default() {
        }

        public InvocationHandler create(Target target, Map<Method, InvocationHandlerFactory.MethodHandler> dispatch) {
            return new FeignInvocationHandler(target, dispatch);
        }
    }

该方法返回了一个FeignInvocationHandler类型的对象。

继续分析

T proxy = Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);

该方法声明了一个代理类，当target实例（HardCodedTarget）执行时，实际执行的时handler

即FeignInvocationHandler。

在分析FeignClientFactoryBean里的getTarget方法里的ifelse里的else部分我们发现逻辑和loadBalance方法中相同。区别在于loadBalance中的client是负载均衡类型client。而else部分设置的client是负载均衡类型client的委托类。即else部分不走负载均衡走普通的client。

综上：也就是说loadBalance方法返回的是FeignInvocationHandler类型的代理类。