SpringBoot2 | BeanDefinition 注册核心类 ImportBeanDefinitionRegistrar 源码分析 (十)

简介: SpringBoot2 | BeanDefinition 注册核心类 ImportBeanDefinitionRegistrar 源码分析 (十)


概述

本篇来介绍一个Spring强大的扩展接口:ImportBeanDefinitionRegistrar,该接口主要用来注册beanDefinition。很多三方框架集成Spring 的时候,都会通过该接口,实现扫描指定的类,然后注册到spring 容器中。 比如 Mybatis 中的Mapper接口,springCloud中的 FeignClient 接口,都是通过该接口实现的自定义注册逻辑。

Mybatis中的扫描实现类如下:

源码分析

大致分两个步骤来介绍:

  • 注册所有的ImportBeanDefinitionRegistrar实现类
  • 执行所有的ImportBeanDefinitionRegistrar的逻辑
  • 自定义扫描注册BeanDefinition组件

分别来看。

注册所有的 ImportBeanDefinitionRegistrar 实现类

在 spring 容器启动加载配置类阶段,会执行配置类注解@Import的逻辑: 对应逻辑在ConfigurationClassParser中:

private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
            throws IOException {
        if (visited.add(sourceClass)) {
            for (SourceClass annotation : sourceClass.getAnnotations()) {
                String annName = annotation.getMetadata().getClassName();
                if (!annName.startsWith("java") && !annName.equals(Import.class.getName())) {
                    collectImports(annotation, imports, visited);
                }
            }
            //收集所有的导入配置类
            imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
        }
    }
复制代码

上述方法利用了递归解析,直至获取所有的导入类。

来看解析导入类逻辑:

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
            Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
        if (importCandidates.isEmpty()) {
            return;
        }
        if (checkForCircularImports && isChainedImportOnStack(configClass)) {
            this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
        }
        else {
            this.importStack.push(configClass);
            try {
                for (SourceClass candidate : importCandidates) {
                //类型判断是否为 ImportSelector类型
                    if (candidate.isAssignable(ImportSelector.class)) {
                        // Candidate class is an ImportSelector -> delegate to it to determine imports
                        Class<?> candidateClass = candidate.loadClass();
                        ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                        ParserStrategyUtils.invokeAwareMethods(
                                selector, this.environment, this.resourceLoader, this.registry);
                        if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
                            this.deferredImportSelectors.add(
                                    new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
                        }
                        else {
                            String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                            Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                            processImports(configClass, currentSourceClass, importSourceClasses, false);
                        }
                    }
                    //这里进行类型判断是否为 ImportBeanDefinitionRegistrar 类型
                    else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                        // Candidate class is an ImportBeanDefinitionRegistrar ->
                        // delegate to it to register additional bean definitions
                        Class<?> candidateClass = candidate.loadClass();
                        //直接实例化
                        ImportBeanDefinitionRegistrar registrar =
                                BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
                        ParserStrategyUtils.invokeAwareMethods(
                                registrar, this.environment, this.resourceLoader, this.registry);
                        configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                    }
                    else {
                        // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
                        // process it as an @Configuration class
                        this.importStack.registerImport(
                                currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                        //递归解析
                        processConfigurationClass(candidate.asConfigClass(configClass));
                    }
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to process import candidates for configuration class [" +
                        configClass.getMetadata().getClassName() + "]", ex);
            }
            finally {
                this.importStack.pop();
            }
        }
    }
复制代码

上述逻辑对@Import导入类进行判断,如果为ImportBeanDefinitionRegistrar类型,则直接实例化,并加入到ConfigurationClass集合中:

private final Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars =
            new LinkedHashMap<>();
复制代码

该集合在配置类解析完之后,会单独处理。

执行所有的 ImportBeanDefinitionRegistrar 的逻辑

ConfigurationClassBeanDefinitionReader通过loadBeanDefinitions方法来获取所有的BeanDefinition,最终会执行以下方法:

上述方法解析并读取配置类中的BeanDefinition,有一行比较关键:

loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
复制代码

可以看到,该方法传入的参数正是前面存入ConfigurationClass中的集合对象,也就是ImportBeanDefinitionRegistrar的所有实现类。 继续来看:

private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
        registrars.forEach((registrar, metadata) ->
                registrar.registerBeanDefinitions(metadata, this.registry));
    }
复制代码

遍历所有的实现类,执行注册逻辑。 Mybatis,Feignclient大致做法:通过实现了该接口,然后注册各自指定的类或接口:mapper接口或者feignClient接口,然后将接口声明为 FactoryBean,设置拦截方法,生成代理类。

自定义扫描注册BeanDefinition组件

自定义注解:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MyAutoBeanDefinitionRegistrar3.class)
public @interface EnableMyAutoRegistrar3 {
}
复制代码

自定义注册实现类:

public class MyAutoBeanDefinitionRegistrar3 implements ImportBeanDefinitionRegistrar, BeanClassLoaderAware {
    private ClassLoader classLoader;
    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        ClassPathScanningCandidateComponentProvider scan = getScanner();
        //指定注解,类似于Feign注解
        scan.addIncludeFilter(new AnnotationTypeFilter(MyComponent.class));
        Set<BeanDefinition> candidateComponents = scan.findCandidateComponents("com.beanDefinition.registrar.component");
        BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
        candidateComponents.stream().forEach(beanDefinition -> {
            String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
            if (!registry.containsBeanDefinition(beanDefinition.getBeanClassName())) {
                registry.registerBeanDefinition(beanName, beanDefinition);
            }
        });
    }
    protected ClassPathScanningCandidateComponentProvider getScanner() {
        return new ClassPathScanningCandidateComponentProvider(false) {
            // FeignClient 重写了 ClassPathScanningCandidateComponentProvider 匹配逻辑
            @Override
            protected boolean isCandidateComponent(
                    AnnotatedBeanDefinition beanDefinition) {
                if (beanDefinition.getMetadata().isIndependent()) {
                    // TODO until SPR-11711 will be resolved
                    // 判断接口是否继承了 Annotation注解
                    if (beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata()
                            .getInterfaceNames().length == 1 && Annotation.class.getName().equals(beanDefinition.getMetadata().getInterfaceNames()[0])) {
                        try {
                            Class<?> target = ClassUtils.forName(beanDefinition.getMetadata().getClassName(),
                                    MyAutoBeanDefinitionRegistrar3.this.classLoader);
                            return !target.isAnnotation();
                        } catch (Exception ex) {
                            this.logger.error(
                                    "Could not load target class: " + beanDefinition.getMetadata().getClassName(), ex);
                        }
                    }
                    return true;
                }
                return false;
            }
        };
    }
}
复制代码

具体代码 Github: github.com/admin801122…

总结

本篇主要讲述了 Spring BeanDefinition 注册接口ImportBeanDefinitionRegistrar的用法,也是一些第三方框架整合 Spring 时的常用扩展接口。

看完本文,你应该能很好的理解@EnableFeignClients的注册原理了。



目录
相关文章
|
3月前
|
XML 缓存 算法
SpringBoot2 | SpingBoot FilterRegistrationBean 注册组件 | FilterChain 责任链源码分析(九)
SpringBoot2 | SpingBoot FilterRegistrationBean 注册组件 | FilterChain 责任链源码分析(九)
27 0
|
25天前
|
Java Spring
springboot单类集中定义线程池
该内容是关于Spring中异步任务的配置和使用步骤。首先,在启动类添加`@EnableAsync`注解开启异步支持。然后,自定义线程池类`EventThreadPool`,设置核心和最大线程数、存活时间等参数。接着,将线程池bean注入到Spring中,如`@Bean(&quot;RewardThreadPool&quot;)`。最后,在需要异步执行的方法上使用`@Async`注解,例如在一个定时任务类中,使用`@Scheduled(cron = &quot;...&quot;)`和`@Async`结合实现异步定时任务。
17 2
|
6月前
|
Java Spring
Spring Boot使用策略模式指定Service实现类
Spring Boot使用策略模式指定Service实现类
|
4月前
|
Java easyexcel 数据库连接
SpringBoot使用EasyExcel将Excel数据直接转换为类对象
SpringBoot使用EasyExcel将Excel数据直接转换为类对象
85 0
|
4月前
|
Java 关系型数据库 MySQL
结合springboot+mybatis-plus+lombok,自定义Page封装类
结合springboot+mybatis-plus+lombok,自定义Page封装类
54 0
|
5月前
|
Java 数据库连接 API
SpringBoot【问题 01】借助@PostConstruct解决使用@Component注解的类用@Resource注入Mapper接口为null的问题(原因解析+解决方法)
SpringBoot【问题 01】借助@PostConstruct解决使用@Component注解的类用@Resource注入Mapper接口为null的问题(原因解析+解决方法)
89 0
|
5月前
|
Oracle Java 关系型数据库
Generator【SpringBoot集成】代码生成+knife4j接口文档(2种模板设置、逻辑删除、字段填充 含代码粘贴可用)保姆级教程(注意事项+建表SQL+代码生成类封装+测试类)
Generator【SpringBoot集成】代码生成+knife4j接口文档(2种模板设置、逻辑删除、字段填充 含代码粘贴可用)保姆级教程(注意事项+建表SQL+代码生成类封装+测试类)
28 0
|
5月前
|
前端开发 Java 容器
SpringBoot中注册Servlet、Filter和Listener(代码和注解两种方式)
SpringBoot中注册Servlet、Filter和Listener(代码和注解两种方式)
59 0
|
6月前
|
Java
SpringBoot手动获取Bean类
SpringBoot手动获取Bean类
|
22天前
|
Java Linux
Springboot 解决linux服务器下获取不到项目Resources下资源
Springboot 解决linux服务器下获取不到项目Resources下资源