深入Spring原理-3.Bean的后置处理器

爱吃芝士的土豆倪

已于 2023-12-13 21:24:41 修改

阅读量310

点赞数 10

分类专栏： Spring 文章标签： spring java 1024程序员节

于 2023-10-23 22:36:27 首次发布

本文链接：https://blog.csdn.net/qq_40851232/article/details/134000838

版权

Spring 专栏收录该内容

8 篇文章 2 订阅

订阅专栏

👏作者简介：大家好，我是爱吃芝士的土豆倪，24届校招生Java选手，很高兴认识大家
📕系列专栏：Spring源码、JUC源码
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：源码溯源，一探究竟
📝联系方式：nhs19990716，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬👀

文章目录

Bean后置处理器与注解的关系

首先以一个没有添加额外的后置处理器来说明：️GenericApplicationContext

GenericApplicationContext context = new GenericApplicationContext();

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

    private Bean2 bean2;

    @Autowired
    public void setBean2(Bean2 bean2) {
        log.debug("@Autowired 生效: {}", bean2);
        this.bean2 = bean2;
    }

    @Autowired
    private Bean3 bean3;

    @Resource
    public void setBean3(Bean3 bean3) {
        log.debug("@Resource 生效: {}", bean3);
        this.bean3 = bean3;
    }

    private String home;

    @Autowired
    public void setHome(@Value("${JAVA_HOME}") String home) {
        log.debug("@Value 生效: {}", home);
        this.home = home;
    }

    @PostConstruct
    public void init() {
        log.debug("@PostConstruct 生效");
    }

    @PreDestroy
    public void destroy() {
        log.debug("@PreDestroy 生效");
    }

    @Override
    public String toString() {
        return "Bean1{" +
               "bean2=" + bean2 +
               ", bean3=" + bean3 +
               ", home='" + home + '\'' +
               '}';
    }
}

public class Bean2 {
}

public class Bean3 {
}

// ⬇️用原始方法注册三个 bean
context.registerBean("bean1", Bean1.class);
context.registerBean("bean2", Bean2.class);
context.registerBean("bean3", Bean3.class);

context.refresh(); // 执行beanFactory后处理器, 添加bean后处理器, 初始化所有单例

运行发现，bean1 bean2 bean3 并没有被注册成功！

通过分析原因是因为 bean1 中得 @Autowired 和 @ value并没有生效，那么接下来启用它

// 自动装配候选者的解析器
        context.getDefaultListableBeanFactory().setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        context.registerBean(AutowiredAnnotationBeanPostProcessor.class); // @Autowired @Value

此时 bean 中的 @Autowired 和 @Value 就被注入了

[DEBUG] 21:07:55.642 [main] com.itheima.a04.Bean1               - @Value 生效: C:\Program Files\Java\jdk1.8.0_231 
[DEBUG] 21:07:55.647 [main] com.itheima.a04.Bean1               - @Autowired 生效: com.itheima.a04.Bean2@120f102b

而如果想要@Resource @PostConstruct @PreDestroy 也被注入，需要启动这个

context.registerBean(CommonAnnotationBeanPostProcessor.class); // @Resource @PostConstruct @PreDestroy

效果如下：

[DEBUG] 21:12:03.082 [main] com.itheima.a04.Bean1               - @Resource 生效: com.itheima.a04.Bean3@37858383 
[DEBUG] 21:12:03.093 [main] com.itheima.a04.Bean1               - @Autowired 生效: com.itheima.a04.Bean2@59af0466 
[DEBUG] 21:12:03.102 [main] com.itheima.a04.Bean1               - @Value 生效: C:\Program Files\Java\jdk1.8.0_231 
[DEBUG] 21:12:03.102 [main] com.itheima.a04.Bean1               - @PostConstruct 生效 
[DEBUG] 21:12:03.186 [main] com.itheima.a04.Bean1               - @PreDestroy 生效

通过上述其实可以看到， @Autowired 等注解的解析属于 bean 生命周期阶段（依赖注入，初始化）的扩展功能，而这些扩展功能由bean的后处理器完成。

并且仔细观察输出的结果可以发现，先 @Resource 后 @Autowired，这是其源码的执行顺序有关，其@Resource逻辑判断在@Autowired之前。

以上是加载一些普通类，但是对于加载配置类其实还是不行的

@ConfigurationProperties(prefix = "java")
public class Bean4 {

    private String home;

    private String version;

    public String getHome() {
        return home;
    }

    public void setHome(String home) {
        this.home = home;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    @Override
    public String toString() {
        return "Bean4{" +
               "home='" + home + '\'' +
               ", version='" + version + '\'' +
               '}';
    }
}

context.registerBean("bean4", Bean4.class);
System.out.println(context.getBean(Bean4.class));

发现其配置类中并没有成功加载上对应的home 和 version

Bean4{home='null', version='null'}

其实在这里还是需要添加一个新的后置处理器：

ConfigurationPropertiesBindingPostProcessor.register(context.getDefaultListableBeanFactory());

其实到这里，本质就是说明了常用注解与后置处理器之间的关系，需要加入对应的后置处理器，才会让这些注解生效。

详解Bean后置处理器生效的过程

还是以上面的代码举例：

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        beanFactory.registerSingleton("bean2", new Bean2()); // 创建过程,依赖注入,初始化
        beanFactory.registerSingleton("bean3", new Bean3());
        beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); // @Value

实际上刚才让 @Autowired 和 @Value 起作用的是AutowiredAnnotationBeanPostProcessor.class

那么接下来就进入内部来看看具体的实现流程吧。

// 查找哪些属性、方法加了 @Autowired, 这称之为 InjectionMetadata
AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        processor.setBeanFactory(beanFactory);

        // 自己创建的，依赖注入等都不会生效
        Bean1 bean1 = new Bean1();
        System.out.println(bean1);
        processor.postProcessProperties(null, bean1, "bean1"); // 执行依赖注入 @Autowired @Value
        System.out.println(bean1);

输出：

Bean1{bean2=null, bean3=null, home='null'}
[DEBUG] 21:32:35.864 [main] com.itheima.a04.Bean1               - @Value 生效: ${JAVA_HOME} 
[DEBUG] 21:32:35.873 [main] com.itheima.a04.Bean1               - @Autowired 生效: com.itheima.a04.Bean2@4562e04d 
Bean1{bean2=com.itheima.a04.Bean2@4562e04d, bean3=com.itheima.a04.Bean3@2a65fe7c, home='${JAVA_HOME}'}

其实可以发现，当processor.postProcessProperties(null, bean1, “bean1”); 之后，实际上bean1已经被注入了

而后进入到postProcessProperties方法查看

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);

        try {
            metadata.inject(bean, beanName, pvs);
            return pvs;
        } catch (BeanCreationException var6) {
            throw var6;
        } catch (Throwable var7) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
        }
    }

可以看到，发现发现findAutowiringMetadata 其实也就是那些属性，那些方法参数上由Autowired注解，找到以后，封装到InjectionMetadata中，然后Inject进去。

进入findAutowiringMetadata里面查看发现：

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        String cacheKey = StringUtils.hasLength(beanName) ? beanName : clazz.getName();
        InjectionMetadata metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized(this.injectionMetadataCache) {
                metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }

                    metadata = this.buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }

        return metadata;
    }

其是private，那么我们首先用反射的方式获取到这个方法：

// 拿到私有方法
        Method findAutowiringMetadata = AutowiredAnnotationBeanPostProcessor.class.getDeclaredMethod("findAutowiringMetadata", String.class, Class.class, PropertyValues.class);
        findAutowiringMetadata.setAccessible(true);

// 这行代码其实就是去执行了findAutowiringMetadata，分析bean1这个类中，有那个有autowire修饰 解析器收集起来
        InjectionMetadata metadata = (InjectionMetadata) findAutowiringMetadata.invoke(processor, "bean1", Bean1.class, null);// 获取 Bean1 上加了 @Value @Autowired 的成员变量，方法参数信息
// 由于有些方法并没有重写toString，所以需要加 断点来测试
        System.out.println(metadata);

断点如图所示：

在这里插入图片描述

此时其实就是找到了所有的@Autowired

此时调用 InjectionMetadata 来进行依赖注入, 注入时按类型查找值

metadata.inject(bean1, "bean1", null);
System.out.println(bean1);

而inject做了什么呢？首先通过反射获取到成员变量或者方法

Field bean3 = Bean1.class.getDeclaredField("bean3");
DependencyDescriptor dd1 = new DependencyDescriptor(bean3, false);
// 根据成员变量的信息得到类型
Object o = beanFactory.doResolveDependency(dd1, null, null, null);
System.out.println(o);

这段代码其实也就是inject的本质了，首先通过反射API来获取Bean1类中名为“bean3”的成员变量的Field对象，然后Spring内部封装了一个DependencyDescriptor 对象来描述bean3成员变量的依赖，最后，会调用doResolveDependency（）方法来解析 bean3的依赖，这意味着Spring会尝试查找并注入名为“bean3”的成员变量所需的Bean，然后打印返回值，这主要是 “bean3”的依赖，也就是所需要的 Bean的实例。

而@Autowired的方法也大同小异：

Method setBean2 = Bean1.class.getDeclaredMethod("setBean2", Bean2.class);
DependencyDescriptor dd2 =
                new DependencyDescriptor(new MethodParameter(setBean2, 0), true);
Object o1 = beanFactory.doResolveDependency(dd2, null, null, null);
System.out.println(o1);

Method setHome = Bean1.class.getDeclaredMethod("setHome", String.class);
DependencyDescriptor dd3 = new DependencyDescriptor(new MethodParameter(setHome, 0), true);
Object o2 = beanFactory.doResolveDependency(dd3, null, null, null);
System.out.println(o2);

BeanFactory后置处理器与注解关系

还是以一个例子来讲解吧

GenericApplicationContext context = new GenericApplicationContext();
context.registerBean("config", Config.class);

@Configuration
@ComponentScan("com.itheima.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/test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }
}

public class Bean1 {

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

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

context.refresh();

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

实际上输出只会打印出来config，并没有其他的，结合Bean后置处理器与注解的关系，我们可以轻易的想到，一定是缺少了什么后置处理器，所以导致其他的输出不出来。

context.registerBean(ConfigurationClassPostProcessor.class); // @ComponentScan @Bean @Import @ImportResource

发现输出结果和我们预期的是一致的：

[DEBUG] 22:07:04.915 [main] com.itheima.a05.component.Bean2     - 我被 Spring 管理啦 
[DEBUG] 22:07:04.919 [main] com.itheima.a05.component.Bean3     - 我被 Spring 管理啦 
[DEBUG] 22:07:04.928 [main] com.itheima.a05.Bean1               - 我被 Spring 管理啦 
[INFO ] 22:07:05.039 [main] c.a.druid.pool.DruidDataSource      - {dataSource-1} inited 
config
org.springframework.context.annotation.ConfigurationClassPostProcessor
bean2
bean3
bean1
sqlSessionFactoryBean
dataSource
[INFO ] 22:07:05.107 [main] c.a.druid.pool.DruidDataSource      - {dataSource-1} closing ... 
[INFO ] 22:07:05.108 [main] c.a.druid.pool.DruidDataSource      - {dataSource-1} closed

以上其实就将我们的beanFactory 配置好了，config里面的配置都被注册成了bean，用过Mybatis的都知道，最终我们使用的是Mapper接口，如果我们配置了Mapper接口，那么是否会被注册进来呢？

@Mapper
public interface Mapper1 {
}

@Mapper
public interface Mapper2 {
}

测试发现并没有，所以还需要配置另一种后置处理器

context.registerBean(MapperScannerConfigurer.class, bd -> { // @MapperScanner  自动配置间接的用到了这个
            bd.getPropertyValues().add("basePackage", "com.itheima.a05.mapper");
        });

此时在结果中可以看到，mapper1 mapper2都被注册进来了。

通过上文可以看到@ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器(即 BeanFactory)的扩展功能，这些扩展功能由不同的 BeanFactory 后处理器来完成, 其实主要就是补充了一些 bean 定义。

详解BeanFactory后置处理器生效的过程

@ComponentScan

public class ComponentScanPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override // context.refresh 这个方法在所有的bean定义都已经被加载并且bean实例化之前调用。它允许你在实例化之前对bean工厂进行后置处理操作
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
    // 模拟解析
    @Override // 这个方法在所有的bean定义被加载，但是还未实例化之前调用。它允许你对注册的bean定义进行修改、添加或删除。
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
        try {
            // 扫描Config类里面的ComponentScan注解
            ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
            if (componentScan != null) {
                // 便利包结构
                for (String p : componentScan.basePackages()) {
                    System.out.println(p);
                    // com.itheima.a05.component -> classpath*:com/itheima/a05/component/**/*.class
                    String path = "classpath*:" + p.replace(".", "/") + "/**/*.class";
                    System.out.println(path);
                    // 读取类的原信息
                    CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                    // 根据指定的路径来获取所有符合条件的资源文件
                    Resource[] resources = new PathMatchingResourcePatternResolver().getResources(path);
                    // 用于生成Bean名称的策略类
                    AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
                    for (Resource resource : resources) {
                        // System.out.println(resource);
                        // 读取每一个class
                        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())) {

                            /**
                             创建一个通用的Bean定义实例，该实例基于提供的类名（reader.getClassMetadata().getClassName()）创建。
                             具体来说，它会为给定的类名创建一个RootBeanDefinition实例，该实例包含了类的元数据信息。
                             */

                            AbstractBeanDefinition bd = BeanDefinitionBuilder
                                    .genericBeanDefinition(reader.getClassMetadata().getClassName())
                                    .getBeanDefinition();

                            /**
                             然后，使用generateBeanName()方法生成一个唯一的Bean名称。这个方法会根据给定的Bean定义
                             和Bean工厂的规则来生成一个合适的名称。生成的名称通常会基于类名，并在名称冲突时添加序号以保证唯一性。
                             */

                            String name = generator.generateBeanName(bd, beanFactory);

                            /**
                             最后，通过beanFactory.registerBeanDefinition()方法将生成的Bean定义注册到Bean工厂中，
                             使得该Bean能够被Spring容器管理和使用。
                             */

                            beanFactory.registerBeanDefinition(name, bd);
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

其实本质上就是读取@ComponentScan 注解里面的包结构，然后遍历每一个包路径里面所有的资源，如果对应的资源有@Component 或者器派生类的话，就将其注入进去即可。

输出：

com.itheima.a05.component
classpath*:com/itheima/a05/component/**/*.class
[DEBUG] 22:18:26.118 [main] com.itheima.a05.component.Bean2     - 我被 Spring 管理啦 
[DEBUG] 22:18:26.121 [main] com.itheima.a05.component.Bean3     - 我被 Spring 管理啦 
config
com.itheima.a05.ComponentScanPostProcessor
bean2
bean3

@Bean

上面的输出其实并没有把config里面的三个bean也注入进去，所以还需要完善bean的注入：

public class AtBeanPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }

    /**

     优化点： 路径 和 配置类写死了
     理论上先找到所有的配置类，然后对配置类在进行操作

     */

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
        try {
            CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
            MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/itheima/a05/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();
                // 定义config里面的工厂方法
                builder.setFactoryMethodOnBean(method.getMethodName(), "config");
                // 自动装配，因为sqlSessionFactoryBean 有参数，需要将dataSource 装配进来
                // 构造方法的参数，工厂方法的参数，自动装配，选择装配模式AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR
                builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);

                if (initMethod.length() > 0) {

                    /**
                     builder.setInitMethodName(initMethod) 方法的作用是将初始化方法名称设置到 BeanDefinitionBuilder 中，
                     让 Spring 容器在创建 bean 实例之后，自动调用这个指定的初始化方法。

                     具体而言，当使用 BeanDefinitionBuilder 构建一个 BeanDefinition 对象时，可以通过该方法来设置创建的 bean
                     需要执行的初始化方法名称，从而在创建 bean 实例时自动调用这个方法。
                     */

                    builder.setInitMethodName(initMethod);
                }

                AbstractBeanDefinition bd = builder.getBeanDefinition();
                beanFactory.registerBeanDefinition(method.getMethodName(), bd);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

本质上的解析其实也都是类似的，不用的在于，没有遍历包路径这一层，只需要遍历指定 config.class里面的方法即可。

此时其实打印输出就可以看到里面的bean也被注入了。

@Mapper

mapper接口其实和前两个还不太一样，比如将其注册在BeanFactory中：

	@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其实也是能被注入的，但是如果手动的将 mapper包下的所有接口都这样注入，岂不是要麻烦死，而且也不符合自动注入的思想对吧？那么可以这样：

public class MapperPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
        try {
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            Resource[] resources = resolver.getResources("classpath:com/itheima/a05/mapper/**/*.class");
            AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
            CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
            for (Resource resource : resources) {
                MetadataReader reader = factory.getMetadataReader(resource);
                ClassMetadata classMetadata = reader.getClassMetadata();
                // 判断是接口 还是 实现类
                if (classMetadata.isInterface()) {

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


                    AbstractBeanDefinition bd = BeanDefinitionBuilder.genericBeanDefinition(MapperFactoryBean.class)
                            .addConstructorArgValue(classMetadata.getClassName())
                            .setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE)
                            .getBeanDefinition();

                    AbstractBeanDefinition bd2 = BeanDefinitionBuilder.genericBeanDefinition(classMetadata.getClassName()).getBeanDefinition();

                    /**
                     如果直接使用bd 来生成名字，由于 MapperFactoryBean.class 所以 两个mapper 都是 叫 MapperFactoryBean
                     所以参考spring源码 以classMetadata.getClassName() 作为名字生成bean
                     */

                    String name = generator.generateBeanName(bd2, beanFactory);
                    beanFactory.registerBeanDefinition(name, bd);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

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

    }
}

其实本质上还是和前两种是一样的，但是在这里有一个坑，就是命名上，如果直接使用bd 来生成名字，由于 MapperFactoryBean.class是唯一的所以两个mapper 都是叫 MapperFactoryBean，所以在这里，参考Spring源码，用第二个AbstractBeanDefinition 以classMetadata.getClassName() 作为名字生成bean。这样就不会出现重名的问题了。

爱吃芝士的土豆倪

关注

10
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
深入Spring原理-3.Bean的后置处理器

对象来描述bean3成员变量的依赖，最后，会调用doResolveDependency（）方法来解析 bean3的依赖，这意味着Spring会尝试查找并注入名为“bean3”的成员变量所需的Bean，然后打印返回值，这主要是 “bean3”的依赖，也就是所需要的 Bean的实例。以上其实就将我们的beanFactory 配置好了，config里面的配置都被注册成了bean，用过Mybatis的都知道，最终我们使用的是Mapper接口，如果我们配置了Mapper接口，那么是否会被注册进来呢？
复制链接

扫一扫