Spring容器与bean

容器接口

  • BeanFactory 接口,典型功能有:

    • getBean
  • ApplicationContext 接口,是 BeanFactory 的子接口。它扩展了 BeanFactory 接口的功能,如:

    • 国际化
    • 通配符方式获取一组 Resource 资源
    • 整合 Environment 环境(能通过它获取各种来源的配置信息)
    • 事件发布与监听,实现组件之间的解耦

BeanFactory与Application的区别

  1. 到底什么是 BeanFactory
    • 它是 ApplicationContext 的父接口
    • 它才是 Spring 的核心容器, 主要的 ApplicationContext 实现都【组合】了它的功能,【组合】是指 ApplicationContext 的一个重要成员变量就是 BeanFactory
  1. BeanFactory 能干点啥
    • 表面上只有 getBean
    • 实际上控制反转、基本的依赖注入、直至 Bean 的生命周期的各种功能,都由它的实现类提供
    • 通过反射查看了它的成员变量 singletonObjects,内部包含了所有的单例 bean
  1. ApplicationContext 比 BeanFactory 多点啥
    • ApplicationContext 组合并扩展了 BeanFactory 的功能
    • 国际化、通配符方式获取一组 Resource 资源、整合 Environment 环境、事件发布与监听

容器实现

具体实现类:

  • DefaultListableBeanFactory,是 BeanFactory 最重要的实现,像控制反转依赖注入功能,都是它来实现
  • ClassPathXmlApplicationContext,从类路径查找 XML 配置文件,创建容器(旧)
  • FileSystemXmlApplicationContext,从磁盘路径查找 XML 配置文件,创建容器(旧)
  • XmlWebApplicationContext,传统 SSM 整合时,基于 XML 配置文件的容器(旧)
  • AnnotationConfigWebApplicationContext,传统 SSM 整合时,基于 java 配置类的容器(旧)
  • AnnotationConfigApplicationContext,Spring boot 中非 web 环境容器(新)
  • AnnotationConfigServletWebServerApplicationContext,Spring boot 中 servlet web 环境容器(新)
  • AnnotationConfigReactiveWebServerApplicationContext,Spring boot 中 reactive web 环境容器*(新)

带有 ApplicationContext 的类都是 ApplicationContext 接口的实现,但它们是组合了 DefaultListableBeanFactory 的功能,并非继承而来。

DefaultListableBeanFactory

  • beanFactory 可以通过 registerBeanDefinition 注册一个 bean definition 对象

    • 我们平时使用的配置类、xml、组件扫描等方式都是生成 bean definition 对象注册到 beanFactory 当中
    • bean definition 描述了这个 bean 的创建蓝图:scope 是什么、用构造还是工厂创建、初始化销毁方法是什么,等等
  • beanFactory 需要手动调用 beanFactory 后处理器对它做增强

    • 例如通过解析 @Bean、@ComponentScan 等注解,来补充一些 bean definition
  • beanFactory 需要手动添加 bean 后处理器,以便对后续 bean 的创建过程提供增强

    • 例如 @Autowired,@Resource 等注解的解析都是 bean 后处理器完成的
    • bean 后处理的添加顺序会对解析结果有影响
  • beanFactory 需要手动调用方法来初始化单例

  • beanFactory 需要额外设置才能解析 ${} 与 #{}

ApplicationContext实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 // ⬇️较为经典的容器, 基于 classpath 下 xml 格式的配置文件来创建
private static void testClassPathXmlApplicationContext() {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("a02.xml");

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

System.out.println(context.getBean(Bean2.class).getBean1());
}

// ⬇️基于磁盘路径下 xml 格式的配置文件来创建
private static void testFileSystemXmlApplicationContext() {
FileSystemXmlApplicationContext context =
new FileSystemXmlApplicationContext(
"src\\main\\resources\\a02.xml");
for (String name : context.getBeanDefinitionNames()) {
System.out.println(name);
}

System.out.println(context.getBean(Bean2.class).getBean1());
}

// ⬇️较为经典的容器, 基于 java 配置类来创建
private static void testAnnotationConfigApplicationContext() {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(Config.class);

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

System.out.println(context.getBean(Bean2.class).getBean1());
}

// ⬇️较为经典的容器, 基于 java 配置类来创建, 用于 web 环境
private static void testAnnotationConfigServletWebServerApplicationContext() {
AnnotationConfigServletWebServerApplicationContext context =
new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
for (String name : context.getBeanDefinitionNames()) {
System.out.println(name);
}
}

@Configuration
static class WebConfig {
@Bean
public ServletWebServerFactory servletWebServerFactory(){
return new TomcatServletWebServerFactory();
}
@Bean
public DispatcherServlet dispatcherServlet() {
return new DispatcherServlet();
}
@Bean
public DispatcherServletRegistrationBean registrationBean(DispatcherServlet dispatcherServlet) {
return new DispatcherServletRegistrationBean(dispatcherServlet, "/");
}
@Bean("/hello")
public Controller controller1() {
return (request, response) -> {
response.getWriter().print("hello");
return null;
};
}
}

@Configuration
static class Config {
@Bean
public Bean1 bean1() {
return new Bean1();
}

@Bean
public Bean2 bean2(Bean1 bean1) {
Bean2 bean2 = new Bean2();
bean2.setBean1(bean1);
return bean2;
}
}

static class Bean1 {
}

static class Bean2 {

private Bean1 bean1;

public void setBean1(Bean1 bean1) {
this.bean1 = bean1;
}

public Bean1 getBean1() {
return bean1;
}
}
}

Bean 的生命周期

一个受 Spring 管理的 bean,生命周期主要阶段有

  1. 创建:根据 bean 的构造方法或者工厂方法来创建 bean 实例对象
  2. 依赖注入:根据 @Autowired,@Value 或其它一些手段,为 bean 的成员变量填充值、建立关系
  3. 初始化:回调各种 Aware 接口,调用对象的各种初始化方法
  4. 销毁:在容器关闭时,会销毁所有单例对象(即调用它们的销毁方法)
    • prototype 对象也能够销毁,不过需要容器这边主动调用

生命周期中还有一类 bean 后置处理器,会在上述生命周期的前后,提供一些扩展逻辑。

bean后置处理器

注意:以下都是方法

创建前后的增强

  • postProcessBeforeInstantiation (Instantiation:实例化)

    • 这里返回的对象若不为 null 会替换掉原本的 bean,并且仅会走 postProcessAfterInitialization 流程
  • postProcessAfterInstantiation

    • 这里如果返回 false 会跳过依赖注入阶段

依赖注入前的增强

  • postProcessProperties

    • 如 @Autowired、@Value、@Resource

初始化前后的增强

  • postProcessBeforeInitialization (Initialization:初始化)

    • 这里返回的对象会替换掉原本的 bean
    • 如 @PostConstruct、@ConfigurationProperties
  • postProcessAfterInitialization

    • 这里返回的对象会替换掉原本的 bean
    • 如代理增强

销毁之前的增强

  • postProcessBeforeDestruction

    • 如 @PreDestroy

模板方法模式

Bean的生命周期中通过bean的后置处理器作扩展,使用的是模板方法模式

代码演示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class TestMethodTemplate {

public static void main(String[] args) {
MyBeanFactory beanFactory = new MyBeanFactory();
//定义不同的子类
beanFactory.addBeanPostProcessor(bean -> System.out.println("解析 @Autowired"));
beanFactory.addBeanPostProcessor(bean -> System.out.println("解析 @Resource"));
beanFactory.getBean();
}

// 模板方法 Template Method Pattern
static class MyBeanFactory {
public Object getBean() {
Object bean = new Object();
System.out.println("构造 " + bean);
System.out.println("依赖注入 " + bean); // @Autowired, @Resource
for (BeanPostProcessor processor : processors) {
processor.inject(bean);
}
System.out.println("初始化 " + bean);
return bean;
}

private List<BeanPostProcessor> processors = new ArrayList<>();

public void addBeanPostProcessor(BeanPostProcessor processor) {
processors.add(processor);
}
}

static interface BeanPostProcessor {
public void inject(Object bean); // 对依赖注入阶段的扩展
}
}

bean 后处理器排序

对于各种后处理器的执行顺序,有这样的规则:

  1. 实现了 PriorityOrdered 接口的优先级最高
  2. 实现了 Ordered 接口与加了 @Order 注解的平级, 按数字升序
  3. 其它的排在最后

代码演示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/*
bean 后处理的的排序
*/
public class TestProcessOrder {

public static void main(String[] args) {
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

List<BeanPostProcessor> list = new ArrayList<>(List.of(new P1(), new P2(), new P3(), new P4(), new P5()));
list.sort(beanFactory.getDependencyComparator());

list.forEach(processor->{
processor.postProcessBeforeInitialization(new Object(), "");
});

/*
学到了什么
1. 实现了 PriorityOrdered 接口的优先级最高
2. 实现了 Ordered 接口与加了 @Order 注解的平级, 按数字升序
3. 其它的排在最后
*/
}

@Order(1)
static class P1 implements BeanPostProcessor {
private static final Logger log = LoggerFactory.getLogger(P1.class);

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.debug("postProcessBeforeInitialization @Order(1)");
return bean;
}
}

@Order(2)
static class P2 implements BeanPostProcessor {
private static final Logger log = LoggerFactory.getLogger(P2.class);

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.debug("postProcessBeforeInitialization @Order(2)");
return bean;
}

}

static class P3 implements BeanPostProcessor, PriorityOrdered {
private static final Logger log = LoggerFactory.getLogger(P3.class);

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.debug("postProcessBeforeInitialization PriorityOrdered");
return bean;
}

@Override
public int getOrder() {
return 100;
}
}

static class P4 implements BeanPostProcessor, Ordered {
private static final Logger log = LoggerFactory.getLogger(P4.class);

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.debug("postProcessBeforeInitialization Ordered");
return bean;
}

@Override
public int getOrder() {
return 0;
}
}

static class P5 implements BeanPostProcessor {
private static final Logger log = LoggerFactory.getLogger(P5.class);

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.debug("postProcessBeforeInitialization");
return bean;
}
}
}

控制台输出样例:

1
2
3
4
5
[DEBUG] 22:13:30.104 [main] com.itheima.a03.TestProcessOrder$P3 - postProcessBeforeInitialization PriorityOrdered 
[DEBUG] 22:13:30.108 [main] com.itheima.a03.TestProcessOrder$P4 - postProcessBeforeInitialization Ordered
[DEBUG] 22:13:30.108 [main] com.itheima.a03.TestProcessOrder$P1 - postProcessBeforeInitialization @Order(1)
[DEBUG] 22:13:30.108 [main] com.itheima.a03.TestProcessOrder$P2 - postProcessBeforeInitialization @Order(2)
[DEBUG] 22:13:30.108 [main] com.itheima.a03.TestProcessOrder$P5 - postProcessBeforeInitialization

Bean 后处理器

后处理器作用

  1. @Autowired 等注解的解析属于 bean 生命周期阶段(依赖注入, 初始化)的扩展功能,这些扩展功能由 bean 后处理器来完成
  2. 每个后处理器各自增强什么功能
    • AutowiredAnnotationBeanPostProcessor 解析 @Autowired 与 @Value
    • CommonAnnotationBeanPostProcessor 解析 @Resource、@PostConstruct、@PreDestroy
    • ConfigurationPropertiesBindingPostProcessor 解析 @ConfigurationProperties
  1. 另外 ContextAnnotationAutowireCandidateResolver 负责获取 @Value 的值,解析 @Qualifier、泛型、@Lazy 等

@Autowired bean 后处理器运行分析

  1. AutowiredAnnotationBeanPostProcessor.findAutowiringMetadata 用来获取某个 bean 上加了 @Value @Autowired 的成员变量,方法参数的信息,表示为 InjectionMetadata
  2. InjectionMetadata 可以完成依赖注入
  3. InjectionMetadata 内部根据成员变量,方法参数封装为 DependencyDescriptor 类型
  4. 有了 DependencyDescriptor,就可以利用 beanFactory.doResolveDependency 方法进行基于类型的查找

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接口。
1
2
3
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.example.mapper"/>
</bean>
  1. MapperScannerConfigurer(这是一个BeanFactory的后置处理器)会扫描指定包下的Mapper接口,然后将这些接口交给SqlSessionFactoryBean(这个类实现了FactoryBean接口,getObject方法中返回了SqlSessionFactoryBean)管理,通过动态代理生成实现类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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接口的实例。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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接口的实例,然后调用接口中的方法,实现对数据的访问。
1
2
3
4
5
6
7
8
9
10
11
@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 框架内部的类常用内置注入和初始化

代码演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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 等注解失效

对应代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@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 期望是多例

1
2
3
4
5
6
7
8
9
@Component
@Scope("prototype")
public class F {
private static final Logger log = LoggerFactory.getLogger(F.class);

public F() {
log.info("F()");
}
}

测试

1
2
3
4
5
E e = context.getBean(E.class);
F f1 = e.getF();
F f2 = e.getF();
System.out.println(f1);
System.out.println(f2);

输出

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

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

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

解决

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

1
2
3
4
5
6
7
8
9
10
11
12
@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 方法的目的类似

输出

1
2
3
4
5
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 都会创建一个新的实例,而不是复用之前创建的实例。

1
2
3
4
5
6
7
8
9
@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() 方法都会创建一个新的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@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();
}
}

Spring容器与bean
http://example.com/2023/03/26/Spring容器与bean/
作者
程序员小魏
发布于
2023年3月26日
许可协议