05beanfactory后置处理器

最新推荐文章于 2024-06-20 20:20:21 发布
最新推荐文章于 2024-06-20 20:20:21 发布
阅读量555 收藏 7
点赞数 12
分类专栏： spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48254383/article/details/139304955
版权

BeanFactory 后处理器的作用

作用与bdMap创建完成后，通过对bdMap的操作（新增）来实现更多的功能拓展

  • ConfigurationClassPostProcessor 可以解析

    • @ComponentScan

    • @Bean

    • @Import

    • @ImportResource

  • MapperScannerConfigurer 可以解析

    • Mapper 接口

  1. @ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器（即 BeanFactory）的扩展功能

  2. 这些扩展功能由不同的 BeanFactory 后处理器来完成，其实主要就是补充了一些 bean 定义

package com.butch.a05;

import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

public class A05 {

    public static void main(String[] args) {
        GenericApplicationContext applicationContext = new GenericApplicationContext();
        applicationContext.registerBean("config",Config.class);

        //注册beanfactory后置处理器ConfigurationClassPostProcessor 解析// @ComponentScan @Bean @Import @ImportResource
        applicationContext.registerBean(ConfigurationClassPostProcessor.class);
        //注册MapperScannerConfigurer，解析@mapperScaner
        applicationContext.registerBean(MapperScannerConfigurer.class,beanDefinition -> {
            beanDefinition.getPropertyValues().add("basePackage","com.butch.a05.mapper");
        });
        applicationContext.refresh();

        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println("beanDefinitionName = " + beanDefinitionName);
        }
        applicationContext.close();
    }
}
package com.butch.a05;

import com.alibaba.druid.pool.DruidDataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@ComponentScan("com.butch.a05.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/db1");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        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;
    }*/
}

package com.butch.a05;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Bean1 {

    private static final Logger log = LoggerFactory.getLogger(Bean1.class);

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

package com.butch.a05.component;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class Bean2 {

    private static final Logger log = LoggerFactory.getLogger(Bean2.class);

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

模拟解析 @ComponentScan

  1. Spring 操作元数据的工具类 CachingMetadataReaderFactory

  2. 通过注解元数据（AnnotationMetadata）获取直接或间接标注的注解信息

  3. 通过类元数据（ClassMetadata）获取类名，AnnotationBeanNameGenerator 生成 bean 名

  4. 解析元数据是基于 ASM 技术

版本1.0未解耦
package com.butch.a05;

import com.fasterxml.jackson.dataformat.xml.util.AnnotationUtil;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.io.Resource;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.stereotype.Component;

import java.io.IOException;

public class A05 {

    public static void main(String[] args) throws IOException {
        GenericApplicationContext applicationContext = new GenericApplicationContext();
        applicationContext.registerBean("config",Config.class);

//        //注册beanfactory后置处理器ConfigurationClassPostProcessor 解析// @ComponentScan @Bean @Import @ImportResource
//        applicationContext.registerBean(ConfigurationClassPostProcessor.class);
//        //注册MapperScannerConfigurer，解析@mapperScaner
//        applicationContext.registerBean(MapperScannerConfigurer.class,beanDefinition -> {
//            beanDefinition.getPropertyValues().add("basePackage","com.butch.a05.mapper");
//        });
        //模拟componscan注解
        ComponentScan annotation = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
        if (annotation != null){
            //获取包名
            for (String s : annotation.basePackages()) {
                System.out.println("s = " + s);
                //转化路径为包名
                // com.butch.a05.component -> classpath*:com/butch/a05/component/**/*.class
                String path = "classpath*:" + s.replace(".", "/") + "/**/*.class";
                System.out.println("path = " + path);
                //通过context扩展获取资源, 获取扫描到包class文件集合
                CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
                Resource[] resources = applicationContext.getResources(path);
                for (Resource resource : resources) {
//                    System.out.println("resource = " + resource);
                    //获取类的元信息
                    MetadataReader metadataReader = factory.getMetadataReader(resource);
                    System.out.println("metadataReader.getClassMetadata().getClassName() = " + metadataReader.getClassMetadata().getClassName());
                    System.out.println("metadataReader.getAnnotationMetadata().hasAnnotatedMethods(Component.class.getName()) = " + metadataReader.getAnnotationMetadata().hasAnnotation(Component.class.getName()));
                    //派生注解
                    System.out.println("metadataReader.getAnnotationMetadata().hasAnnotatedMethods(Component.class.getName()) = " + metadataReader.getAnnotationMetadata().hasMetaAnnotation(Component.class.getName()));
                    //当加了component注解或者其派生注解的时候 注册bd到map中
                    if (metadataReader.getAnnotationMetadata().hasAnnotation(Component.class.getName()) || metadataReader.getAnnotationMetadata().hasMetaAnnotation(Component.class.getName())){
                        //构造一个bd
                        AbstractBeanDefinition bd = BeanDefinitionBuilder.genericBeanDefinition(metadataReader.getClassMetadata().getClassName()).getBeanDefinition();
                        //获取bean的名字
                        String beanName = generator.generateBeanName(bd, applicationContext);
                        //注册bd
                        applicationContext.registerBeanDefinition(beanName,bd);
                    }
                }

            }
        }
        applicationContext.refresh();

        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println("beanDefinitionName = " + beanDefinitionName);
        }
        applicationContext.close();
    }

}
版本2.0解耦
package com.butch.a05;

import com.fasterxml.jackson.dataformat.xml.util.AnnotationUtil;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.io.Resource;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.stereotype.Component;

import java.io.IOException;

public class A05 {

    public static void main(String[] args) throws IOException {
        GenericApplicationContext applicationContext = new GenericApplicationContext();
        applicationContext.registerBean("config",Config.class);

//        //注册beanfactory后置处理器ConfigurationClassPostProcessor 解析// @ComponentScan @Bean @Import @ImportResource
//        applicationContext.registerBean(ConfigurationClassPostProcessor.class);
//        //注册MapperScannerConfigurer，解析@mapperScaner
//        applicationContext.registerBean(MapperScannerConfigurer.class,beanDefinition -> {
//            beanDefinition.getPropertyValues().add("basePackage","com.butch.a05.mapper");
//        });
        applicationContext.registerBean(ComponentScanPostProcessor.class);

        applicationContext.refresh();

        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println("beanDefinitionName = " + beanDefinitionName);
        }
        applicationContext.close();
    }

}
package com.butch.a05;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.stereotype.Component;

public class ComponentScanPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry applicationContext) throws BeansException {
        //模拟componscan注解
        try {
            ComponentScan annotation = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
            if (annotation != null) {
                //获取包名
                for (String s : annotation.basePackages()) {
                    System.out.println("s = " + s);
                    //转化路径为包名
                    // com.butch.a05.component -> classpath*:com/butch/a05/component/**/*.class
                    String path = "classpath*:" + s.replace(".", "/") + "/**/*.class";
                    System.out.println("path = " + path);
                    //通过context扩展获取资源, 获取扫描到包class文件集合
                    CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                    AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
//                    Resource[] resources = applicationContext.getResources(path);
                    Resource[] resources = new PathMatchingResourcePatternResolver().getResources(path);
                    for (Resource resource : resources) {
//                    System.out.println("resource = " + resource);
                        //获取类的元信息
                        MetadataReader metadataReader = factory.getMetadataReader(resource);
                        System.out.println("metadataReader.getClassMetadata().getClassName() = " + metadataReader.getClassMetadata().getClassName());
                        System.out.println("metadataReader.getAnnotationMetadata().hasAnnotatedMethods(Component.class.getName()) = " + metadataReader.getAnnotationMetadata().hasAnnotation(Component.class.getName()));
                        //派生注解
                        System.out.println("metadataReader.getAnnotationMetadata().hasAnnotatedMethods(Component.class.getName()) = " + metadataReader.getAnnotationMetadata().hasMetaAnnotation(Component.class.getName()));
                        //当加了component注解或者其派生注解的时候 注册bd到map中
                        if (metadataReader.getAnnotationMetadata().hasAnnotation(Component.class.getName()) || metadataReader.getAnnotationMetadata().hasMetaAnnotation(Component.class.getName())) {
                            //构造一个bd
                            AbstractBeanDefinition bd = BeanDefinitionBuilder.genericBeanDefinition(metadataReader.getClassMetadata().getClassName()).getBeanDefinition();
                            //获取bean的名字
                            String beanName = generator.generateBeanName(bd, applicationContext);
                            //注册bd
                            applicationContext.registerBeanDefinition(beanName, bd);
                        }
                    }

                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

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

    }
}
总结

  1. 获取componentScan注解的basepage属性值，即为包名，并将其转为路径

  2. 获取类路径下的所有资源类文件，获取其元数据

  3. 根据其元数据判断类中是否有component注解及其派生注解

  4. 有的话注册bd到map中

模拟解析 @Bean

版本1.0未解耦
package com.butch.a05;

import com.fasterxml.jackson.dataformat.xml.util.AnnotationUtil;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.type.MethodMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Set;

public class A05 {

    public static void main(String[] args) throws IOException {
        GenericApplicationContext applicationContext = new GenericApplicationContext();
        applicationContext.registerBean("config",Config.class);

//        //注册beanfactory后置处理器ConfigurationClassPostProcessor 解析// @ComponentScan @Bean @Import @ImportResource
//        applicationContext.registerBean(ConfigurationClassPostProcessor.class);
//        //注册MapperScannerConfigurer，解析@mapperScaner
//        applicationContext.registerBean(MapperScannerConfigurer.class,beanDefinition -> {
//            beanDefinition.getPropertyValues().add("basePackage","com.butch.a05.mapper");
//        });

//        applicationContext.registerBean(ComponentScanPostProcessor.class);

        //获取类元信息
        CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
        MetadataReader metadataReader = factory.getMetadataReader(new ClassPathResource("com/butch/a05/Config.class"));
        //所有包含@bean注解的方法
        Set<MethodMetadata> annotatedMethods = metadataReader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
        for (MethodMetadata method : annotatedMethods) {
            System.out.println("annotatedMethod = " + method.getMethodName());
            //获取工厂bd
            BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();
            String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
            beanDefinitionBuilder.setFactoryMethodOnBean(method.getMethodName(),"config");
            beanDefinitionBuilder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
            //处理属性提取注入的初始化
            if (initMethod.length() > 0){
                beanDefinitionBuilder.setInitMethodName(initMethod);
            }
            //注册bd
            AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
            applicationContext.registerBeanDefinition(method.getMethodName(),beanDefinition);
        }
        applicationContext.refresh();

        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println("beanDefinitionName = " + beanDefinitionName);
        }
        applicationContext.close();
    }

}
版本2.0解耦
package com.butch.a05;

import com.fasterxml.jackson.dataformat.xml.util.AnnotationUtil;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.type.MethodMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Set;

public class A05 {

    public static void main(String[] args) throws IOException {
        GenericApplicationContext applicationContext = new GenericApplicationContext();
        applicationContext.registerBean("config",Config.class);

//        //注册beanfactory后置处理器ConfigurationClassPostProcessor 解析// @ComponentScan @Bean @Import @ImportResource
//        applicationContext.registerBean(ConfigurationClassPostProcessor.class);
//        //注册MapperScannerConfigurer，解析@mapperScaner
//        applicationContext.registerBean(MapperScannerConfigurer.class,beanDefinition -> {
//            beanDefinition.getPropertyValues().add("basePackage","com.butch.a05.mapper");
//        });

//        applicationContext.registerBean(ComponentScanPostProcessor.class);

//        //获取类元信息
//        CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
//        MetadataReader metadataReader = factory.getMetadataReader(new ClassPathResource("com/butch/a05/Config.class"));
//        //所有包含@bean注解的方法
//        Set<MethodMetadata> annotatedMethods = metadataReader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
//        for (MethodMetadata method : annotatedMethods) {
//            System.out.println("annotatedMethod = " + method.getMethodName());
//            //获取工厂bd
//            BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();
//            String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
//            beanDefinitionBuilder.setFactoryMethodOnBean(method.getMethodName(),"config");
//            beanDefinitionBuilder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
//            //处理属性提取注入的初始化
//            if (initMethod.length() > 0){
//                beanDefinitionBuilder.setInitMethodName(initMethod);
//            }
//            //注册bd
//            AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
//            applicationContext.registerBeanDefinition(method.getMethodName(),beanDefinition);
//        }
        applicationContext.registerBean(AtBeanPostProcessor.class);
        applicationContext.refresh();

        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println("beanDefinitionName = " + beanDefinitionName);
        }
        applicationContext.close();
    }

}
package com.butch.a05;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.type.MethodMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;

import java.io.IOException;
import java.util.Set;

public class AtBeanPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        try {
            //获取类元信息
            CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
            MetadataReader metadataReader = factory.getMetadataReader(new ClassPathResource("com/butch/a05/Config.class"));
            //所有包含@bean注解的方法
            Set<MethodMetadata> annotatedMethods = metadataReader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
            for (MethodMetadata method : annotatedMethods) {
                System.out.println("annotatedMethod = " + method.getMethodName());
                //获取工厂bd
                BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();
                String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
                beanDefinitionBuilder.setFactoryMethodOnBean(method.getMethodName(),"config");
                beanDefinitionBuilder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
                //处理属性提取注入的初始化
                if (initMethod.length() > 0){
                    beanDefinitionBuilder.setInitMethodName(initMethod);
                }
                //注册bd
                AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
                beanDefinitionRegistry.registerBeanDefinition(method.getMethodName(),beanDefinition);
            }
        }catch (IOException e){
            e.printStackTrace();
        }

    }

    @Override//refresh
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}
总结

  1. 获取该类的元数据

  2. 获取类中所有标注@bean注解的方法

  3. 根据方法构造bd，注册到Map中

模拟解析@mapperscan

添加单个mapper可以使用@bean
  @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;
    }
扫描添加mapper
package com.butch.a05;

import org.mybatis.spring.mapper.MapperFactoryBean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;

import java.io.IOException;

public class MapperPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        try {

            //获取mapper对应的资源
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            Resource[] resources = resolver.getResources("classpath:com/butch/a05/mapper/**/*.class");
            CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
            AnnotationBeanNameGenerator annotationBeanNameGenerator = new AnnotationBeanNameGenerator();
            for (Resource resource : resources) {
                //获取资源元数据
                MetadataReader reader = factory.getMetadataReader(resource);
                ClassMetadata classMetadata = reader.getClassMetadata();
                //如果该类是一个接口则注册bd
                if (classMetadata.isInterface()){
                    AbstractBeanDefinition bd1 = BeanDefinitionBuilder.genericBeanDefinition(MapperFactoryBean.class)
                            //mapper的泛型类型
                            .addConstructorArgValue(classMetadata.getClassName())
                            //set构造bytype
                            .setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE)
                            .getBeanDefinition();
                    //由于bean名字生成都是MapperFactoryBean，因此根据泛型类型再生成一个bd获取名字
                    AbstractBeanDefinition bd2 = BeanDefinitionBuilder.genericBeanDefinition(classMetadata.getClassName()).getBeanDefinition();
                    //获取名字
                    String beanName = annotationBeanNameGenerator.generateBeanName(bd2, beanDefinitionRegistry);
                    //注册
                    beanDefinitionRegistry.registerBeanDefinition(beanName,bd1);
                }

            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

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

    }
}
总结

  1. 单个mapper可以使用@bean注入

  2. 多个mapper使用mapperscan

    1. 获取mapperscan的包转为类路径，并获取资源

    2. 获取资源的下类的元信息

    3. 根据类元信息判断类是否为接口，是否有mapper注解

    4. 有则注册mpper，由于获取名字的时候使用的mapperfactorybean，获取到的名字都一样，因新建一个bd，根据类的元信息获取beanname

李卫公的开平方机
关注
  • 12
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用BeanFactory实现创建对象
08-27
使用BeanFactory实现创建对象 BeanFactory是一种工厂模式，主要用来创建对象。在Java中，BeanFactory是Spring框架中的一个核心组件，用于管理和创建对象。通过使用BeanFactory，可以将对象的创建和依赖注入解耦，...
spring之beanfactory
05-26
spring之beanfactory 的一些基本知识与其关系使用
常见BeanFactory后置处理器
rrrrrrrrrfh的博客
02-02 142
BeanFactory后置处理器，最开始我们也有讲过，这里复习一下，并将一个新的beanfactroy后置处理器。先将第一个。我们先说下测试环境。执行入口我们用beanfactory的实现类。测试类是Config类，里面有@Bean注解注入的类。
Spring——BeanFactory的后置处理器
zl13101758272的博客
07-11 1086
文章目录BeanFactory的后置处理器1. BeanFactory的后置处理器是什么？2. BeanFactory的后置处理器分类3. BeanFactory的后置处理器使用3.1 BeanDefinitionRegistryPostProcessor 带注册功能的3.2 BeanFactoryPostProcessor 不带注册功能的4. BeanFactory的后置处理器IOC加载顺序。4.1 Spring自带的BeanFactory的后置处理器。4.2 自定义的BeanFactory的后置处理器。
spring beanFactory后置处理器-BeanFactoryPostProcessor
@Bean
09-07 296
spring-BeanFactoryPostProcessor有什么功能呢。他能改变bean在实例化之前的一些原注解值，比如单例变原型，手动减轻BeanFactory的工作压力。 原注解是指spring默认为bean装配的注解比如：@Scope，@lazy，@Primary，@DependsOn，@Role，@Description 直接看代码 定义一个单例bean @Componen...
Spring BeanFactory后置处理器详解之配置类解析过程
JAVA技术爱好者
11-09 957
Spring BeanFactory后置处理器详解之配置类解析过程BeanFactoryPostProcessor实现方式BeanFactory后置处理器源码分析invokeBeanFactoryPostProcessors分析 BeanFactoryPostProcessor BeanFactoryPostProcessor是spring的一大核心，也是一个扩展点之一，spring的配置类扫描解析就是使用了BeanFactoryPostProcessor来实现的；spring中的两大扩展点之一就是Bean
Spring之BeanFactory后置处理器
tututuyang的博客
07-26 763
Spring之BeanFactory后置处理器 写在前面 BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作 BeanFactoryPostProcessor => BeanFactory后置处理器 在beanFactory标准初始化之后调用 所有的bean定义已经保存加载到beanFactory，bean实例对象还没有创建出来的时候执行 demo测试 在看源码之前，先写个demo测试一下 自定义一个MyBeanFactoryPostProce
Spring注解驱动开发学习总结19：Spring容器创建 - beanFactory后置处理器的操作步骤
xueping_wu的博客
04-21 327
Spring注解驱动开发学习总结19：Spring容器创建 - beanFactory后置处理器的操作步骤1、查看Spring容器的refresh方法分析步骤5中的invokeBeanFactoryPostProcessors方法2、小结 回顾前１篇文章： １、Spring注解驱动开发学习总结18：Spring容器创建 - beanFactory创建和预准备工作步骤 分析了Spring容器refresh方法的： １）刷新前的容器准备：prepareRefresh()； ２）刷新内置的bean工厂：obtai
Spring之BeanFactory后置处理器之PropertySourcesPlaceholderConfigurer
lvyuanj的专栏
03-26 1124
Spring/SpringBoot之BeanFactory后置处理器之PropertySourcesPlaceholderConfigurer
Spring源码分析---BeanFactory 后置处理器 05
qq_36255346的博客
12-28 850
Spring源码分析---BeanFactory 后置处理器
Spring-5 常见的后置处理器
陌生的博客
11-24 722
bean后置处理器
Springboot启动流程分析（三）：刷新IOC容器之执行beanFactory后置处理器原理
bigbearxyz的博客
09-09 763
不惮其烦，逐行解析，全景再现Springboot启动流程。
简单了解Spring中BeanFactory与FactoryBean的区别
08-25
简单了解Spring中BeanFactory与FactoryBean的区别 Spring框架中有两个非常关键的接口：BeanFactory和FactoryBean。虽然它们的名字相似，但它们的作用和实现机制却有很大的不同。 BeanFactory是Spring IoC容器的...
Spring中BeanFactory解析bean详解
08-30
3. 如果bean实现了InitializingBean接口，会调用其afterPropertiesSet方法进行后置处理。 4. 如果bean定义中包含了初始化方法，也会执行这个方法。 5. 对于依赖其他bean的情况，Spring会递归地创建并注入依赖的bean...
BeanFactory的实例化
08-04
BeanFactory 的实例化方式 在 Spring 框架中，BeanFactory 是一个核心组件，负责管理和实例化 Bean。Spring 3 中提供了三种实例化 BeanFactory 的方法，下面将详细介绍这三种方法。 第一种方法：从文件系统资源...
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 284
Java爬虫Jsoup
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 698
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 953
JSON，Ajax
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 752
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Bean的后置处理器
07-29
Bean的后置处理器是一种特殊的接口，即BeanPostProcessor接口。它定义了两个方法：postProcessBeforeInitialization和postProcessAfterInitialization。\[1\]这两个方法分别在Bean的初始化之前和之后被调用，可以在这两个方法中对Bean进行一些额外的处理操作。在Spring容器中，BeanFactory和ApplicationContext对待Bean的后置处理器有一些不同。ApplicationContext容器会自动检测配置文件中实现了BeanPostProcessor接口的类，并将其注册为后置处理器，而BeanFactory容器需要通过代码显式注册后置处理器。\[2\]后置处理器可以用来修改Bean的属性或行为，例如在postProcessAfterInitialization方法中根据条件修改Bean的属性值。\[3\]通过实现BeanPostProcessor接口并重写相应的方法，我们可以自定义后置处理器来对Bean进行额外的处理。 #### 引用[.reference_title] - *1* [spring源码-bean的后置处理器](https://blog.csdn.net/sunqingzhong44/article/details/128284663)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Spring之BeanPostProcessor(后置处理器)介绍](https://blog.csdn.net/qq_38526573/article/details/88086752)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [[spring学习]5、bean的后置处理器(BeanPostProcessor)](https://blog.csdn.net/m0_51545690/article/details/125189749)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值