• 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. 通过容器提供的方法获取容器中的对象，然后使用

    二、入门练习

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

    只需要引入spring-context的依赖就可以了

    （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-contextartifactId>
               <version>${spring.version}version>
           dependency>
       dependencies>
    dependencyManagement>
project>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    （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>junitgroupId>
          <artifactId>junitartifactId>
          <version>3.8.1version>
          <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
        dependency>
    dependencies>
project>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    （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");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    public class TestService {

	public TestService() {
        System.out.println("TestService初始化了");
    }
 
    public void method1() {
        // 业务省略...
    }

    public void method2() {
        // 业务省略...
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    （4）添加bean.xml

    上面这一大堆url是命名空间，也就是提供了bean标签，spring需要根据这个来进行解析bean标签，如果没有他的话启动会报错

    
<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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    （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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    运行结果：

    通过运行结果不难发现，spring是通过我们提供的xml知道需要创建哪些对象，并通过无参构造器进行创建。

    这里还有一个细节问题，当ClassPathXmlApplicationContext初始化过后，xml当中声明的对象就已经全部都初始化了。也就是对象是随着容器的初始化进行初始化的。

    三、BeanFactory接口

    通过上面示例不能发现classPathXmlApplicationContext就是spring容器的核心，classPathXmlApplicationContext是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);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    四、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"));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5

    运行结果：并没有访问无参构造器初始化，当通过XmlBeanFactory 第一次访问getBean方法的时候才会触发初始化！

    接下来再来看classPathXmlApplicationContext：

    public class Client {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5

    运行结果：不管使用没使用都会触发初始化！

    这里我们简单做个总结：

    • 关系：BeanFactory和ApplicationContext都是接口，BeanFactory是最顶级的接口，ApplicationContext是BeanFactory的子接口。
    • BeanFactory中定义了各种bean的方法，比如根据id或者类型来获取bean，以及判断bean是否存在等方法。ApplicationContext继承了他的所有方法，并且还继承了很多接口，如：MessageSource（国际化资源接口）、ResourceLoader（资源加载接口）、ApplicationEventPublisher（应用事件发布接口）等。
    • 初始化：接口就是定义方法，压根没功能，一般说起来功能的差距也就是上面我们所测试的classPathXmlApplicationContext 和XmlBeanFactory的区别，XmlBeanFactory就是对应的BeanFactory，BeanFactory是懒加载方式，只在第一次使用的时候初始化。而classPathXmlApplicationContext 是初始化容器的时候加载所有对象。

    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="卸载对象的时候执行的方法"/>

    • 1
    • 2

    属性：

    • 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/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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    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));
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    5.2.alias元素

    alias元素也可以用来给某个bean定义别名，语法：

    <alias name="需要定义别名的bean" alias="别名" />

    • 1
    <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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

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

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

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

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

    5.4.实例化 Bean 的四种方式

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

    
<bean id="testService" class="com.gzl.cn.service.TestService"/>

    • 1
    • 2

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

    静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其静态方法配置给Spring即可

    public class TestController {
	/**
	* 模拟一个静态工厂，创建业务层实现类
	*/
    public static TestService testService() {
        return new TestService();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 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/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    
    <bean id="testService" class="com.gzl.cn.controller.TestController" factory-method="testService"/>
beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    第三种方式：spring 管理实例工厂-使用实例工厂的方法创建对象

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

    public class TestController {
    /**
     * 模拟一个实例工厂，创建业务层实现类
     * 此工厂创建对象，必须现有工厂实例对象，再调用方法
     */
    public TestService testService() {
        return new TestService();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    <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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    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());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    这里有一个细节，就是从容器当中取出来的工厂类，再次执行工厂方法拿到的对象 和 存到容器当中的对象不是一个！

    第四种方式：通过FactoryBean来创建bean对象

    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;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    案例：

    public class TestController {

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

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    
<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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    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));
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

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

    六、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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
  • 相关阅读:
    如何利用产品状态维度优化库存管理和采购策略？【ODOO15/16】
    前端开发 开发过程
    tiktok接口对接
    C语言回调函数到底是怎么回事？
    精通Linux，没用过lsof命令？
    springAOP落地实现
    448. 找到所有数组中消失的数字
    数字化校园建设规划方案
    51.Sentinel微服务保护
    机器学习之深度学习简介
  • 原文地址：https://blog.csdn.net/weixin_43888891/article/details/127647693