springboot的feign调用指定IP springboot feign原理

转载

mob6454cc6d3e23 2024-04-26 14:19:20

文章标签 源码学习 openfeign openFeign工作原理 spring 初始化 文章分类 架构后端开发

一、SpringBoot中使用 openFeign

在SpringBoot项目中使用openFeign是很简单的，只需要四步

1-1、导入pom文件

<dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-openfeign</artifactId>
     <version>2.1.3.RELEASE</version>
 </dependency>

1-2、在启动类加入开启feign注解

@EnableFeignClients

1-3、在具体的接口上加feign注解标签

@FeignClient(value = "backend", url = "${marketCloudBackend.url}", configuration = BackendFeignConfiguration.class)
public interface MarketCloudBackendFeign {

    @PostMapping(value = "/visitor/aiCallDisVisitor", consumes = "application/json", produces = "application/json")
    Object distributePublicCustomer(@RequestBody T params);
}

1-4、在使用的地方注入

@Resource
private MarketCloudBackendFeign marketCloudBackendFeign;

二、openFeign的工作原理

我们知道openfeign是一个rpc远程调用框架，目的是使的我们调用接口和调用本地方法一样简单，本质上还是需要http请求。

openFeign是通过jdk代理来实现这个操作的，下面我们将通过源码一步步探寻它的运作原理。

我们的目的很简单，因为我们在使用的时候是直接进行注入的，我们只需要知道每一个接口是如何被注入到Spring容器的，找到代理所做的事情即可。

2-1、@EnableFeignClients

一切的都是从@EnableFeignClients注解开始：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({FeignClientsRegistrar.class})
public @interface EnableFeignClients {
    String[] value() default {};

    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

    Class<?>[] defaultConfiguration() default {};

    Class<?>[] clients() default {};
}

除去@Retention、@Target、@Documented这几个通用注解外，我们看到还有一个@Import 并且引入了 FeignClientsRegistrar.class

2-2、FeignClientsRegistrar

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {}

FeignClientsRegistrar 实现了 ImportBeanDefinitionRegistrar 并重写了里面的方法registerBeanDefinitions，会自动调用这个方法进行初始化。

FeignClientsRegistrar里面重写registerBeanDefinitions的逻辑如下

public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    this.registerDefaultConfiguration(metadata, registry);
    this.registerFeignClients(metadata, registry);
}

2-3、registerFeignClients

这个方法主要是去获取使用了@FeignClient的接口，找到之后进行注入。

这里有两种方式，如果你使用了@EnableFeignClients 的 clients那它就直接去获取对应的class，不通过类路径自动扫描

@EnableFeignClients(clients = {SchedualServiceHi.class, SchedualServiceHi2.class})

public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        // 获取@EnableFeignClients注解里面的参数
        Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
        Class<?>[] clients = attrs == null ? null : (Class[])((Class[])attrs.get("clients"));
        Object basePackages;
        // 如果使用了clients 就根据class加载
        if (clients != null && clients.length != 0) {
            ((Set)basePackages).add(ClassUtils.getPackageName(clazz));
        } else {
            // 否则使用类路径加载
            basePackages = this.getBasePackages(metadata);
        }
        // 迭代全部的接口
        Iterator var17 = ((Set)basePackages).iterator();
        while(var17.hasNext()) {
            String basePackage = (String)var17.next();
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
            Iterator var21 = candidateComponents.iterator();
            while(var21.hasNext()) {
                BeanDefinition candidateComponent = (BeanDefinition)var21.next();
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // 进行下一步的注册
                    this.registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

2-4、registerFeignClient

private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
   // ....
    BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
   // ...

可以看到registerFeignClient方法里面生成了一个BeanDefinitionBuilder，而入参是FeignClientFactoryBean

2-5、FeignClientFactoryBean

class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {}

可以看到它是实现了FactoryBean 里面有一个getObject是获取bean实例的，FeignClientFactoryBean 重写了这个 getObject

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

<T> T getTarget() {
    FeignContext context = (FeignContext)this.applicationContext.getBean(FeignContext.class);
    Builder builder = this.feign(context);
    // url 为 null 、""、" "  StringUtils.hasText 就返回false
    if (!StringUtils.hasText(this.url)) {
        // ......
        
    } else {
        // ......
        Targeter targeter = (Targeter)this.get(context, Targeter.class);
        return targeter.target(this, builder, context, new HardCodedTarget(this.type, this.name, url));
    }
}

Targeter 是一个接口，它有两个实现类，我们来看默认的实现类

springboot的feign调用指定IP springboot feign原理_openfeign

注：这个FactoryBean接口，可以理解成是Spring的一个钩子，它的getObject方法，是在初始化bean的时候会去调用。（暂时大家先这么理解后面再写一篇文章解释，里面也很复杂）

2-6、DefaultTargeter

class DefaultTargeter implements Targeter {
    DefaultTargeter() {
    }

    public <T> T target(FeignClientFactoryBean factory, Builder feign, FeignContext context, HardCodedTarget<T> target) {
        return feign.target(target);
    }
}

target 最终调用的是 Feign.class 方法，如下，可以看到最终是调用ReflectiveFeign.newInstance

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, this.closeAfterDecode, this.propagationPolicy);
    ParseHandlersByName handlersByName = new ParseHandlersByName(this.contract, this.options, this.encoder, this.decoder, this.queryMapEncoder, this.errorDecoder, synchronousMethodHandlerFactory);
    return new ReflectiveFeign(handlersByName, this.invocationHandlerFactory, this.queryMapEncoder);
}

2-7、ReflectiveFeign.newInstance

在newInstance方法里面有一个JDK代理，所以openfeign其实是基于JDK代理来实现的

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

JDK代理是基于接口代理的，当然最主要的还是我们的InvocationHandler,它代表了我们代理对象最终指向的内容，所以下面我们就要来看看这个handler是如何产生的。

2-8、this.targetToHandlersByName.apply(target);

第一个行代码，就是获取当前对象的方法

this.contract.parseAndValidatateMetadata(key.type());

最后返回 类名#方法名 为key，MethodHandler 为value的map

存入map的时候调用的方法是

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

点进去这个 create 方法，我们看到是new了一个对象，这个类是实现了MethodHandler

return new SynchronousMethodHandler(target, this.client, this.retryer, this.requestInterceptors, this.logger, this.logLevel, md, buildTemplateFromArgs, options, decoder, errorDecoder, this.decode404, this.closeAfterDecode, this.propagationPolicy);

记住这个 SynchronousMethodHandler 后面还会看到

2-9、this.factory.create(target, methodToHandler);

我们再返回newInstance 方法，可以看到最终是调用了一个 this.factory.create 来创建 InvocationHandler

InvocationHandlerFactory 的 create 里面自己就对这个接口进行实现 return new FeignInvocationHandler(target, dispatch);

2-10、FeignInvocationHandler

FeignInvocationHandler 实现了 InvocationHandler 接口，重写了里面的 invoke 方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (!"equals".equals(method.getName())) {
        if ("hashCode".equals(method.getName())) {
            return this.hashCode();
        } else {
            return "toString".equals(method.getName()) ? this.toString() : ((MethodHandler)this.dispatch.get(method)).invoke(args);
        }
    } else {
        try {
            Object otherHandler = args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
            return this.equals(otherHandler);
        } catch (IllegalArgumentException var5) {
            return false;
        }
    }
}

可以看到它最终是调用MethodHandler的 invoke方法。

2-11、SynchronousMethodHandler

上面我们说到最终的MethodHandler其实是SynchronousMethodHandler，那么我们只需要看这个里面的invoke方法就好了

这个里面其实就是显现了http的调用

public Object invoke(Object[] argv) throws Throwable {
    RequestTemplate template = this.buildTemplateFromArgs.create(argv);
    Retryer retryer = this.retryer.clone();

    while(true) {
        try {
            return this.executeAndDecode(template);
        } catch (RetryableException var8) {
           // 为了方面看，我去除了异常处理部分
        }
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。