Spring学习第3篇：Spring容器的基本使用
大家家好，我是一名网络怪咖，北漂五年。相信大家和我一样，都有一个大厂梦，作为一名资深Java选手，深知Spring重要性，现在普遍都使用SpringBoot来开发，面试的时候SpringBoot原理也是经常会问到，SpringBoot是为了简化Spring开发，但是底层仍然是Spring。如果不了解Spring源码，那就更别提SpringBoot源码了，接下来我准备用两个月时间，从基础到源码彻彻底底的学习一遍Spring。
学习框架一定要踏踏实实一步一个脚印的学，很多人都比较喜欢急功近利，选择跳着学，包括我有时候也是，最终会发现你不但节约不了时间，反而会更耗时，而且学着学着很容易放弃。
目录
-
- 一、概念知识
- 二、入门练习
- 三、BeanFactory接口
- 四、BeanFactory 和 ApplicationContext 区别
- 五、bean 标签和管理对象细节
-
- 5.1.bean 标签
- 5.2.alias元素
- 5.3.bean 的作用范围和生命周期
- 5.4.实例化 Bean 的四种方式
- 六、import元素
一、概念知识
IOC容器也叫spring容器
IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间
依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由ioc容器进行管理，不需要我们再去手动通过new的方式去创建对象，由ioc容器直接帮我们组装好，当我们需要使用的时候直接从ioc容器中直接获取就可以了。
那么spring ioc容器是如何知道需要管理哪些对象呢？
需要我们给ioc容器提供一个配置清单，这个配置
支持xml格式和java注解的方式，在配置文件中列出需要让ioc容器管理的对象，以及可以指定让ioc容器如何构建这些对象，当spring容器启动的时候，就会去加载这个配置文件，然后将这些对象给组装好以供外部访问者使用。
Bean概念
Bean :在计算机英语中，有可重用组件的含义，由spring容器管理的对象统称为
Bean对象。Bean就是普通的java对象，和我们自己new的对象其实是一样的，只是这些对象是由spring去创建和管理的，我们需要在配置文件中告诉spring容器需要创建哪些bean对象，所以需要先在配置文件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。
Spring容器使用步骤
- 引入spring相关的maven配置
- 创建bean配置文件，比如bean xml配置文件
- 在bean xml文件中定义好需要spring容器管理的bean对象
- 创建spring容器，并给容器指定需要装载的bean配置文件，当spring容器启动之后，会加载这些配置文件，然后创建好配置文件中定义好的bean对象，将这些对象放在容器中以供使用
- 通过容器提供的方法获取容器中的对象，然后使用
二、入门练习
往后要练习的模块有很多，这里我们直接使用父子工程。
如果单纯使用spring容器需要spring-context依赖，但是spring-contex依赖于spring-beans，而spring-beans又依赖于spring-core。所以一共需要三个依赖。
（1）父工程的pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>com.gzl.cngroupId>
<artifactId>spring-demoartifactId><packaging>pompackaging>
<version>1.0-SNAPSHOTversion><modules><module>spring-ioc-xmlmodule>modules>
<properties>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<maven.compiler.compilerVersion>1.8maven.compiler.compilerVersion>
<maven.compiler.source>8maven.compiler.source>
<maven.compiler.target>8maven.compiler.target>
<spring.version>5.3.23spring.version>
properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-coreartifactId>
<version>${spring.version}version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>${spring.version}version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-beansartifactId>
<version>${spring.version}version>
dependency>
dependencies>
dependencyManagement>
<build>
<plugins>
<plugin>
<artifactId>maven-surefire-pluginartifactId>
<configuration>
<skipTests>trueskipTests>
<testFailureIgnore>truetestFailureIgnore>
configuration>
plugin>
<plugin>
<artifactId>maven-compiler-pluginartifactId>
<configuration>
<source>1.8source>
<target>1.8target>
<encoding>utf-8encoding>
configuration>
plugin>
plugins>
build>
project>
（2）子工程pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-demoartifactId>
<groupId>com.gzl.cngroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>spring-ioc-xmlartifactId>
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-coreartifactId>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-beansartifactId>
dependency>
dependencies>
project>
（3）添加TestController 和 TestService
public class TestController {
public TestController() {
System.out.println("TestController初始化了");
}
public void method1(){
System.out.println("method1");
}
public void method2(){
System.out.println("method2");
}
}
public class TestService {
public TestService() {
System.out.println("TestService初始化了");
}
public void method1() {
// 业务省略...
}
public void method2() {
// 业务省略...
}
}
（4）添加bean.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testService" class="com.gzl.cn.service.TestService"/>
<bean id="testController" class="com.gzl.cn.controller.TestController"/>
beans>
（5）添加测试类
public class Client {
public static void main(String[] args) {
// 默认就是从项目根路径寻找bean.xml, classpath:bean.xml 和 bean.xml 是一样的效果
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
TestController testController = (TestController)classPathXmlApplicationContext.getBean("testController");
TestService testService = (TestService)classPathXmlApplicationContext.getBean("testService");
System.out.println(testController);
System.out.println(testService);
testController.method1();
}
}
运行结果：
通过运行结果不难发现，spring是通过我们提供的xml知道需要创建哪些对象，并通过无参构造器进行创建。这里还有一个细节问题，就是我并没有访问getBean方法的时候，spring已经通过无参构造将对象放到了容器当中。
三、BeanFactory接口
spring内部提供了很多表示spring容器的接口和对象，我们上面入门demo使用的是xml配置，所以这里用到了classPathXmlApplicationContext，我们来看看比较常见的几个容器接口和具体的实现类。
spring容器中具有代表性的容器就是BeanFactory接口，这个是spring容器的顶层接口，提供了容器最基本的功能。
源码当中是有注释的：https://github.com/spring-projects/spring-framework/blob/main/spring-beans/src/main/java/org/springframework/beans/factory/BeanFactory.java
public interface BeanFactory {
// 按bean的id查找容器中的bean
Object getBean(String var1) throws BeansException;
// 这个是一个泛型方法，按照bean的id查找指定类型的bean，返回指定类型的bean对象
<T> T getBean(String var1, Class<T> var2) throws BeansException;
// 返回容器中指定id的bean对象，允许指定显式构造函数参数/工厂方法参数，覆盖bean定义中指定的默认参数(如果有的话)
Object getBean(String var1, Object... var2) throws BeansException;
// 根据class类型来寻找bean
<T> T getBean(Class<T> var1) throws BeansException;
// 根据class类型来寻找bean，允许指定显式构造函数参数/工厂方法参数，覆盖bean定义中指定的默认参数(如果有的话)
<T> T getBean(Class<T> var1, Object... var2) throws BeansException;
// 返回指定bean的提供程序，允许延迟按需检索实例，包括可用性和惟一性选项。这个方法比较特别，以后会专门来讲
<T> ObjectProvider<T> getBeanProvider(Class<T> var1);
<T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
// 根据名称判断bean是否存在
boolean containsBean(String var1);
// 是否为单实例Bean
boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
// 是否为原型（多实例）
boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
// 检查给定名称的调用是否会返回一个可赋值给指定目标类型的对象。
boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
// 根据bean的id查找返回的对象类型。
@Nullable
Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;
// 根据实例的名字获取实例的别名
String[] getAliases(String var1);
}
四、BeanFactory 和 ApplicationContext 区别
BeanFactory有一个子接口ApplicationContext，也被称为Spring上下文，spring Ioc容器的实现，从根源上是beanfactory，它继承了BeanFactory的基本功能， 同时也继承了容器的高级功能，如：MessageSource（国际化资源接口）、ResourceLoader（资源加载接口）、ApplicationEventPublisher（应用事件发布接口）等。轮层级来说，真正可以作为一个可以独立使用的ioc容器还是DefaultListableBeanFactory，因此可以这么说，DefaultListableBeanFactory是整个spring ioc的始祖。
ApplicationContext：是IOC容器另一个重要接口，
- BeanFactory 才是 Spring 容器中的顶层接口。ApplicationContext 是它的子接口。
- ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
- BeanFactory：什么时候使用什么时候创建对象。
ApplicationContext和BeanFactory区别我们可以通过classPathXmlApplicationContext 和XmlBeanFactory来进行比较，classPathXmlApplicationContext 属于ApplicationContext，而 XmlBeanFactory属于BeanFactory系列的，XmlBeanFactory继承自DefaultListableBeanFactory，重写了一些功能，使自己更强大。
public class Client {
public static void main(String[] args) {
XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("bean.xml"));
}
}
运行结果：并没有访问无参构造器初始化，当通过XmlBeanFactory 第一次访问getBean方法的时候才会触发初始化！
接下来再来看classPathXmlApplicationContext：
public class Client {
public static void main(String[] args) {
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
}
}
运行结果：不管使用没使用都会触发初始化！
ApplicationContext 接口的实现类
- ClassPathXmlApplicationContext：它是从类的根路径下加载xml配置文件 推荐使用这种
- FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
- AnnotationConfigApplicationContext：注意其类名包含了Annotation和config两个单词，上面我们有说过，bean的定义支持xml的方式和注解的方式，当我们使用注解的方式定义bean的时候，就需要用到这个容器来装载了，这个容器内部会解析注解来构建构建和管理需要的bean。
注解的方式相对于xml方式更方便一些，也是我们比较推荐的方式，后面我们会大量使用这种方式，具体会详解。
五、bean 标签和管理对象细节
5.1.bean 标签
作用：
- 用于配置对象让 spring 来创建的。
- 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
格式：
<bean id="bean唯一标识" name="bean名称" class="完整类型名称" factory-bean="工厂bean名称" factory-method="工厂方法" scope="作用范围"
init-method="创建对象的时候执行的方法" destroy-method="卸载对象的时候执行的方法"/>
属性：
id：给对象在容器中提供一个唯一标识。name：每个bean都有一个名称，叫做bean名称，bean名称在一个spring容器中必须唯一，否则会报错，通过bean名称可以从spring容器获取对应的bean对象。但是这个bean名称是可以存在多个的。class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。scope：指定对象的作用范围。- singleton :默认值，单例的
- prototype :多例的
- request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中
- session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中
- global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session
init-method：指定类中的初始化方法名称，也就是创建对象的时候执行。destroy-method：指定类中销毁方法名称，卸载对象的时候执行。factory-bean：工厂bean名称，使用后面会讲到factory-method：工厂方法，使用后面会讲到
bean别名
相当于人的外号一样，一个人可能有很多外号，当别人喊这个人的名称或者外号的时候，都可以找到这个人。那么bean也一样，也可以给bean起几个外号，这个外号在spring中叫做bean的别名，spring容器允许使用者通过名称或者别名获取对应的bean对象。
名称和别名可以通过bean元素中的id和name来定义，具体定义规则如下：：
- 当id存在的时候，不管name有没有，取id为bean的名称
- 当id不存在，此时需要看name，name的值可以通过,;或者空格分割，最后会按照分隔符得到一个String数组，数组的第一个元素作为bean的名称，其他的作为bean的别名
- 当id和name都存在的时候，id为bean名称，name用来定义多个别名
- 当id和name都不指定的时候，bean名称自动生成，生成的规则是
全类名#序号序号是从0开始，多个别名的话依次往下排。
一个实例 bean 可以没有别名，但是一定存在bean名称！
获取别名：String[] aliases = context.getAliases(beanName);
获取名称：String[] beanDefinitionNames = classPathXmlApplicationContext.getBeanDefinitionNames();
通过下面示例来加深一下别名和名称：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testService" class="com.gzl.cn.service.TestService"/>
<bean id="testController" name="testController1,testController2,testController3" class="com.gzl.cn.controller.TestController"/>
beans>
public class Client {
public static void main(String[] args) {
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
String[] beanDefinitionNames = classPathXmlApplicationContext.getBeanDefinitionNames();
for (String name : beanDefinitionNames) {
System.out.println("获取bean名称为:" + name + "的别名");
String[] testServices = classPathXmlApplicationContext.getAliases(name);
System.out.println(Arrays.asList(testServices));
}
}
}
5.2.alias元素
alias元素也可以用来给某个bean定义别名，语法：
<alias name="需要定义别名的bean" alias="别名" />
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testService" class="com.gzl.cn.service.TestService"/>
<alias name="testService" alias="testService1" />
<bean id="testController" name="testController1,testController2,testController3" class="com.gzl.cn.controller.TestController"/>
beans>
5.3.bean 的作用范围和生命周期
单例对象：scope=“singleton”
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象：scope=“prototype”
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。
5.4.实例化 Bean 的四种方式
第一种方式：使用默认无参构造函数
<bean id="testService" class="com.gzl.cn.service.TestService"/>
第二种方式：spring 管理静态工厂-使用静态工厂的方法创建对象
public class TestController {
/**
* 模拟一个静态工厂，创建业务层实现类
*/
public static TestService testService() {
return new TestService();
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testService" class="com.gzl.cn.controller.TestController" factory-method="testService"/>
beans>
public class Client {
public static void main(String[] args) {
// 1.使用 ApplicationContext 接口，就是在获取 spring 容器
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
// 2.根据 bean 的 id 获取对象
TestService testService = (TestService)classPathXmlApplicationContext.getBean("testService");
testService.method1();
}
}
第三种方式：spring 管理实例工厂-使用实例工厂的方法创建对象
public class TestController {
/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public TestService testService() {
return new TestService();
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testController" class="com.gzl.cn.controller.TestController"/>
<bean id="testService" factory-bean="testController" factory-method="testService">bean>
beans>
public class Client {
public static void main(String[] args) {
// 这个参数就是传xml所在的位置，默认就是从项目根路径寻找bean.xml, classpath:bean.xml 和 bean.xml 是一样的效果
// 1.使用 ApplicationContext 接口，就是在获取 spring 容器
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
// 2.根据 bean 的 id 获取对象
TestController testController = (TestController) classPathXmlApplicationContext.getBean("testController");
TestService testService = (TestService) classPathXmlApplicationContext.getBean("testService");
System.out.println(testController);
System.out.println(testService);
System.out.println(testController.testService());
}
}
这里有一个细节，就是从容器当中取出来的工厂类，再次执行工厂方法拿到的对象 和 存到容器当中的对象不是一个！
第四种方式：通过FactoryBean来创建bean对象
BeanFactory接口，BeanFactory是spring容器的顶层接口，而这里要说的是FactoryBean，也是一个接口，这两个接口很容易搞混淆，FactoryBean可以让spring容器通过这个接口的实现来创建我们需要的bean对象。
public class TestController {
public TestController() {
System.out.println("TestController初始化了");
}
}
public class TestControllerFctoryBean implements FactoryBean<TestController> {
/**
* 实际上相当于将这个方法的返回值加入到容器当中
*
* @return
*/
@Override
public TestController getObject() {
return new TestController();
}
@Override
public Class<?> getObjectType() {
// 需要创建的对象的类型
return TestController.class;
}
/**
* true代表的是单例对象，如果是false的话每次从容器获取的对象就不是同一个了
*
* @return
*/
@Override
public boolean isSingleton() {
return true;
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testController" class="com.gzl.cn.controller.TestControllerFctoryBean"/>
beans>
public class Client {
public static void main(String[] args) {
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
for (String beanName : classPathXmlApplicationContext.getBeanDefinitionNames()) {
System.out.println(beanName + ":" + classPathXmlApplicationContext.getBean(beanName));
}
}
}
六、import元素
当我们的系统比较大的时候，会分成很多模块，每个模块会对应一个bean xml文件，我们可以在一个总的bean xml中对其他bean xml进行汇总，相当于把多个bean xml的内容合并到一个里面了，可以通过import元素引入其他bean配置文件。
语法：
用法如下：
bean.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="bean1.xml" />
<bean id="testController" name="testController1,testController2,testController3" class="com.gzl.cn.controller.TestController"/>
beans>
bean1.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testService" class="com.gzl.cn.service.TestService"/>
<alias name="testService" alias="testService1"/>
beans>