容器与Bean(二)

本文涉及的产品
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
简介: 容器与Bean

容器与Bean(一)https://developer.aliyun.com/article/1469469


BeanFactory 后处理器

BeanFactory 后处理器的作用

  • ConfigurationClassPostProcessor 可以解析
  • @ComponentScan
  • @Bean
  • @Import
  • @ImportResource
  • MapperScannerConfigurer 可以解析
  • Mapper 接口
  1. @ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器(即 BeanFactory)的扩展功能
  2. 这些扩展功能由不同的 BeanFactory 后处理器来完成,其实主要就是补充了一些 bean 定义

@ComponentScan底层实现过程

  1. 扫描指定包路径下的类文件。在启动Spring应用程序时,会通过ClassLoader加载应用程序的类,并扫描指定包路径下的所有类文件。Spring框架会使用ClassPathBeanDefinitionScanner类来扫描类路径,并使用ClassPathResource类来表示类路径中的资源文件。
  2. 解析类文件中的注解信息。扫描完类文件之后,Spring框架会解析类文件中的注解信息,包括@Component、@Service、@Repository等等。根据注解的不同,生成相应的Bean定义对象。
  3. 注册BeanDefinition对象。生成BeanDefinition对象之后,Spring框架会将它们注册到Bean工厂中,从而使它们成为可用的Bean对象。在这个过程中,Spring框架会使用BeanDefinitionRegistry接口来注册BeanDefinition对象,并使用BeanDefinitionReaderUtils类来加载Bean定义信息。
  4. 初始化Bean对象。当Spring框架完成Bean定义的注册之后,会自动初始化所有的Bean对象。在这个过程中,Spring框架会自动处理Bean之间的依赖关系,通过自动装配来实现依赖注入。此外,还会调用所有的@PostConstruct方法来完成Bean的初始化工作。

@Bean底层实现过程

@Bean注解是Spring框架中的一个核心注解,它用于声明一个Bean对象,并将这个对象纳入Spring容器的管理范畴。底层的具体实现过程包括以下几个步骤:

  1. 扫描@Configuration注解。当Spring容器启动时,它会扫描所有的@Configuration注解,这些注解通常用于指定配置类,也就是包含@Bean注解的类。
  2. 解析@Bean注解。在扫描到@Configuration注解后,Spring容器会解析其中的@Bean注解,检查注解中是否指定了Bean的名称。如果没有指定名称,Spring容器会使用方法名作为Bean的名称。
  3. 执行@Bean注解的方法。在解析@Bean注解后,Spring容器会执行其中的方法,并将方法返回的对象作为Bean对象注册到容器中。如果方法有参数,Spring容器会尝试自动装配这些参数,如果无法自动装配,则会抛出异常。如果有多个Bean对象匹配到了同一个参数类型,则会抛出异常。
  4. 处理Bean对象。在执行完所有的@Bean注解的方法后,Spring容器会处理这些Bean对象,包括初始化、依赖注入等操作。具体的处理过程取决于Bean对象的作用域、生命周期等属性。
  5. 注册Bean对象。在处理完所有的Bean对象后,Spring容器会将它们注册到容器中,并且为每个Bean对象分配一个唯一的ID,这个ID通常是一个字符串。我们可以使用这个ID来获取Bean对象,或者使用@Autowired注解来注入Bean对象。

Mapper 接口在Spring框架中的底层实现

在Spring框架中,MyBatis的Mapper接口底层实现主要通过动态代理实现。

MyBatis的Mapper接口主要是定义了数据访问的方法,通过Spring框架和MyBatis框架的结合,我们可以通过Mapper接口的定义,使用Spring提供的动态代理机制来自动生成Mapper接口的实现类。

具体实现过程如下:

  1. 在Spring配置文件中,需要配置MapperScannerConfigurer来扫描Mapper接口。
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.example.mapper"/>
</bean>
  1. MapperScannerConfigurer(这是一个BeanFactory的后置处理器)会扫描指定包下的Mapper接口,然后将这些接口交给SqlSessionFactoryBean(这个类实现了FactoryBean接口,getObject方法中返回了SqlSessionFactoryBean)管理,通过动态代理生成实现类。
public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean {
    private SqlSessionFactoryBean sqlSessionFactoryBean;
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 获取指定包下的所有Mapper接口,并将MapperFactoryBean注册为BeanDefinition
        for (Class<?> mapperClass : this.mapperScanner.scan()) {
            RootBeanDefinition beanDefinition = new RootBeanDefinition(MapperFactoryBean.class);
            beanDefinition.getPropertyValues().add("mapperInterface", mapperClass);
            beanDefinition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactoryBean.getObject());
            registry.registerBeanDefinition(mapperClass.getName(), beanDefinition);
        }
    }
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(this.sqlSessionFactoryBean, "Property 'sqlSessionFactory' is required");
        Assert.notNull(this.mapperScanner, "Property 'mapperScanner' is required");
    }
    // Setter for sqlSessionFactoryBean
    public void setSqlSessionFactoryBean(SqlSessionFactoryBean sqlSessionFactoryBean) {
        this.sqlSessionFactoryBean = sqlSessionFactoryBean;
    }
}
  1. MapperFactoryBean是Mapper接口的工厂类,负责生成Mapper接口的实例。
public class MapperFactoryBean<T> implements FactoryBean<T> {
    private Class<T> mapperInterface;
    private SqlSession sqlSession;
    public T getObject() throws Exception {
        //返回具体Mapper接口的代理实现类对象,注册到IoC容器中
        return this.sqlSession.getMapper(this.mapperInterface);
    }
    public Class<T> getObjectType() {
        return this.mapperInterface;
    }
    // Setter for sqlSession
    public void setSqlSession(SqlSession sqlSession) {
        this.sqlSession = sqlSession;
    }
    // Setter for mapperInterface
    public void setMapperInterface(Class<T> mapperInterface) {
        this.mapperInterface = mapperInterface;
    }
}
  1. 最后,我们就可以在业务逻辑中,直接使用@Autowired注解注入Mapper接口的实例,然后调用接口中的方法,实现对数据的访问。
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    public User getUserById(Long id) {
        return userMapper.getUserById(id);
    }
}

以上就是Mapper接口在Spring框架中的底层实现过程。通过动态代理,我们可以轻松地实现Mapper接口的定义和使用,使得数据访问变得更加简单和方便。

Aware 接口和 InitializingBean 接口

  1. Aware 接口提供了一种【内置】 的注入手段,例如
  • BeanNameAware 注入 bean 的名字
  • BeanFactoryAware 注入 BeanFactory 容器
  • ApplicationContextAware 注入 ApplicationContext 容器
  • EmbeddedValueResolverAware 注入 ${} 解析器
  1. InitializingBean 接口提供了一种【内置】的初始化手段
  2. 对比
  • 内置的注入和初始化不受扩展功能的影响,总会被执行
  • 而扩展功能受某些情况影响可能会失效
  • 因此 Spring 框架内部的类常用内置注入和初始化

代码演示

public class MyBean implements BeanNameAware, ApplicationContextAware, InitializingBean {
    private static final Logger log = LoggerFactory.getLogger(MyBean.class);
    //接口BeanNameAware重写的方法
    @Override
    public void setBeanName(String name) {
        log.debug("当前bean " + this + " 名字叫:" + name);
    }
    //接口ApplicationContextAware重写的方法
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.debug("当前bean " + this + " 容器是:" + applicationContext);
    }
    //接口InitializingBean重写的方法
    @Override
    public void afterPropertiesSet() throws Exception {
        log.debug("当前bean " + this + " 初始化");
    }
    @Autowired
    public void aaa(ApplicationContext applicationContext) {
        log.debug("当前bean " + this + " 使用@Autowired 容器是:" + applicationContext);
    }
    @PostConstruct
    public void init() {
        log.debug("当前bean " + this + " 使用@PostConstruct 初始化");
    }
}

配置类 @Autowired 失效分析

Java 配置类不包含 BeanFactoryPostProcessor 的情况

Java 配置类包含 BeanFactoryPostProcessor 的情况,因此要创建其中的 BeanFactoryPostProcessor 必须提前创建 Java 配置类,而此时的 BeanPostProcessor 还未准备好,导致 @Autowired 等注解失效

对应代码

@Configuration
public class MyConfig1 {
    private static final Logger log = LoggerFactory.getLogger(MyConfig1.class);
    @Autowired
    public void setApplicationContext(ApplicationContext applicationContext) {
        log.debug("注入 ApplicationContext");
    }
    @PostConstruct
    public void init() {
        log.debug("初始化");
    }
    @Bean //  ⬅️ 注释或添加 beanFactory 后处理器对应上方两种情况
    public BeanFactoryPostProcessor processor1() {
        return beanFactory -> {
            log.debug("执行 processor1");
        };
    }
}

注意

解决方法:

  • 用内置依赖注入和初始化取代扩展依赖注入和初始化

Bean的初始化与销毁

Spring 提供了多种初始化手段,除了课堂上讲的 @PostConstruct,@Bean(initMethod)  之外,还可以实现 InitializingBean 接口来进行初始化,如果同一个 bean 用了以上手段声明了 3 个初始化方法,那么它们的执行顺序是

  1. @PostConstruct 标注的初始化方法
  2. InitializingBean 接口的初始化方法
  3. @Bean(initMethod)  指定的初始化方法

与初始化类似,Spring 也提供了多种销毁手段,执行顺序为

  1. @PreDestroy 标注的销毁方法
  2. DisposableBean 接口的销毁方法
  3. @Bean(destroyMethod) 指定的销毁方法

Scope

在当前版本的 Spring 和 Spring Boot 程序中,支持五种 Scope

  • singleton,容器启动时创建(未设置延迟),容器关闭时销毁
  • prototype,每次使用时创建,不会自动销毁,需要调用 DefaultListableBeanFactory.destroyBean(bean) 销毁
  • request,每次请求用到此 bean 时创建,请求结束时销毁
  • session,每个会话用到此 bean 时创建,会话结束时销毁
  • application,web 容器用到此 bean 时创建,容器停止时销毁

singleton 注入其它 scope 失效

但要注意,如果在 singleton 注入其它 scope 都会有问题,解决方法有

  • @Lazy
  • @Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
  • ObjectFactory 或者 Provider
  • ApplicationContext.getBean

三种具体解决方法

@Lazy

关于@Lazy的介绍具体见这篇文章:https://www.yuque.com/weiyikai/framework/lb8lnxo0watlztqt

实现原理:

以单例注入多例为例

有一个单例对象 E

@Component
public class E {
    private static final Logger log = LoggerFactory.getLogger(E.class);
    private F f;
    public E() {
        log.info("E()");
    }
    @Autowired
    public void setF(F f) {
        this.f = f;
        log.info("setF(F f) {}", f.getClass());
    }
    public F getF() {
        return f;
    }
}

要注入的对象 F 期望是多例

@Component
@Scope("prototype")
public class F {
    private static final Logger log = LoggerFactory.getLogger(F.class);
    public F() {
        log.info("F()");
    }
}

测试

E e = context.getBean(E.class);
F f1 = e.getF();
F f2 = e.getF();
System.out.println(f1);
System.out.println(f2);

输出

com.itheima.demo.cycle.F@6622fc65
com.itheima.demo.cycle.F@6622fc65

发现它们是同一个对象,而不是期望的多例对象

对于单例对象来讲,依赖注入仅发生了一次,后续再没有用到多例的 F,因此 E 用的始终是第一次依赖注入的 F

解决

  • 使用 @Lazy生成代理(就是说加上@Lazy注解,注入的对象便是代理对象)
  • 代理对象虽然还是同一个,但当每次使用代理对象的任意方法时,由代理创建新的 f 对象

@Component
public class E {
    @Autowired
    @Lazy
    public void setF(F f) {
        this.f = f;
        log.info("setF(F f) {}", f.getClass());
    }
    // ...
}

注意

  • @Lazy也可以加在成员变量上,但加在 set 方法上的目的是可以观察输出,加在成员变量上就不行了
  • @Autowired 加在 set 方法的目的类似

输出

E: setF(F f) class com.itheima.demo.cycle.F$$EnhancerBySpringCGLIB$$8b54f2bc
F: F()
com.itheima.demo.cycle.F@3a6f2de3
F: F()
com.itheima.demo.cycle.F@56303b57

从输出日志可以看到调用 setF 方法时,f 对象的类型是代理类型

ApplicationContext.getBean

在单例 Bean 中注入多例 Bean 时,通过在单例 Bean 中使用 ApplicationContext 的 getBean() 方法获取多例 Bean,而不是通过注入的方式,可以解决多例 Bean 变成单例 Bean 的问题。因为每次获取多例 Bean 都会创建一个新的实例,而不是复用之前创建的实例。

@Service
public class SingletonService {
    @Autowired
    private ApplicationContext context;
    public PrototypeService getPrototypeService() {
        return context.getBean(PrototypeService.class);
    }
}

ObjectFactory 或者 Provider

使用 ObjectFactory 或者 Provider 接口获取多例 Bean,同样可以避免多例 Bean 变成单例 Bean 的问题。因为 ObjectFactory 和 Provider 接口都是延迟加载多例 Bean,每次调用 get() 方法都会创建一个新的实例。

@Service
public class SingletonService {
    @Autowired
    private ObjectFactory<PrototypeService> prototypeServiceObjectFactory;
    public PrototypeService getPrototypeService() {
        return prototypeServiceObjectFactory.getObject();
    }
}
@Service
public class SingletonService {
    @Autowired
    private Provider<PrototypeService> prototypeServiceProvider;
    public PrototypeService getPrototypeService() {
        return prototypeServiceProvider.get();
    }
}


目录
相关文章
|
3月前
|
XML Java 数据格式
Spring5入门到实战------7、IOC容器-Bean管理XML方式(外部属性文件)
这篇文章是Spring5框架的实战教程,主要介绍了如何在Spring的IOC容器中通过XML配置方式使用外部属性文件来管理Bean,特别是数据库连接池的配置。文章详细讲解了创建属性文件、引入属性文件到Spring配置、以及如何使用属性占位符来引用属性文件中的值。
Spring5入门到实战------7、IOC容器-Bean管理XML方式(外部属性文件)
|
12天前
|
Java 测试技术 Windows
咦!Spring容器里为什么没有我需要的Bean?
【10月更文挑战第11天】项目经理给小菜分配了一个紧急需求,小菜迅速搭建了一个SpringBoot项目并完成了开发。然而,启动测试时发现接口404,原因是控制器包不在默认扫描路径下。通过配置`@ComponentScan`的`basePackages`字段,解决了问题。总结:`@SpringBootApplication`默认只扫描当前包下的组件,需要扫描其他包时需配置`@ComponentScan`。
|
3月前
|
XML Java 数据格式
Spring5入门到实战------3、IOC容器-Bean管理XML方式(一)
这篇文章详细介绍了Spring框架中IOC容器的Bean管理,特别是基于XML配置方式的实现。文章涵盖了Bean的定义、属性注入、使用set方法和构造函数注入,以及如何注入不同类型的属性,包括null值、特殊字符和外部bean。此外,还探讨了内部bean的概念及其与外部bean的比较,并提供了相应的示例代码和测试结果。
Spring5入门到实战------3、IOC容器-Bean管理XML方式(一)
|
3月前
|
XML Java 数据格式
Spring5入门到实战------5、IOC容器-Bean管理(三)
这篇文章深入探讨了Spring5框架中IOC容器的高级Bean管理,包括FactoryBean的使用、Bean作用域的设置、Bean生命周期的详细解释以及Bean后置处理器的实现和应用。
Spring5入门到实战------5、IOC容器-Bean管理(三)
|
3月前
|
XML Java 数据格式
Spring5入门到实战------4、IOC容器-Bean管理XML方式、集合的注入(二)
这篇文章是Spring5框架的实战教程,主题是IOC容器中Bean的集合属性注入,通过XML配置方式。文章详细讲解了如何在Spring中注入数组、List、Map和Set类型的集合属性,并提供了相应的XML配置示例和Java类定义。此外,还介绍了如何在集合中注入对象类型值,以及如何使用Spring的util命名空间来实现集合的复用。最后,通过测试代码和结果展示了注入效果。
Spring5入门到实战------4、IOC容器-Bean管理XML方式、集合的注入(二)
|
3月前
|
XML Java 数据格式
Spring5入门到实战------6、IOC容器-Bean管理XML方式(自动装配)
这篇文章是Spring5框架的入门教程,详细讲解了IOC容器中Bean的自动装配机制,包括手动装配、`byName`和`byType`两种自动装配方式,并通过XML配置文件和Java代码示例展示了如何在Spring中实现自动装配。
Spring5入门到实战------6、IOC容器-Bean管理XML方式(自动装配)
|
3月前
|
XML Java 数据格式
Spring5入门到实战------8、IOC容器-Bean管理注解方式
这篇文章详细介绍了Spring5框架中使用注解进行Bean管理的方法,包括创建Bean的注解、自动装配和属性注入的注解,以及如何用配置类替代XML配置文件实现完全注解开发。
Spring5入门到实战------8、IOC容器-Bean管理注解方式
|
6月前
|
Java 容器 Spring
Spring的加载配置文件、容器和获取bean的方式
Spring的加载配置文件、容器和获取bean的方式
51 3
Spring的加载配置文件、容器和获取bean的方式
|
6月前
|
XML Java 数据格式
掌握 Spring IoC 容器与 Bean 作用域:详解 singleton 与 prototype 的使用与配置
在您的应用程序中,由 Spring IoC 容器管理的形成其核心的对象被称为 "bean"。一个 bean 是由 Spring IoC 容器实例化、组装和管理的对象
84 0
|
XML Java 数据格式
【Spring】全面讲解IOC、AOP、注入方式、bean的生命周期、aop通知应用 spring与web容器整合
Spring是一个开源的轻量级Java应用开发框架,它提供了一种简单、高效、灵活的方式来构建企业级应用程序。Spring框架的核心特点是依赖注入(Dependency Injection)和面向切面编程(Aspect-Oriented Programming),它通过一组模块化的组件提供全面的支持,使开发人员能够快速搭建可扩展、可维护的应用。