Spring学习第3篇：Spring容器的基本使用

大家家好，我是一名网络怪咖，北漂五年。相信大家和我一样，都有一个大厂梦，作为一名资深Java选手，深知Spring重要性，现在普遍都使用SpringBoot来开发，面试的时候SpringBoot原理也是经常会问到，SpringBoot是为了简化Spring开发，但是底层仍然是Spring。如果不了解Spring源码，那就更别提SpringBoot源码了，接下来我准备用两个月时间，从基础到源码彻彻底底的学习一遍Spring。

学习框架一定要踏踏实实一步一个脚印的学，很多人都比较喜欢急功近利，选择跳着学，包括我有时候也是，最终会发现你不但节约不了时间，反而会更耗时，而且学着学着很容易放弃。

一、概念知识

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

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion><groupId>com.gzl.cn</groupId><artifactId>spring-demo</artifactId><packaging>pom</packaging><version>1.0-SNAPSHOT</version><modules><module>spring-ioc-xml</module></modules><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><!-- 配置maven编译的时候采用的编译器版本 --><maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion><!-- 指定源代码是什么版本的，如果源码和这个版本不符将报错，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-source参数 --><maven.compiler.source>8</maven.compiler.source><!-- 该命令用于指定生成的class文件将保证和哪个版本的虚拟机进行兼容，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-target参数 --><maven.compiler.target>8</maven.compiler.target><spring.version>5.3.23</spring.version></properties><!-- 管理依赖版本 --><dependencyManagement><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>${spring.version}</version></dependency></dependencies></dependencyManagement><build><plugins><plugin><artifactId>maven-surefire-plugin</artifactId><!-- 打包跳过单元测试 --><configuration><skipTests>true</skipTests><testFailureIgnore>true</testFailureIgnore></configuration></plugin><plugin><artifactId>maven-compiler-plugin</artifactId><configuration><source>1.8</source><target>1.8</target><encoding>utf-8</encoding></configuration></plugin></plugins></build></project>

（2）子工程pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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-demo</artifactId><groupId>com.gzl.cn</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>spring-ioc-xml</artifactId><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId></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

<!-- 上面这一大堆是命名空间，也就是他提供了bean标签，spring需要根据这个来进行解析bean标签，如果没有他的话启动会报错 -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中id 属性：对象的唯一标识。spring内部将这些名称和具体的bean对象进行绑定，然后spring容器可以通过这个的名称找对我们需要的对象，这个名称叫做bean的名称class 属性：指定要创建对象的全限定类名--><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查找容器中的beanObject 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);// 是否为单实例Beanboolean 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查找返回的对象类型。@NullableClass<?> getType(String var1) throws NoSuchBeanDefinitionException;@NullableClass<?> 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名称！

获取当前名称的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/beanshttp://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/beanshttp://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>

在beanFactory中维护着一个名为aliasMap的Map<String,String>集合，存储别名和beanName之间的映射关系

5.3.bean 的作用范围和生命周期

单例对象：scope=“singleton”
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
       对象出生：当应用加载，创建容器时，对象就被创建了。
       对象活着：只要容器在，对象一直活着。
       对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope=“prototype”
每次访问对象时，都会重新创建对象实例。
生命周期：
       对象出生：当使用对象时，创建新的对象实例。
       对象活着：只要对象在使用中，就一直活着。
       对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

5.4.实例化 Bean 的四种方式

第一种方式：使用默认无参构造函数

<!--在默认情况下：它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。 -->
<bean id="testService" class="com.gzl.cn.service.TestService"/>

第二种方式：spring 管理静态工厂-使用静态工厂的方法创建对象

静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其静态方法配置给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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 注意:这里的class是指静态方法所在的类，并不会将TestController存入容器，而是将testService静态方法的返回值放入容器 --><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 管理实例工厂-使用实例工厂的方法创建对象

实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean

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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 此种方式是：先把工厂的创建交给 spring 来管理。然后在使用工厂的 bean 来调用里面的方法,将方法的返回值存入到容器当中factory-bean 属性：用于指定实例工厂 bean 的 id。factory-method 属性：用于指定实例工厂中创建对象的方法。--><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对象。

上面不管是静态工厂方式还是非静态工厂方式，都是自定义的工厂方法，Spring提供了FactoryBean的接口规范，FactoryBean接口定义如下：

public interface FactoryBean<T> {String OBJECT_TYPE_ATTRIBUTE = “factoryBeanObjectType”;T getObject() throws Exception; //获得实例对象方法Class<?> getObjectType(); //获得实例对象类型方法default boolean isSingleton() {return true;}
}

案例：

public class TestController {public TestController() {System.out.println("TestController初始化了");}}

public class TestControllerFctoryBean implements FactoryBean<TestController> {/*** 实际上相当于将这个方法的返回值加入到容器当中** @return*/@Overridepublic TestController getObject() {return new TestController();}@Overridepublic Class<?> getObjectType() {// 需要创建的对象的类型return TestController.class;}/*** true代表的是单例对象，如果是false的话每次从容器获取的对象就不是同一个了** @return*/@Overridepublic boolean isSingleton() {return true;}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 注意：这里并不是说将TestControllerFctoryBean加入到容器，而是将TestControllerFctoryBean当中的getObject方法返回值加入到容器--><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));}}
}

当首次用到TestController时，才调用getObject() ，此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池中，并且后期每次使用到userDao都从该缓存池中返回的是同一个testController实例。

六、import元素

当我们的系统比较大的时候，会分成很多模块，每个模块会对应一个bean xml文件，我们可以在一个总的bean xml中对其他bean xml进行汇总，相当于把多个bean xml的内容合并到一个里面了，可以通过import元素引入其他bean配置文件。

语法：<import resource="其他配置文件的位置" />

用法如下：

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="testService" class="com.gzl.cn.service.TestService"/><alias name="testService" alias="testService1"/>
</beans>