Java知识点整理 16 — Spring Bean

在之前的文章 Java知识点整理 8 — Spring 简介 中介绍了 Spring 的两大核心概念 IoC 和 AOP，但对 Spring Bean 的介绍不全面，本文将补充 Spring 中 Bean 的概念。

一. 什么是 Spring Bean 

在 Spring 官方文档中，对 bean 的定义为：构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。bean 是由 Spring IoC 容器实例化、组装和管理的对象。

开发者需要告诉 IoC 容器协助管理哪些对象，这个是通过配置元数据来定义的。配置元数据可以是 XML文件（较老）、注解或者 Java 配置类。

二. 通过例子来理解

首先有一个 Student 类，里面有两个成员变量 id 和 name，并提供 set、get方法。

public class Student {
    private Integer id;
    private String name;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

另一个类是 StudentManager，有一个 Student 的对象，提供了 setStudent 方法初始化 Student 对象，并且它的 show 方法能够打印这个 student 的 id 和 name。

public class StudentManager {
    private Student student;
 
    public void setStudent(Student student) {
        this.student = student;
    }
 
    public void show() {
        System.out.println(student.getId());
        System.out.println(student.getName());
    }
}

分析以上两段代码发现，两个类之间高度耦合，后者依赖于前者。假如没有及时对 StudentManager 的 student 绑定对象，却调用了 show 方法，那么程序就会报空指针异常的错误。因此 Spring 提供了 IoC（控制反转）和 DI（依赖注入）进行解耦。

在 Spring 中不需要自己创建对象，只需要告诉 Spring，哪些类需要创建，然后在启动项目时 Spring 就会自动帮助创建对应的对象，并且只存在一个类的实例。这个类的实例也就是 Bean，而这种模式通常称为单例模式，即一个类只有一个实例。

继续思考，开发者该如何告诉 Spring 哪些类需要创建对象呢？

最简单最常用的方式就是 Java 注解配置。也就是将一个类声明为 Bean 所需要的注解。

其实以上四种声明方式效果完全一致，使用不同的关键词是让开发者快速了解该类属于哪一层。

例如，在刚才的 Student 类前加上 @Component 注解，就告诉 Spring：你要在项目创建运行时帮我创建 Student 类的 Bean（对象）。

@Component
public class Student {
    private Integer id;
    private String name;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

此时"依赖"添加完毕，但还没结束。虽然让 Spring 帮助我们创建了对象，但 StudentManager 怎么知道这个被创建的对象在哪呢？所以接下来要告诉 StudentManager 刚才 Spring 帮助创建的 Bean（对象）在哪，也就是注入 Bean。

例如，在 StudentManager 类中声明成员变量 Student 的前面加上 @Autowired，Spring 会自动注入一个 Bean。

@Component
public class StudentManager {
    @Autowired
    private Student student;
 
    public void show() {
        System.out.println(student.getId());
        System.out.println(student.getName());
    }
}

三. @Bean 注解的使用

• @Bean 注解作用在方法上，产生一个 Bean 对象，然后将其交给 Spring 管理。Spring 会将这个 Bean 对象放在自己的 IoC 容器中。
• @Bean 方法名与返回类名一致，首字母小写。
• @Component、@Repository、@Controller、@Service 这些注解只局限于自己编写的类，@Bean 注解能把第三方库中的类实例加入 IoC 容器并交给 Spring 管理。
• @Bean 一般和 @Component 或 @Configuration 一起使用。

四. @Component 和 @Bean 的区别

• @Component 注解作用于类，@Bean 作用于方法。
• @Component 通常是通过类路径扫描来自动侦测以及自动装配到 Spring 容器中，可以使用 @ComponentScan 注解定义要扫描的路径，从中找出标识了需要装配的类，并自动装配到 Spring 的 bean 容器中。@Bean 注解通常是在标有该注解的方法中定义产生这个 bean，它告诉了 Spring 这是某个类的实例，在需要时给我。
• @Bean 注解比 @Component 注解的自定义性更强，而且很多地方只能通过@Bean 注解来注册 bean，比如第三方库。

@Bean 注解的使用：

@Configuration //标记该类为配置类，提供配置信息给 Spring 容器。
public class AppConfig {
    @Bean
    public TransferService transferService() {
        return new TransferServiceImpl();
    }
}

五. @Autowired 和 @Resource 的区别

@Autowired 属于 Spring 内置的注解，默认注入方式为 byType，优先根据接口类型去匹配并注入 Bean（接口的实现类）。

但如果一个接口存在多个实现类，byType 这种方式可能无法正确注入对象，因为 Spring 找到了多个满足条件的选择，默认情况下不知道选哪一个。这种情况下，注入方式会变为 byName，即根据名称匹配，这个名称通常是类名，如下面的 SmsService。

// smsService 就是上面所说的名称
@Autowired
private SmsService smsService;

如果 SmsService 接口有两个实现类：SmsServiceImpl1 和 SmsServiceImpl2，且它们都被 Spring 容器管理。

// 报错，byName 和 byType 都无法匹配到 bean
@Autowired
private SmsService smsService;
// 正确注入 SmsServiceImpl1 对象对应的 bean
@Autowired
private SmsService smsServiceImpl1;
// 正确注入  SmsServiceImpl1 对象对应的 bean
// smsServiceImpl1 就是我们上面所说的名称
@Autowired
@Qualifier(value = "smsServiceImpl1")
private SmsService smsService;

通过 @Qualifier 注解能够显式指定名称，而不是依赖变量名称。

@Resource 属于JDK提供的注解，默认注入方式为 byName。如果无法通过名称匹配到对应的 Bean，注入方式会变为 byType。

@Resource 有两个比较重要且日常开发常用的属性：name（名称）和 type（类型）。

// 报错，byName 和 byType 都无法匹配到 bean
@Resource
private SmsService smsService;
// 正确注入 SmsServiceImpl1 对象对应的 bean
@Resource
private SmsService smsServiceImpl1;
// 正确注入 SmsServiceImpl1 对象对应的 bean（比较推荐这种方式）
@Resource(name = "smsServiceImpl1")
private SmsService smsService;

总结一下：

• @Autowired 是 Spring 提供的注解，@Resource 是 JDK 提供的注解。
• @Autowired 默认的注入方式为 byType，@Resource 默认的注入方式为 byName。
• 当一个接口存在多个实现类时，两个注解都需要通过名称才能正确匹配到对应的 Bean。@Autowired 可以通过 @Qualifier 注解来显示指定名称，@Resource 可以通过 name 属性来显式指定名称。
• @Autowired 支持在构造函数、方法、字段和参数上使用。@Resource 主要用于字段和方法上的注入，不支持在构造函数或参数上使用。

六. Bean 的作用域

通常有以下几种：

如何配置：

// 注解方式
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public Person personPrototype() {
    return new Person();
}

七. Bean 的生命周期

1. 创建 Bean 的实例：Bean 容器首先会找到配置文件中的 Bean 定义，然后使用 Java 反射 API 来创建 Bean 的实例。

2. Bean 属性赋值/填充：为 Bean 设置相关属性和依赖，例如 @Autowired 等注解注入对象、@Value 注入值、@Resource 注入各种资源等。

3. Bean 初始化：

• 如果 Bean 实现了 BeanNameAware 接口，调用 setBeanName() 方法，传入 Bean 的名字。
• 如果 Bean 实现了 BeanClassLoaderAware 接口，调用 setBeanClassLoader() 方法，传入 ClassLoader 对象的实例。
• 与上面的类似，如果实现了其他 *.Aware 接口，就调用相应的方法。
• 如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行postProcessBeforeInitialization() 方法
• 如果 Bean 实现了 InitializingBean 接口，执afterPropertiesSet() 方法。
• 如果 Bean 在配置文件中的定义包含 init-method 属性，执行指定的方法。
• 如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行postProcessAfterInitialization() 方法。

4. 销毁 Bean：销毁并不是说立刻把 Bean 销毁掉，而是把 Bean 的销毁方法先记录下来，将来需要销毁 Bean 或者销毁容器的时候，就调用这些方法去释放 Bean 所持有的资源。

• 如果 Bean 实现了 DisposableBean 接口，执行 destroy() 方法。
• 如果 Bean 在配置文件中的定义包含 destroy-method 属性，执行指定的 Bean 销毁方法。或者，也可以直接通过 @PreDestroy 注解标记 Bean 销毁之前执行的方法。

AbstractAutowireCapableBeanFactory 的 doCreateBean() 方法中能看到一次执行了这四个阶段：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    throws BeanCreationException {
 
    // 1. 创建 Bean 的实例
    BeanWrapper instanceWrapper = null;
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
 
    Object exposedObject = bean;
    try {
        // 2. Bean 属性赋值/填充
        populateBean(beanName, mbd, instanceWrapper);
        // 3. Bean 初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
 
    // 4. 销毁 Bean-注册回调接口
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
 
    return exposedObject;
}

Aware 接口能让 Bean 拿到 Spring 容器资源。

Spring 中提供的 Aware 接口主要有：

• BeanNameAware：注入当前 Bean 对应 beanName；
• BeanClassLoaderAware：注入加载当前 bean 的 ClassLoader；
• BeanFactoryAware：注入当前 BeanFactory 容器的引用。

BeanPostProcessor 接口时 Spring 为修改 Bean 提供的强大扩展点。

public interface BeanPostProcessor {
 
	// 初始化前置处理
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
 
	// 初始化后置处理
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
 
}

• postProcessBeforeInitialization：Bean 实例化、属性注入完成后，InitializingBean#afterPropertiesSet 方法以及自定义的 init-method 方法之前执行。
• postProcessAfterInitialization：与上面类似，只是在之后执行。

 八. Bean 是线程安全的吗

Spring 框架中的 Bean 是否线程安全取决于其作用域和状态。

通常情况下，Bean 作用域都是默认使用 singleton，常用的还有 prototype。

prototype 作用域下，每次获取都会创建一个新的 bean 实例，不存在资源竞争问题，所以不存在线程安全问题。singleton 作用域下，IoC容器中有唯一的 bean 实例，可能会存在资源竞争问题，这取决于 bean 是否有状态，即是否包含可变的成员变量的对象。如果是有状态的 bean，则存在线程安全问题。但大部分 bean 实际上都是无状态的，是线程安全的。

对于有状态单例 bean 的线程安全问题，可以在类中定义一个 ThreadLocal 成员变量，将需要的可变成员变量保存在 ThreadLocal中。