手写RPC框架Feign

LailaiMonkey

已于 2023-04-27 11:54:27 修改

阅读量2.4k

点赞数 1

分类专栏：架构文章标签： rpc dubbo java

于 2022-09-17 15:12:23 首次发布

本文链接：https://blog.csdn.net/h273979586/article/details/126750590

版权

Feign原理实现

手写RPC框架Feign

手写RPC框架Feign

阅读本文你可获得：
1、RPC原理
2、feign注入原理
3、如何手写feign框架
4、动态代码设计模式应用场景

什么是RPC

RPC：远程过程调用，也就是我们通常说“HTTP”调用，也有人说dubbo不是基于HTTP也是RPC啊，那怎么理解这件事呢？其实RPC就是指两服务之间调用不再写繁琐代码，有个东西把这件事包装起来，像写普通方法一样调用远程服务。

有人从网络分层（5层）角度出发说：feign不属于RPC，dubbo才是真正的RPC，feign底层是HTTP（应用层）或7层调用，dubbo是4层（传输层）调用，真正PRC是4层而不是7层。也有人说RPC就是HTTP，在此小编认为两者说的不准确，RPC不是区分实现过程（4层、7层）只区分调用手段（像调用普通service一样）。

从宏观角度讲只要是开发人员调用外部服务像调用方法一样的框架都叫RPC。

Feign注入原理

使用feign需要在启动类上加@EnableFeignClients注解并写上包名，我们在类上加@FeignClient注解、方法加@GetMapping等注解并配置相应属性feign架构就起作用，那么从这里思考这几个注解起了什么作用？我们倒着分析。

GetMapping、PostMapping 这几个注解同Controller一样这里不再描述；
FeignClient 是对我们类名、请求地址进行统一配置这里不再描述；
EnableFeignClients 这个注解相当重要且它是核心注解，以上两个注解是否起作用，怎么发起HTTP调用都是该注解在工作；

EnableFeignClients

注解上有一个@Import(FeignClientsRegistrar.class)核心代码在FeignClientsRegistrar类中。
该类实现接口ImportBeanDefinitionRegistrar它是Spring扩展点之一，支持我们写的代码封装成BeanDefinition俗称bean，bean的有功能它都有例如：@Autowired注解该bean、postProcessAfterInitializationbean的后置初始化等功能。

registerBeanDefinitions 方法中两个方法：registerDefaultConfiguration注册默认配置和registerFeignClients注册feign的配置，我们注入feign的配置所以核心在registerFeignClients方法中。

在这里插入图片描述
scanner是项目启动扫描所有class文件，并设置过滤条件（类上有FeignClient注解），且通过metadata（启动类上EnableFeignClients注解配置包名）并获得注解所扫描对应包名。

在这里插入图片描述
拿到启动类上所有包类，过滤上一步设置好的条件（带FeignClient注解的）类，找到我们定义FeignClient接口类。

在这里插入图片描述
上图四步feign帮我们做了，其实第三步对于我们手写框架来说可以忽略，重要看第四步。

在这里插入图片描述
第一步：构建FeignClientFactoryBean并通过构造函数设置值（生成代理核心）。
第二步：获得bean别名、并设置bean是否是主要bean。
第三步：向Spring中注册bean。

致此我们写的带FeignClient注解的接口注册到spring中，可以通过@Autowired或@Resource等方式注入到代码里开始使用，那么有的小伙伴就会问我的实现还没写呢？调用逻辑呢？

Feign调用入口

Java动态代理分为两种：JDK和CGLIB，它两本质区别是有没有实现接口，JDK必须是实现接口，CGLIB可以不用实现接口。feign用的是JDK动态代理所以我们写代码时FeignClient注解要放在接口，刚才注入bean过程也进行了判断，非接口不让注解会报错（第三张图有分析）。

我们最后一张图有说：构建FeignClientFactoryBean并通过构造函数设置值，这里是产生代理核心。该主要实现了FactoryBean返回值就是我们注册到spring中bean的类型，在该类中可以注入其它bean，感觉兴趣的小伙伴可以从源一直点下去，在newInstance类中会生成代理对象，如下图。

在动态代理类中编写具体实现代码。
在这里插入图片描述

以上核对源码分析完成，我们分析源码主要目的是为实现简单feign做铺垫。

手写Feign

如果我们要写一个简单版本的feign那应该怎么做呢？
1、我们需要把接口类注入到spring中。
2、在动态代理中编写实现方法。

听着很简单实际操作也很简单(>‿<）

定义启动类注解MonkeyEnableHttpClient并配置扫描包同EnableFeignClients注解，我们只需要value一个注解即可。

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2022/09/15 4:11 下午
 * @Modified By：
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(MonkeyHttpClientRegister.class)
public @interface MonkeyEnableHttpClient {
   
    String[] value();
}

定义接口类注解MonkeyHttpClient同FeignClient注解，需要知道bean名称（通过反射自动生成）、该类配置全局url、超时时间等信息。

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2022/09/15 2:48 下午
 * @Modified By：
 */
@Target({
   ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MonkeyHttpClient {
   

    /**
     * 注册bean名称，默认类名
     *
     * @return
     */
    String name() default "";

    /**
     * 调用url
     *
     * @return
     */
    String url();

    /**
     * 读超时时间
     *
     * @return
     */
    String readTimeout() default "5000";

    /**
     * 连接超时时间
     *
     * @return
     */
    String connectTimeout() default "5000";

}

定义注册类MonkeyHttpClientRegister启动时扫描包并注册到Spring中。

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2022/09/15 4:04 下午
 * @Modified By：
 */
@Slf4j
public class MonkeyHttpClientRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware, BeanClassLoaderAware, ResourceLoaderAware {
   

    private Environment environment;

    private ClassLoader classLoader;

    private ResourceLoader resourceLoader;


    @Override
    public void setEnvironment(Environment environment) {
   
        this.environment = environment;
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
   
        this.classLoader = classLoader;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
   
        this.resourceLoader = resourceLoader;
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
   
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(this.resourceLoader);
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(MonkeyHttpClient.class);
        scanner.addIncludeFilter(annotationTypeFilter);

        Map<String, Object> attributes = metadata.getAnnotationAttributes(MonkeyEnableHttpClient.class.getCanonicalName());
        if (CollectionUtils.isEmpty(attributes)) {
   
            return;
        }

        Set<String> basePackages = new HashSet<>();
        for (String pkg : (String[]) attributes.get("value")) {
   
            if (StringUtils.hasText(pkg)) {
   
                basePackages.add(pkg);
            }
        }

        for (String basePackage : basePackages) {
   
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
            for (BeanDefinition candidateComponent : candidateComponents) {
   
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
   

                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    Assert.isTrue(annotationMetadata.isInterface(), "@GZHttpClient can only be specified on an interface");

                    Map<String, Object> feignClientAttributeMap = annotationMetadata.getAnnotationAttributes(MonkeyHttpClient.class.getCanonicalName());
                    if (CollectionUtils.isEmpty(feignClientAttributeMap)) {
   
                        return;
                    }

                    String className = annotationMetadata.getClassName();

                    Class<?> clazz = null;
                    try {
   
                        clazz = Class.forName(className);
                    } catch (ClassNotFoundException e) {
   
                        log.error("httpClient start up fail:", e);
                    }

                    String beanName = className.substring(className.lastIndexOf(".") + 1);
                    String alias = beanName.substring(0, 1).toLowerCase().concat(beanName.substring(1)).concat("HttpClient");
                    String name = String.valueOf(feignClientAttributeMap.get("name"));
                    String url = String.valueOf(feignClientAttributeMap.get("url"));
                    if (!StringUtils.isEmpty(name)) {
   
                        alias = name;
                    }
                    String readTimeout = String.valueOf(feignClientAttributeMap.get("readTimeout"));
                    String connectTimeout = String.valueOf(feignClientAttributeMap.get("connectTimeout"));

                    BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(MonkeyHttpClientFactoryBean.class);
                    definition.addConstructorArgValue(clazz);
                    definition.addConstructorArgValue(url);
                    definition.addConstructorArgValue(readTimeout);
                    definition.addConstructorArgValue(connectTimeout);
                    definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

                    AbstractBeanDefinition handleDefinition = definition.getBeanDefinition();
                    handleDefinition.setPrimary(true);

                    // 向Spring的上下文中注册bean组件
                    BeanDefinitionHolder holder = new BeanDefinitionHolder(handleDefinition, className, new String[]{
   alias});
                    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
                }
            }
        }
    }

    protected ClassPathScanningCandidateComponentProvider getScanner() {
   
        return new ClassPathScanningCandidateComponentProvider(false, this.environment