Spring源码第五讲 BeanFactory 后处理器

于 2024-08-17 21:35:21 发布
阅读量490 收藏 10
点赞数 16
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56369671/article/details/141285338
版权

1.BeanFactory 后处理器的作用

public class A05 {
    public static void main(String[] args) {
        // ⬇️GenericApplicationContext 是一个【干净】的容器
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("config", Config.class);
        // ⬇️初始化容器
        context.refresh();

        for (String name : context.getBeanDefinitionNames()) {
            System.out.println(name);
        }

        // ⬇️销毁容器
        context.close();
    }
}

@Configuration
@ComponentScan("com.itheima.a05copy.component")
public class Config {
    @Bean
    public Bean1 bean1() {
        return new Bean1();
    }

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }

    @Bean(initMethod = "init")
    public DruidDataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("138256");
        return dataSource;
    }

    /*@Bean
    public MapperFactoryBean<Mapper1> mapper1(SqlSessionFactory sqlSessionFactory) {
        MapperFactoryBean<Mapper1> factory = new MapperFactoryBean<>(Mapper1.class);
        factory.setSqlSessionFactory(sqlSessionFactory);
        return factory;
    }

    @Bean
    public MapperFactoryBean<Mapper2> mapper2(SqlSessionFactory sqlSessionFactory) {
        MapperFactoryBean<Mapper2> factory = new MapperFactoryBean<>(Mapper2.class);
        factory.setSqlSessionFactory(sqlSessionFactory);
        return factory;
    }*/
}
@Component
public class Bean2 {
    private static final Logger log = LoggerFactory.getLogger(Bean2.class);

    public Bean2() {
        log.debug("我被 Spring 管理啦");
    }
}

config自己加config里配置的三个Bean和Bean2上加了 @Component共5个Bean，但运行只输出config

说明config的@ComponentScan("com.itheima.a05copy.component")没生效。

加上context.registerBean(ConfigurationClassPostProcessor.class);后

说明ConfigurationClassPostProcessor 可以解析 @ComponentScan @Bean @Import @ImportResource这些注解。

context.registerBean(MapperScannerConfigurer.class, bd -> { // @MapperScanner
            bd.getPropertyValues().add("basePackage", "com.itheima.a05copy.mapper");
        });

加上这行代码就可以解析@mapper接口了 

其中mapper1mapper2均为空接口只有一个@Mapper注解。

2. 工厂处理器模拟实现

2.1 模拟解析 @ComponentScan

// context.registerBean(ConfigurationClassPostProcessor.class);// @ComponentScan @Bean @Import @ImportResource
// context.registerBean(MapperScannerConfigurer.class, bd -> { // @MapperScanner
// bd.getPropertyValues().add("basePackage", "com.itheima.a05copy.mapper");
// });
注释掉这三句模拟组建扫描

ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
if (componentScan!=null){
      for (String p : componentScan.basePackages()) {
            System.out.println(p);
     }
 }

输出
com.itheima.a05copy.component
config

Process finished with exit code 0
扫描到了包名

ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);

        if (componentScan!=null){
            for (String p : componentScan.basePackages()) {
                System.out.println(p);
                //com.itheima.a05copy.component -> classpath*:com/itheima/a05copy/component/**/*.class
                String path = "classpath*:" + p.replace(".", "/") + "/**/*.class";
                Resource[] resources = context.getResources(path);
                for (Resource resource : resources) {
                    System.out.println(resource);
                }
            }
        }
@Component
public class Bean2 {
    private static final Logger log = LoggerFactory.getLogger(Bean2.class);

    public Bean2() {
        log.debug("我被 Spring 管理啦");
    }
}
@Component
public class Bean3 {
    private static final Logger log = LoggerFactory.getLogger(Bean3.class);

    public Bean3() {
        log.debug("我被 Spring 管理啦");
    }
}

public class Bean4 {
    private static final Logger log = LoggerFactory.getLogger(Bean4.class);

    public Bean4() {
        log.debug("我被 Spring 管理啦");
    }
}

Bean4未加@Component但也被扫描到了，因为由代码知是路径扫描。

if (componentScan!=null){
            for (String p : componentScan.basePackages()) {
                System.out.println(p);
                //com.itheima.a05copy.component -> classpath*:com/itheima/a05copy/component/**/*.class
                String path = "classpath*:" + p.replace(".", "/") + "/**/*.class";
                CachingMetadataReaderFactory factory=new CachingMetadataReaderFactory();
                Resource[] resources = context.getResources(path);
                for (Resource resource : resources) {
                    // System.out.println(resource);
                    MetadataReader reader = factory.getMetadataReader(resource);
                    System.out.println("类名:" + reader.getClassMetadata().getClassName());
                    AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
                    System.out.println("是否加了 @Component:" + annotationMetadata.hasAnnotation(Component.class.getName()));
                }
            }
        }

获取Bean源的一些信息

 此时若将Bean3的注解改为@Component的派生注解会扫描不到

System.out.println("是否加了 @Component:" + annotationMetadata.hasAnnotation(Component.class.getName()));
System.out.println("是否加了 @Component 派生:" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));

AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
                for (Resource resource : resources) {
                    // System.out.println(resource);
                    MetadataReader reader = factory.getMetadataReader(resource);
                    // System.out.println("类名:" + reader.getClassMetadata().getClassName());
                    AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
                    // System.out.println("是否加了 @Component:" + annotationMetadata.hasAnnotation(Component.class.getName()));
                    // System.out.println("是否加了 @Component 派生:" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));

                    if (annotationMetadata.hasAnnotation(Component.class.getName())
                        || annotationMetadata.hasMetaAnnotation(Component.class.getName())) {
                        AbstractBeanDefinition bd = BeanDefinitionBuilder
                                .genericBeanDefinition(reader.getClassMetadata().getClassName())
                                .getBeanDefinition();
                        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();
                        String name = generator.generateBeanName(bd, beanFactory);
                        beanFactory.registerBeanDefinition(name, bd);
                    }
                }

如果有@Component或者他的派生注解 这生成Bean


public class ComponentScanPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override // context.refresh
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
      try {
            ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);

            if (componentScan != null) {
                for (String p : componentScan.basePackages()) {
                    System.out.println(p);
                    // com.itheima.a05copy.component -> classpath*:com/itheima/a05copy/component/**/*.class
                    String path = "classpath*:" + p.replace(".", "/") + "/**/*.class";
                    CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                    Resource[] resources = new PathMatchingResourcePatternResolver().getResources(path);
                    AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
                    for (Resource resource : resources) {
                        // System.out.println(resource);
                        MetadataReader reader = factory.getMetadataReader(resource);
                        // System.out.println("类名:" + reader.getClassMetadata().getClassName());
                        AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
                        // System.out.println("是否加了 @Component:" + annotationMetadata.hasAnnotation(Component.class.getName()));
                        // System.out.println("是否加了 @Component 派生:" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));

                        if (annotationMetadata.hasAnnotation(Component.class.getName())
                            || annotationMetadata.hasMetaAnnotation(Component.class.getName())) {
                            AbstractBeanDefinition bd = BeanDefinitionBuilder
                                    .genericBeanDefinition(reader.getClassMetadata().getClassName())
                                    .getBeanDefinition();
                            String name = generator.generateBeanName(bd, beanFactory);
                            beanFactory.registerBeanDefinition(name, bd);
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

将模拟解析 @ComponentScan的代码抽取为ComponentScanPostProcessor

// context.registerBean(ConfigurationClassPostProcessor.class);// @ComponentScan @Bean @Import @ImportResource
        // context.registerBean(MapperScannerConfigurer.class, bd -> { // @MapperScanner
        //     bd.getPropertyValues().add("basePackage", "com.itheima.a05copy.mapper");
        // });

        context.registerBean(ComponentScanPostProcessor.class); // 解析 @Bean

可见Bean2Bean3能被解析。 

总结

1. Spring 操作元数据的工具类 CachingMetadataReaderFactory
2. 通过注解元数据（AnnotationMetadata）获取直接或间接标注的注解信息
3. 通过类元数据（ClassMetadata）获取类名，AnnotationBeanNameGenerator 生成 bean 名
4. 解析元数据是基于 ASM 技术

2.2 模拟解析 @Bean


public class AtBeanPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
        try {
            CachingMetadataReaderFactory factory=new CachingMetadataReaderFactory();
            MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/itheima/a05copy/Config.class"));
            Set<MethodMetadata> methods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
            for (MethodMetadata method : methods) {
                System.out.println(method);
                String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
                BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
                builder.setFactoryMethodOnBean(method.getMethodName(),"config");
                builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
                if (initMethod.length()>0){
                    builder.setInitMethodName(initMethod);
                }
                AbstractBeanDefinition bd = builder.getBeanDefinition();
                beanFactory.registerBeanDefinition(method.getMethodName(),bd);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

reader.getAnnotationMetadata()获取和注解有关的元数据

reader.getAnnotationMetadata().getAnnotatedMethods()获取被注解标注的方法，接下来由这些信息定义Bean
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
builder.setFactoryMethodOnBean(method.getMethodName(),"config");这两行定义Config的工厂方法。
builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);解决sqlSessionFactoryBean的自动装配的问题。

if (initMethod.length()>0){
builder.setInitMethodName(initMethod);
}解决dataSource的@Bean(initMethod = "init")初始化方法

bean1 sqlSessionFactory BeandataSource 都正常解析了。


2.3 模拟解析 Mapper 接口

1. Mapper 接口被 Spring 管理的本质：实际是被作为 MapperFactoryBean 注册到容器中
2. Spring 的诡异做法，根据接口生成的 BeanDefinition 仅为根据接口名生成 bean 名

wm1043
关注
  • 16
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring 源码阅读 12：BeanFactory 预处理
知识分享官
10-20 283
标签，这个 Bean 的类定义中，有一个属性是 InputStream 类型的，或者是 Class 类型的，我们需要在 XML 配置文件中给这个属性配置一个值，但是又没有办法在 XML 中配置一个 InputStream 或者 Class 类型的对象，只能配置一个字符串内容。这里主要是为了安全考虑，如果开发者定义了一个类，实现了 BeanFactory 并注册到了 Spring 的容器中，当其他的类获取 BeanFactory 类型的 Bean 的时候，仍然能从容器中取出了正确的 Bean。
Spring原理学习（三）BeanFactory后处理器
小鲁蛋的博客
11-03 561
ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器（即 BeanFactory）的扩展功能这些扩展功能由不同的 BeanFactory 后处理器来完成，其实主要就是补充了一些 bean 定义。
Spring源码分析之：BeanFactory
c18120446428的博客
09-20 349
BeanFactory 首先我们看一下spring源码中的对于该接口的注释，如下 /** * The root interface for accessing a Spring bean container. * 访问 Spring bean 容器的根接口 * * <p>This is the basic client view of a bean container; * further interfaces such as {@link ListableBeanFact.
Spring源码|解析深入Spring源码多图剖析@Configuration背后的BeanFactory后置处理器实现逻辑
qq_37419449的博客
11-05 4088
揭秘@Configuration的秘密之BeanFactory后置处理器 前序文章 Spring如何扫描工作目录下的Bean?|图文并茂讲解@Configuration的工作原理 文章目录揭秘@Configuration的秘密之BeanFactory后置处理器基础介绍目的流程图代码分析(1) postProcessBeanFactory()(2)enhanceConfigurationClasses()(3)ConfigurationClassEnhancer.enhance()(4)Configura
【Spring源码分析】BeanFactory系列接口解读
qq_63691275的博客
11-05 409
BeanFactory：顶层接口，提供了最基础的方法，譬如：getBean、containBean，HierarchicalBeanFactory，子接口，拓展了 层次关系，ListableBeanFactory，子接口，拓展了 枚举 能力 AutowireCapableBeanFactory，子接口，拓展了 自动装配 能力 ConfigurableBeanFactory，子接口，拓展了相关组件 可配置化 的能力 ConfigurableListableBeanFactory，集大成者
Spring5学习笔记04--Bean后处理器
qingqingxiangyang的博客
09-04 156
Bean后处理器以及常见的Bean后处理器介绍
Spring源码学习第五天==＞prepareBeanFactory(beanFactory)
lewismago的博客
01-17 257
关键词：prepareBeanFactory(beanFactory)方法postProcessBeanFactory(beanFactory)方法 今天的知识点和流程要比创建BeanFactory要少很多，理解起来会稍微轻松简单一些。 一.prepareBeanFactory(beanFactory) 见名知意:beanFactory的准备工作，对各种属性进行填充 1.设置BeanFactory的类加载器为ApplicationContex的类加载器 2.设置b...
spring源码笔记五：bean工厂后置处理器
zhoutaoping1992的博客
03-22 687
五、bean工厂后置处理器 5.1、源码解析 refresh()方法比较重要的代码是上篇文章标注的第5条和第11条代码，本次先解析第5行的代码invokeBeanFactoryPostProcessors，执行bean工厂后置处理器。 点进invokeBeanFactoryPostProcessors， 再点进PostProcessorRegistrationDelegate.invo...
Spring源码学习三：BeanFactory解析1
08-04
在Spring框架中，BeanFactory是核心的IoC（Inversion of Control）容器接口，它负责管理和维护Bean的生命周期。BeanFactory提供了对Bean的创建、初始化、销毁等操作的支持，是Spring容器的基础。当我们通过XML、Java...
二、Spring源码分析——BeanFactory
08-11
《Spring源码分析——BeanFactory》 在Java的IoC（Inversion of Control）和DI（Dependency Injection）领域，Spring框架扮演着至关重要的角色。BeanFactory是Spring的核心组件之一，它是容器的基石，负责管理应用...
Spring源码深度解析第二版
11-15
Spring源码深度解析第二版 Spring是一款广泛应用于Java企业级应用程序的开源框架，旨在简化Java应用程序的开发和部署。Spring框架的核心主要包括了IoC容器、AOP、MVC框架等模块。 第1章 Spring整体架构和环境搭建 ...
Spring源码解析.pdf
03-09
### Spring源码解析知识点 #### 一、Spring IoC 容器详解 ##### 1. BeanFactory —— 最基础的IoC容器 - **概念**：`BeanFactory` 是Spring框架中最基本的IoC容器，它负责管理Bean的生命周期，包括创建、配置和...
Spring源码解析.zip
07-31
在源码中，`org.springframework.beans.factory`和`org.springframework.context`包下包含了实现IoC功能的关键类，如`BeanFactory`和`ApplicationContext`。理解这些类的职责以及它们如何协同工作，能帮助我们更好地...
spring揭秘06-Autowired自动绑定依赖及组件自动扫描
最新发布
PacosonSWJTU的博客
08-16 463
Resource注解可以替代 @Autowired 与 @Qualilfier这2个注解结合的功能，即根据beanName到spring容器中查找匹配的bean，并注入依赖关系到当前bean（如Jsr250AnnotationBookAppService）；
spring中使用到的设计模式有哪些
weixin_47503016的博客
08-12 327
spring 使用到的设计模式
SpringBoot
qq_74812898的博客
08-12 602
SpringBoot
spring中的事务
menghuannvxia的专栏
08-13 416
方法发生异常就会触发事务管理，在spring中想进行事务回滚必须加上@Transactional注解，下边是出现异常进行捕获进行回滚的源代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值