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容器使用步骤

1. 引入spring相关的maven配置
2. 创建bean配置文件，比如bean xml配置文件
3. 在bean xml文件中定义好需要spring容器管理的bean对象
4. 创建spring容器，并给容器指定需要装载的bean配置文件，当spring容器启动之后，会加载这些配置文件，然后创建好配置文件中定义好的bean对象，将这些对象放在容器中以供使用
5. 通过容器提供的方法获取容器中的对象，然后使用

二、入门练习

往后要练习的模块有很多，这里我们直接使用父子工程。

如果单纯使用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>