一、IoC 容器
IoC 容器是 Spring 的核心,Spring 通过 IoC 容器来管理对象的实例化和初始化(这些对象就是 Spring Bean),以及对象从创建到销毁的整个生命周期。也就是管理对象和依赖,以及依赖的注入等等。
Spring 提供 2 种不同类型的 IoC 容器:BeanFactory 和 ApplicationContext 容器。
1.1 BeanFactory 容器
BeanFactory 是一个管理 Bean 的工厂,它主要负责初始化各种 Bean, 并调用它们的生命周期方法。BeanFactory 是最简单的 Bean 容器,它由 org.springframework.beans.factory.BeanFactory 接口定义实现。提供了容器最基本的功能。
目前 BeanFactory 没多少人用,主要是为了能够兼容 Spring 集成的第三方框架,所以目前仍然保留了该接口。下面是官网的解释
The BeanFactory
and related interfaces, such as BeanFactoryAware
, InitializingBean
, DisposableBean
, are still present in Spring for the purposes of backward compatibility with the large number of third-party frameworks that integrate with Spring.
Beanfactory 是 org.springframework.beans 的顶级接口。
1.2 ApplicationContext 容器
ApplicationContext 容器几乎涵盖所有 BeanFactory 容器的功能,它继承了 BeanFactory 接口,由org.springframework.context.ApplicationContext 接口定义实现。在 BeanFactory 的基础上增加了AOP、事务支持等等功能。现在Spring 实际开发中基本上使用的是 ApplicationContext 容器。
ApplicationContext 是 org.springframework.context 的顶级接口。
ApplicationContext 有两个常用的实现类,分别是 ClassPathXmlApplicationContext 和 FileSystemXmlApplicationContext 。
1.2.1 ClassPathXmlApplicationContext 类
看名字就知道它是从类路径 ClassPath 中寻找 XML 配置文件,来完成 ApplicationContext 实例化工作:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("configlocation");
//configlocation 是指定 Spring 配置文件(XML)的名称和位置,比如 Beans.xml
1.2.2 FileSystemXmlApplicationContext
该类是从文件系统中寻找 XML 配置文件:
ApplicationContext applicationContext = new FileSystemXmlApplicationContext("configlocation");
//configlocation 是从非类路径外中获取 XML 的名称和位置,比如 ”F:/workCode/Beans.xml“
它们都是通过 XML 配置文件来加载 Bean 的。
二、 Spring Bean 的定义
看官网定义:
In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. Otherwise, a bean is simply one of many objects in your application. Beans, and the dependencies among them, are reflected in the configuration metadata used by a container.
Bean 是由 Spring IoC 容器管理的对象,容器就能通过反射的形式将容器中准备好的对象注入(这里使用的是反射给属性赋值)到需求的组件中去,简单来说,Spring IoC 容器可以看作是一个工厂,Bean 相当于工厂的产品。 Spring 配置文件则告诉容器需要哪些 Bean,以及需要哪种方式来装配 Bean。
Bean 其实就是一个 Java 对象,它是根据 bean 规范编写出来的类,并且由容器生成的对象就是一个 bean。
Bean 规范:
- 所有属性是 private
- 提供默认构造方法
- 提供 getter 和 setter
- 实现 serializable 接口
它和 POJO 其实是一样的,只不过是遵循 Bean 规范的 POJO 。
Spring 配置文件
spring 配置文件主要支持两种格式:XML 和 Properties 格式
- Properties 配置文件主要以 key-value 键值对的形式存在,不能进行其他操作,使用于简单的属性配置
- XML 配置文件是树形结构,文件结构清晰,但是内容比较繁琐,使用于大型复杂项目
一般来说,Spring 的配置文件使用 XML 格式。 XML 配置文件的根元素是,该元素下包含多个子元素。每个都定义了一个 bean ,并描述了该 Bean 如何被装配到 Spring 容器中。
元素的常用属性:
属性名称 | 描述 |
---|---|
id | Bean 的唯一标识符,Spring 容器对 Bean 的配置和管理都通过该属性完成。id 的值必须以字母开始,可以使用字母、数字、下划线等符号。 |
name | name 属性中可以为 Bean 指定多个名称,每个名称之间用逗号或分号隔开。Spring 容器可以通过 name 属性配置和管理容器中的 Bean。 |
class | 该属性指定了 Bean 的具体实现类,它必须是一个完整的类名,即类的全限定名。 |
scope | 用于设定 Bean 实例的作用域,属性值可以为 singleton(单例)、prototype(原型)、request、session 和 global Session。其默认值是 singleton |
constructor-arg | 元素的子元素,可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号(从 0 开始),type 属性指定构造参数的类型 |
property | 元素的子元素,用于调用 Bean 实例中的 setter 方法来属性赋值,从而完成依赖注入。该元素的 name 属性用于指定 Bean 实例中相应的属性名 |
ref | 和 等元素的子元索,该元素中的 bean 属性用于指定对某个 Bean 实例的引用 |
value | 和 等元素的子元素,用于直接指定一个常量值 |
list | 用于封装 List 或数组类型的依赖注入 |
set | 用于封装 Set 类型的依赖注入 |
map | 用于封装 Map 类型的依赖注入 |
entry | |
init-method | 容器加载 Bean 时调用该方法,类似于 Servlet 中的 init() 方法 |
destroy-method | 容器删除 Bean 时调用该方法,类似于 Servlet 中的 destroy() 方法。该方法只在 scope=singleton 时有效 |
lazy-init | 懒加载,值为 true,容器在首次请求时才会创建 Bean 实例;值为 false,容器在启动时创建 Bean 实例。该方法只在 scope=singleton 时有效 |
三、 Spring Bean 的作用域
Spring 容器在初始化一个 Bean 实例时,同时会指定该实例的作用域。Spring 5 支持 6 种作用域。
3.1 singleton
默认的作用域,单例模式。表示在 Spring 容器中只有一个 Bean 实例,Bean 以单例的方式存在。在容器启动前就创建好了对象,任何时间获取都是之前创建好的那个对象。配置方式可以缺省,因为是默认值。<bean class="..."></bean>
3.2 prototype
原型作用域,多实例模式。每次调用 Bean 时都会创建一个新实例。Bean 以多实例的方式存在。容器启动默认不会创建多实例 bean,每次获取都会创建一个新的实例 bean 。配置方式为 <bean class="..." scope="prototype"></bean>
3.3 request
在 web 环境下,每次 HTTP 请求都会创建一个 Bean 实例,该作用域只在当前 HTTP Request 内有效。 配置方式为 <bean class="..." scope="request"></bean>
3.4 session
在 web 环境下,每次 HTTP 会话共享一个 Bean 实例,不同的 Session 使用不同的 Bean 实例。该作用域只在当前 HTTP Session 内有效。配置方式为 <bean class="..." scope="session"></bean>
3.5 application
在web 环境下,同一个 web application 共享一个 Bean 实例,该作用域在当前 ServletContext 内有效。
3.6 websocket
在web 环境下,同一个 websocket 共享一个 Bean 实例,该作用域在整个 websocket 中有效。
四、Spring Bean 的注册方式
Bean 的初始化主要分为两个过程:Bean 的注册和 Bean 的实例化。Bean 的注册主要是指 Spring 通过读取配置文件获取各个 bean 的声明信息,并且对这些信息进行注册的过程。
4.1 XML 配置文件注册方式
在 XML 中配置好后进行注册
<bean id="person" class="org.springframework.beans.Person">
<property name="id" value="1"/>
<property name="name" value="Java"/>
</bean>
4.2 Java 注解注册方式
可以使用 @Component 或 @Configuration + @Bean 来注册 Bean
@Component
public class Person {
private Integer id;
private String name
// 忽略其他方法
}
@Configuration //可以理解为 XML 配置文件中的 <beans> 标签
public class Person {
@Bean //可以理解为 XML 配置文件中的 <bean> 标签
public Person person(){
return new Person();
}
// 忽略其他方法
}
4.3 Java API 注册方式
使用 BeanDefinitionRegistry.registerBeanDefinition() 方法来注册 Bean, 代码如下:
public class CustomBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
RootBeanDefinition personBean = new RootBeanDefinition(Person.class);
// 新增 Bean
registry.registerBeanDefinition("person", personBean);
}
}
五、Spring Bean 的生命周期
Spring 中的 Bean 的生命周期比较复杂,可以表示为: Bean 的定义 -> Bean 的初始化 -> Bean 的使用 -> Bean 的销毁
Spring 是根据 Bean 的作用域来管理,对于单实例 singleton 作用域的 Bean, Spring 能够精确地知道 这个 Bean 的完整生命周期;而对于 prototype 作用域的 Bean, Spring 只负责创建, 当容器创建了 Bean 的实例后,Bean 的实例就交给客户端管理,Spring 容器将不再跟踪其生命周期。
首先,从上面几节中看到,关于 Bean 的定义和初始化中的注册都在配置文件中或者其他方式提前写好。下面我们直接从 Bean 初始化中的实例化开始看,一般会有以下几个过程:
5.1 实例化 Bean
Spring 启动, 查找并加载需要被 Spring 管理的 Bean , 并实例化 Bean ,实例化就是通过容器生成一个 Bean。实例化 Bean 方式主要有三种:类的无参构造方法、静态工厂、实例工厂。
5.1.1 无参构造方法创建
在配置文件 XML 中配置 bean, 默认使用了无参构造器创建 bean
<bean id="bean" class="com.spring.demo.Bean"></bean>
然后再通过 getBean() 方法来获取实例化的 bean
ApplicationContext context = new ClasspathXmlApplicationContext("Bean.xml");
Bean b = (Bean)context.getBean("Bean.xml");
5.1.2 静态工厂方法创建
同样也是需要在 XML 中配置 bean :
<bean id="bean" class="com.spring.demo.BeanFactory" factory-method="getBean"></bean>
id 和 class 都定位到某个工厂类,factory-method 表示调用到该类 BeanFactory 下的方法来创建对象,而且这个 getBean 方法必须是静态方法。
同样是用 getBean() 方法获取实例化的 bean ,就不赘余了。
5.1.3 实例工厂方法创建
同样的,配置 XML 文件
<bean id="beanfactory" class="com.spring.demo.BeanFactory"></bean>
<bean id="bean" factory-bean="beanfactory" factory-method="getbean"></bean>
实例工厂和静态工厂的区别在于,该实例化方式工厂方法不需要是静态的,需要先创建对象(在工厂类中新建一个对象),然后再通过对象调用其方法创建 bean。
5.2 设置属性值(依赖注入)
这个阶段需要利用依赖注入完成 Bean 中的所有属性值的配置注入。容器的注入方法主要有构造方法和 Setter 方法注入。
5.2.1 构造方法注入
注入方式是使用 标签来实现构造函数的注入,在该标签中,包含这样几种属性:
- value: 用于注入基本数据类型以及字符串类型的值
- ref: 注入已经定义好的 Bean
- type: 用来指定对应的构造函数
- index: 若构造函数有多个参数的时候,可以使用index 属性指定参数的位置,给参数的位置进行排序
<bean id="" class="">
<constructor-arg index="0" value=""></constructor-arg>
<constructor-arg index="1" ref=""></constructor-arg>
</bean>
5.2.2 Setter 方法注入
Setter 方法注入的方式是目前 Spring 主流的注入方式,它可以利用 Java Bean 规范所定义的 Setter/Getter 方法来完成注入,可读性和灵活性都很高,它不需要使用声明式构造方法,而是使用 Setter 注入直接设置相关的值。
<bean id="person" class="org.springframework.beans.Person">
<property name="id" value="1"/>
<property name="name" value="Java"/>
</bean>
在 Spring 实例化 Bean 的过程中,首先会调用默认的构造方法实例化 Bean 的对象,然后通过 Java 的反射机制调用 set 方法进行属性的注入。因此,setter 注入要求 Bean 的对应类必须满足一下要求:
- 必须提供一个默认的无参构造方法
- 必须为需要注入的属性提供对应的 setter 方法
5.3 调用 Aware 的相关方法
5.3.1 调用 BeanNameAware 的 setBeanName() 方法
如果 Bean 实现了 BeanNameAware 接口,则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。
5.3.2 调用 BeanFactoryAware 的 setBeanFactory() 方法
如果 Bean 实现了 BeanFactoryAware 接口,则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。
5.3.3 调用 ApplicationContextAware 的 setApplicationContext()方法
如果 Bean 实现了 ApplicationContextAware 接口,则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。
5.4 调用 BeanPostProcessor 的预初始化方法
如果 Bean 实现了 BeanPostProcessor 接口,则 Spring 调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作,此处非常重要,Spring 的 AOP 就是利用它实现的。
5.5 调用InitializingBean 的 afterPropertiesSet() 方法和定制的初始化方法
InitializingBean 是一个接口,它有一个 afterPropertiesSet() 方法,在 Bean 初始化时会判断当前 Bean 是否实现了 InitializingBean,如果实现了则调用 afterPropertiesSet() 方法,进行初始化工作;然后再检查是否也指定了 init-method,如果指定了则通过反射机制调用指定的 init-method 方法,它的实现源码如下:
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
// 判断当前 Bean 是否实现了 InitializingBean,如果是的话需要调用 afterPropertiesSet()
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) { // 安全模式
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet(); // 属性初始化
return null;
}, getAccessControlContext());
} catch (PrivilegedActionException pae) {
throw pae.getException();
}
} else {
((InitializingBean) bean).afterPropertiesSet(); // 属性初始化
}
}
// 判断是否指定了 init-method()
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
// 利用反射机制执行指定方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
5.6 调用 BeanPostProcessor 的后初始化方法
如果 BeanPostProcessor 和 Bean 关联,则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时,Bean 已经可以被应用系统使用了。
5.7 Bean 的使用
如果在 中指定了该 Bean 的作用域为 singleton,则将该 Bean 放入 Spring IoC 的缓存池中,触发 Spring 对该 Bean 的生命周期管理;如果在 中指定了该 Bean 的作用域为 prototype,则将该 Bean 交给调用者,调用者管理该 Bean 的生命周期,Spring 不再管理该 Bean。
5.8 Bean 的销毁
在 Spring 容器关闭时会执行销毁方法,但是 Spring 容器不会自动去调用销毁方法,而是需要我们主动的调用。
如果是 BeanFactory 容器,那么我们需要主动调用 destroySingletons() 方法,通知 BeanFactory 容器去执行相应的销毁方法;如果是 ApplicationContext 容器,那么我们需要主动调用 registerShutdownHook() 方法,告知 ApplicationContext 容器执行相应的销毁方法。
5.9 小结
一般情况下,会在 Bean 被初始化后和被销毁前执行一些相关操作。
Spring 官方提供了 3 种方法实现初始化回调和销毁回调:
- 实现 InitializingBean 和 DisposableBean 接口;
- 在 XML 中配置 init-method 和 destory-method;
- 使用 @PostConstruct 和 @PreDestory 注解。
在一个 Bean 中有多种生命周期回调方法时,优先级为:注解 > 接口 > XML。
不建议使用接口和注解,这会让 pojo 类和 Spring 框架紧耦合。
六、Spring Bean 自动装配
Bean 的装配可以理解为依赖关系注入,Bean 的装配方式也就是 Bean 的依赖注入方式。Spring 容器支持多种装配 Bean 的方式,如基于 XML 的 Bean 装配、基于 Annotation 的 Bean 装配和自动装配等。基于 XML 的装配方式主要分为两种,在 5.2 设置属性值 中提到的过。
自动装配就是指 Spring 容器在不使用 和 标签的情况下,可以自动装配(autowire)相互协作的 Bean 之间的关联关系,将一个 Bean 注入其他 Bean 的 Property 中。使用自动装配需要配置 元素的 autowire 属性。autowire 属性有五个值,具体说明如下表所示。
名称 | 说明 |
---|---|
no | 默认值,表示不使用自动装配,Bean 依赖必须通过 ref 元素定义。 |
byName | 根据 Property 的 name 自动装配,如果一个 Bean 的 name 和另一个 Bean 中的 Property 的 name 相同,则自动装配这个 Bean 到 Property 中。 |
byType | 根据 Property 的数据类型(Type)自动装配,如果一个 Bean 的数据类型兼容另一个 Bean 中 Property 的数据类型,则自动装配。 |
constructor | 类似于 byType,根据构造方法参数的数据类型,进行 byType 模式的自动装配。 |
autodetect(3.0版本不支持) | 如果 Bean 中有默认的构造方法,则用 constructor 模式,否则用 byType 模式。 |
5.10 基于注解装配 Bean
尽管可以使用 XML 来装配 Bean , 但是如果应用中 Bean 数量过多,会导致 XML 配置文件过于臃肿,对后期维护带来一定的困难
Java 从 JDK 5.0 以后,提供了 Annotation(注解)功能,Spring 2.5 版本开始也提供了对 Annotation 技术的全面支持,我们可以使用注解来配置依赖注入。Spring 默认不使用注解装配 Bean,因此需要在配置文件中添加 < context:annotation-config >,启用注解。
Spring 中常用的注解如下。
5.10.1 @Component
可以使用此注解描述 Spring 中的 Bean,但它是一个泛化的概念,仅仅表示一个组件(Bean),并且可以作用在任何层次。使用时只需将该注解标注在相应类上即可。
5.10.2 @Repository
用于将数据访问层(DAO层)的类标识为 Spring 中的 Bean,其功能与 @Component 相同。
5.10.3 @Service
通常作用在业务层(Service 层),用于将业务层的类标识为 Spring 中的 Bean,其功能与 @Component 相同。
5.10.4 @Controller
通常作用在控制层(如 Struts2 的 Action、SpringMVC 的 Controller),用于将控制层的类标识为 Spring 中的 Bean,其功能与 @Component 相同。
5.10.5 @Autowired
可以应用到 Bean 的属性变量、属性的 setter 方法、非 setter 方法及构造函数等,配合对应的注解处理器完成 Bean 的自动配置工作。默认按照 Bean 的类型进行装配。
5.10.6 @Resource
作用与 Autowired 相同,区别在于 @Autowired 默认按照 Bean 类型装配,而 @Resource 默认按照 Bean 实例名称进行装配。
@Resource 中有两个重要属性:name 和 type。
Spring 将 name 属性解析为 Bean 的实例名称,type 属性解析为 Bean 的实例类型。如果指定 name 属性,则按实例名称进行装配;如果指定 type 属性,则按 Bean 类型进行装配。如果都不指定,则先按 Bean 实例名称装配,如果不能匹配,则再按照 Bean 类型进行装配;如果都无法匹配,则抛出 NoSuchBeanDefinitionException 异常。
5.10.7 @Qualifier
与 @Autowired 注解配合使用,会将默认的按 Bean 类型装配修改为按 Bean 的实例名称装配,Bean 的实例名称由 @Qualifier 注解的参数指定。