【第五讲】BeanFactory 后处理器

已于 2022-08-20 16:59:38 修改
阅读量506 收藏
点赞数
分类专栏： 黑马spring高级49讲 文章标签： spring java mybatis
于 2022-08-09 22:56:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25614773/article/details/126257395
版权

第五讲 BeanFactory 后处理器

  1. BeanFactory 后处理器的作用：为BeanFactory提供扩展
  2. 常见的BeanFactory后处理器

文章目录


定义 Bean1、 Bean2、 Mapper1、 Mapper2、 Config 5个类

  • Bean2上面加上@Component
  • Config上加@Component注解和@ComponentScan注解，Config中通过@Bean注解定义Bean1
  • Mapper1、Mapper2上加@Mapper注解

Config

@Component
@ComponentScan("com/example/spring01/com/a05")
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://120.77.215.102:3306/czctest?characterEncoding=utf-8");
        dataSource.setUsername("root");
        dataSource.setPassword("czc521190");
        return dataSource;
    }
}

Bean1和Bean2

@Slf4j
public class Bean1 {

    public Bean1(){
        log.info("我是被 spring 管理啦");
    }
}
-----------------------------------------
@Component
@Slf4j
public class Bean2 {
    public Bean2(){
        log.info("我是被 spring 管理啦");
    }
}

Mapper1和Mapper2

@Mapper
public interface Mapper1 {
}
----------------------------
@Mapper
public interface Mapper2 {
}

TestBeanFactoryPostProcessors

public class TestBeanFactoryPostProcessors {

    public static void main(String[] args) {
        // GenericApplicationContext 是一个【干净】的容器，默认不会添加任何后处理器，方便做测试
        GenericApplicationContext context = new GenericApplicationContext();

        context.registerBean("config",Config.class);
        // 解析@ComponentScan、@Bean、@Import、@ImportResource注解
        context.registerBean(ConfigurationClassPostProcessor.class);
        // 添加Bean工厂后处理器MapperScannerConfigurer，解析@MapperScan注解
        context.registerBean(MapperScannerConfigurer.class,db->{
            db.getPropertyValues().add("basePackage","com/example/spring01/com/a05/mapper");
        });

        // 初始化容器
        context.refresh();


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

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

}

在这里插入图片描述

结论

  1. @Component、@Bean对应的Bean工厂后处理器是ConfigurationClassPostProcessor；
  2. @MapperScan对应的Bean工厂后处理器是MapperScannerConfigurer。
ComponentScan将加了
@Controller，@Repository，@Service,@Component注解的类注册到spring容器中

模拟ComponentScan实现

public static void main(String[] args) throws Exception {
    // GenericApplicationContext 是一个【干净】的容器，默认不会添加任何后处理器，方便做测试
    GenericApplicationContext context = new GenericApplicationContext();
    context.registerBean("config",Config.class);
    // 模拟@ComponentScan
    ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
    if(componentScan != null){
        for (String s : componentScan.basePackages()) {
            System.out.println(s);
            //com.example.spring01.com.a05.component -> classpath*:com/example/spring01/com/a05/component/**/*.class
            String path =  "classpath*:" + s.replace(".","/") + "/**/*.class";
            System.out.println(path);
            CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
            Resource[] resources = context.getResources(path);
            AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
            for (Resource resource : resources) {
                System.out.println("resource---"+resource);
                MetadataReader reader = factory.getMetadataReader(resource);
                AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
                System.out.println("类名："+ reader.getClassMetadata().getClassName());
                System.out.println("是否加了 @Component 注解：" + annotationMetadata.hasAnnotation(Component.class.getName()));
                System.out.println("是否加了 @Component派生 注解：" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));
                // 如果加了@Component 注解 或在 @Component派生 注解
                if(annotationMetadata.hasAnnotation(Component.class.getName() ) || annotationMetadata.hasMetaAnnotation(Component.class.getName())){
                    // 生成 beanDefinition
                    AbstractBeanDefinition bd =
                        BeanDefinitionBuilder.genericBeanDefinition(reader.getClassMetadata().getClassName()).getBeanDefinition();
                    DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();
                    String beanName = generator.generateBeanName(bd, beanFactory);
                    beanFactory.registerBeanDefinition(beanName,bd);
                }
            }
        }
    }
    // 初始化容器
    context.refresh();

    for (String name:context.getBeanDefinitionNames()){
        System.out.println("name--:"+name);
    }
    // 容器销毁
    context.close();
}

自定义一个后处理器ComponentScanPostProcessor, 来解析@Component

实现BeanFactoryPostProcessor两处修改

  1. context.getResources(path) -> new PathMatchingResourcePatternResolver().getResources(path);

  2. DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();
-------------
if(configurableListableBeanFactory instanceof DefaultListableBeanFactory){
    DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;
    String beanName = generator.generateBeanName(bd, beanFactory);
    beanFactory.registerBeanDefinition(beanName,bd);
}

public class ComponentScanPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        try {
            // 模拟@ComponentScan
            ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
            if(componentScan != null){
                for (String s : componentScan.basePackages()) {
                    System.out.println(s);
                    //com.example.spring01.com.a05.component -> classpath*:com/example/spring01/com/a05/component/**/*.class
                    String path =  "classpath*:" + s.replace(".","/") + "/**/*.class";
                    System.out.println(path);
                    CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                    Resource[] resources = new PathMatchingResourcePatternResolver().getResources(path);
                    AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
                    for (Resource resource : resources) {
                        System.out.println("resource---"+resource);
                        MetadataReader reader = factory.getMetadataReader(resource);
                        AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
                        System.out.println("类名："+ reader.getClassMetadata().getClassName());
                        System.out.println("是否加了 @Component 注解：" + annotationMetadata.hasAnnotation(Component.class.getName()));
                        System.out.println("是否加了 @Component派生 注解：" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));
                        // 如果加了@Component 注解 或在 @Component派生 注解
                        if(annotationMetadata.hasAnnotation(Component.class.getName() ) || annotationMetadata.hasMetaAnnotation(Component.class.getName())){
                            // 生成 beanDefinition
                            AbstractBeanDefinition bd =
                                    BeanDefinitionBuilder.genericBeanDefinition(reader.getClassMetadata().getClassName()).getBeanDefinition();

                            if(configurableListableBeanFactory instanceof DefaultListableBeanFactory){
                                DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;
                                String beanName = generator.generateBeanName(bd, beanFactory);
                                beanFactory.registerBeanDefinition(beanName,bd);
                            }

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

引用自己写的后处理器

public static void main(String[] args) throws Exception {
    // GenericApplicationContext 是一个【干净】的容器，默认不会添加任何后处理器，方便做测试
    GenericApplicationContext context = new GenericApplicationContext();
    context.registerBean("config",Config.class);

    context.registerBean(ComponentScanPostProcessor.class);
    // 初始化容器
    context.refresh();

    for (String name:context.getBeanDefinitionNames()){
        System.out.println("name--:"+name);
    }
    // 容器销毁
    context.close();
}

自定义一个CandyComponentScanPostProcessor 来解析@Component注解

实现BeanDefinitionRegistryPostProcessor

两次修改

  1. context.getResources(path) -> new PathMatchingResourcePatternResolver().getResources(path);

  2. 去掉DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();

public class CandyComponentScanPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
       try {
           // 模拟@ComponentScan
           ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
           if(componentScan != null){
               for (String s : componentScan.basePackages()) {
                   System.out.println(s);
                   //com.example.spring01.com.a05.component -> classpath*:com/example/spring01/com/a05/component/**/*.class
                   String path =  "classpath*:" + s.replace(".","/") + "/**/*.class";
                   System.out.println(path);
                   CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                   Resource[] resources = new PathMatchingResourcePatternResolver().getResources(path);
                   AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
                   for (Resource resource : resources) {
                       System.out.println("resource---"+resource);
                       MetadataReader reader = factory.getMetadataReader(resource);
                       AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
                       System.out.println("类名："+ reader.getClassMetadata().getClassName());
                       System.out.println("是否加了 @Component 注解：" + annotationMetadata.hasAnnotation(Component.class.getName()));
                       System.out.println("是否加了 @Component派生 注解：" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));
                       // 如果加了@Component 注解 或在 @Component派生 注解
                       if(annotationMetadata.hasAnnotation(Component.class.getName() ) || annotationMetadata.hasMetaAnnotation(Component.class.getName())){
                           // 生成 beanDefinition
                           AbstractBeanDefinition bd =
                                   BeanDefinitionBuilder.genericBeanDefinition(reader.getClassMetadata().getClassName()).getBeanDefinition();
                           String beanName = generator.generateBeanName(bd, beanFactory);
                           beanFactory.registerBeanDefinition(beanName,bd);
                       }
                   }
               }
           }
       }catch (IOException e) {
           e.printStackTrace();
       }
    }

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

    }
}

工程后处理器模拟实现@Bean

CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/example/spring01/com/a05/Config.class"));
Set<MethodMetadata> methods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
for (MethodMetadata method : methods) {
    System.out.println("method:" + method);

    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    builder.setFactoryMethodOnBean(method.getMethodName(),"config");
    builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
    AbstractBeanDefinition bd = builder.getBeanDefinition();
    context.getDefaultListableBeanFactory().registerBeanDefinition(method.getMethodName(),bd);

    String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
    if(initMethod.length() >0 ){
        builder.setInitMethodName(initMethod);
    }
}

实现BeanFactoryPostProcessor

AtBeanPostProcessor 类

public class AtBeanPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        try {
            CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
            MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/example/spring01/com/a05/Config.class"));
            Set<MethodMetadata> methods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
            for (MethodMetadata method : methods) {
                System.out.println("method:" + method);

                BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
                builder.setFactoryMethodOnBean(method.getMethodName(),"config");
                builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
                AbstractBeanDefinition bd = builder.getBeanDefinition();
                if(configurableListableBeanFactory instanceof DefaultListableBeanFactory) {
                    DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;
                    beanFactory.registerBeanDefinition(method.getMethodName(), bd);
                }
                String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
                if(initMethod.length() >0 ){
                    builder.setInitMethodName(initMethod);
                }
            }

        }catch (Exception e){

        }
    }
}

工厂后处理器模拟实现—Mapper

在Config，使用@Bean 注册

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

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

在这里插入图片描述

自定义 MapperPostProcessor

这里不能使用名字生成器和MapperFactoryBean的BeanDefinition作为参数直接生成名字，这样会导致多个相同的类型的对象因为名字一样产生覆盖的问题
解决办法 这里参考Spring源码的做法用@Mapper注解修饰的接口的BeanDefinition作为参数生成名字

public class MapperPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
        try {
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            Resource[] resources = resolver.getResources("classpath:com/example/spring01/com/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()) {

                    AbstractBeanDefinition bd = BeanDefinitionBuilder
                        .genericBeanDefinition(MapperFactoryBean.class)
                        .addConstructorArgValue(classMetadata.getClassName())
                        .setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE)
                        .getBeanDefinition();
                    
                    AbstractBeanDefinition bd2 = BeanDefinitionBuilder.genericBeanDefinition(classMetadata.getClassName()).getBeanDefinition();
                    String name = generator.generateBeanName(bd2, beanFactory);
                    beanFactory.registerBeanDefinition(name,bd);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

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

    }
}
DisguiseR6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring系列 BeanFactoryPostProcessor后置处理器（超通俗易懂）
weixin_45663027的博客
09-23 90
- @ComponentScan, @Bean, @Mapper @Import @ImportResource等注解的解析属于BeanFactory的扩展功能。这些扩展功能由不同的 BeanFactory 后处理器来完成。BeanFactory后置处理器允许开发者在Spring容器实例化Bean之前对BeanFactory的配置元数据进行修改，或者对BeanDefinition进行进一步的操作。它们可以用于动态修改Bean的属性值、添加新的BeanDefinition、移除不需要的BeanDefinit
Spring源码系列-第2章-后置工厂处理器和Bean生命周期
最新发布
xiejunxing的专栏
07-12 794
*** @param bean the new bean instance 正在创建的bean的实例* @param beanName the name of the bean 该bean的名称返回的bean是包装过后的bean*/ /*** 这个方法是BeanPostProcessor接口中的一个方法，* 用于在bean初始化回调之前(如InitializingBean的afterPropertiesSet或自定义init-method)，
Spring原理学习（三）：BeanFactory后处理器原理解析与模拟实现
m0_49499183的博客
04-07 349
我们已经简单介绍了 BeanFactory后处理器 的作用，今天我们先再来再次体验一下。先准备一个主启动类：然后准备一个bean，上面加了@Configuration和 @Bean 注解；并且加上了@ComponentScan 注解，应该能扫描到加有@Component注解的Bean2。所以config容器里应该有5个bean：config本身、扫描到的bean2、自己管理的三个（bean2、sqlSessionFactory、druidDataSource）。
Spring（六）- BeanFactoryPostProcessor 与 BeanPostProcessor 后处理器
及时当勉励，岁月不待人
11-07 832
Spring（六）- BeanFactoryPostProcessor 与 BeanPostProcessor 后处理器
【探索Spring底层】4.BeanFactory后处理器
沉迷写代码的程序猿的博客
09-02 477
*然后，第三步new一个PathMatchingResourcePatternResolver对象，利用getResources获取上面拼接好的路径的资源，接着遍历这些资源（class文件）。**PathMatchingResourcePatternResolver是实现了ResourcePatternResolver接口的一个类，所以有getResources方法。...
Spring in Action(第2版)中文版
04-09
第5章使用数据库 5.1spring的数据访问哲学 5.1.1了解spring数据访问的异常体系 5.1.2数据访问的模板化 5.1.3使用dao支持类 5.2配置数据源 5.2.1使用jndi数据源 5.2.2使用数据源连接池 5.2.3基于jdbc驱动的...
CGB_面试题_第三阶段.docx
02-17
其处理流程包括：客户端发送请求到 DispatcherServlet，DispatcherServlet 分发请求到处理器映射器找到合适的 Handler，处理器适配器调用 Handler 处理请求，Handler 返回 ModelAndView 对象，视图解析器解析并渲染...
第一周总结(1).doc
12-22
2. DispatcherServlet调用HandlerMapping找到对应的处理器（Controller）和拦截器。 3. HandlerAdapter处理Controller，执行其业务逻辑。 4. Controller返回ModelAndView对象。 5. DispatcherServlet调用...
Spring Context内部知识：第1部分-刷新
04-05
5. **Bean后处理器注册**：在bean实例化和注入之后，Spring会查找并注册BeanPostProcessor。这些处理器可以自定义bean的初始化和销毁过程，例如AOP代理的创建。 6. **初始化回调**：所有bean实例化和依赖注入完成后...
第二十章 Spring 应用上下文生命周期（ApplicationContext Lifecycle）1
08-04
`prepareBeanFactory()`方法中，ApplicationContext与ClassLoader关联，配置Bean表达式处理器，并添加PropertyEditorRegistrar以处理类型转换。同时，注册实现特定Aware接口的BeanPostProcessor，如...
第五天 BeanFactory 后处理器的作用
long_timenosee的博客
03-14 94
【代码】第五天 BeanFactory 后处理器的作用。
Spring之BeanFactory后置处理器
tututuyang的博客
07-26 771
Spring之BeanFactory后置处理器 写在前面 BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作 BeanFactoryPostProcessor => BeanFactory后置处理器 在beanFactory标准初始化之后调用 所有的bean定义已经保存加载到beanFactory，bean实例对象还没有创建出来的时候执行 demo测试 在看源码之前，先写个demo测试一下 自定义一个MyBeanFactoryPostProce
【Spring学习24】容器扩展点：后置处理器BeanFactoryPostProcessor
程序老兵的博客
04-06 4749
上篇说到的BeanPostProcessor(Bean后置处理器)常用在对bean内部的值进行修改；实现Bean的动态代理等。 BeanFactoryPostProcessor和BeanPostProcessor都是spring初始化bean时对外暴露的扩展点。但它们有什么区别呢？ 由《理解Bean生命周期》的图可知：BeanFactoryPostProcessor是生命周期中最早被调用的，远远
Spring源码分析 (bean后置处理器的创建过程 + 注册监听器) (十三)
959
05-06 666
文章目录1.bean后置处理器的创建过程2.注册监听器部分/Spring如何按照类型找到组件2.1 注册监听器2.2 Spring如何按照类型找到组件 1.bean后置处理器的创建过程 refresh() registerBeanPostProcessors() PostProcessorRegistrationDelegate: 这个类是管理全部的后置处理器的类 public static void registerBeanPostProcessors( ConfigurableListabl
Spring BeanFactory后置处理器详解之配置类解析过程
JAVA技术爱好者
11-09 962
Spring BeanFactory后置处理器详解之配置类解析过程BeanFactoryPostProcessor实现方式BeanFactory后置处理器源码分析invokeBeanFactoryPostProcessors分析 BeanFactoryPostProcessor BeanFactoryPostProcessor是spring的一大核心，也是一个扩展点之一，spring的配置类扫描解析就是使用了BeanFactoryPostProcessor来实现的；spring中的两大扩展点之一就是Bean
spring的组件工厂后置处理器——BeanFactoryPostProcessor
weixin_38170255的博客
04-21 134
作用和调用时机 spring有两种后置处理器： 1. 组件后置处理器——org.springframework.beans.factory.config.BeanPostProcessor； 2. 工厂后置处理器——org.springframework.beans.factory.config.BeanFactoryPostProcessor。 根据名字可以看出，前者是处理组件...
Spring源码之BeanFactory后置处理器BeanDefinitionRegistryPostProcessor和ImportBeanDefinitionRegistrar
qq_36446085的博客
05-07 1627
BeanFactory后置处理器 BeanDefinitionRegistryPostProcessor和ImportBeanDefinitionRegistrar的区别 要想了解BeanDefinitionRegistryPostProcessor， 那就要从他的父接口BeanFactoryPostProcessor说起 1、BeanFactoryPostProcessor @Functiona...
spring的启动过程04-bean后置处理器
stone3gao的博客
12-30 1619
概述： spring在初始化bean实例的过程中，需要做个性化的处理如解析注解，每个注解的解析逻辑千变万化有spring自带的有用户自定义的。这里spring就想到了采用注册bean处理器的方式处理个性化需求，该种方式类似于intercept功能，又类似于AOP横向切面的概念，因为它同样提供前置处理逻辑及后置处理逻辑，下面具体分析下这种方式的实现过程。 原理： 找到注册bean处理器的触发点
spring后置处理器
u013376634的博客
01-12 7020
1. BeanPostProcessor bean的后置处理器，主要在bean初始化前后工作。接口定义： public interface BeanPostProcessor { // 在初始化方法(如：afterPropertiesSet 或 init-method)执行前触发 @Nullable default Object postProcessBeforeInitializatio...
beanfactory
06-09
5. 支持国际化：BeanFactory提供了国际化支持，可以根据不同的语言环境加载不同的Bean对象。 BeanFactory是Spring框架中最基础的接口，它定义了IoC容器最基础的形式。在实际开发中，我们通常使用更高级的接口，如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值