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

已于 2023-07-05 23:21:30 修改
阅读量3k 收藏 21
点赞数 4
分类专栏： # Spring 文章标签： spring java 学习
于 2022-11-03 17:42:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43888891/article/details/127647693
版权

       大家家好，我是一名网络怪咖，北漂五年。相信大家和我一样，都有一个大厂梦，作为一名资深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

<?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-context</artifactId>
               <version>${spring.version}</version>
           </dependency>
       </dependencies>
    </dependencyManagement>
</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>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</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

上面这一大堆url是命名空间，也就是提供了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/beans
    http://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知道需要创建哪些对象，并通过无参构造器进行创建。

这里还有一个细节问题，当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);
}

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

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

这里我们简单做个总结：

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

属性：

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

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>

在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/beans
    http://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/beans
    http://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是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
     */
    @Override
    public TestController getObject() {
        return new TestController();
    }

    @Override
    public Class<?> getObjectType() {
    	// 需要创建的对象的类型
        return TestController.class;
    }
	
	/**
     * true代表的是单例对象，如果是false的话每次从容器获取的对象就不是同一个了
     *
     * @return
     */
    @Override
    public 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/beans
    http://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 缓存池中，并且后期每次使用到TestController都从该缓存池中返回的是同一个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/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

<?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/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>
怪 咖@
关注
  • 4
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring零基础入门到精通 --- IOC基础容器
shuai_h的博客
03-25 1453
Spring零基础入门到精通
Spring - Spring容器概念及其初始化过程
weixin_34324081的博客
11-18 1926
引言 工作4年多，做了3年的java，每个项目都用Spring，但对Spring一直都是知其然而不知其所以然。鄙人深知Spring是一个高深的框架，正好近期脱离加班的苦逼状态，遂决定从Spring的官方文档入手，结合Spring代码和实际项目，全面的学习Spring，并将学习内容记录在博客上，以便以后查阅并可以和众猿讨论分享。PS：文章中会有部分是官方原句翻译，例子也...
Spring之IoC容器篇
kissship的博客
08-17 933
Spring是一个开源的应用程序开发框架，它由Rod Johnson创建，主要用于构建企业级Java应用程序。它提供了一个全面的编程和配置模型，可以简化Java开发过程，提高开发效率和可维护性。即为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。目的：解决企业应用开发的复杂性功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能范围：任何Java应用简单来说，
Spring容器
qq_52963857的博客
07-03 1478
Spring核心容器介绍 Spring核心容器总结 Spring注解开发 注解开发定义Bean对象 纯注解开发模式 注解开发Bean作用范围和生命周期管理 注解开发依赖注入 注解开发管理第三方Bean 注解开发为第三方Bean注入资源 注解开发总结
SpringBoot源码学习之AOP切面编程原理
最新发布
qq_39108894的博客
06-16 817
AOP切面编程主要用于抽取与具体业务逻辑无关的逻辑并组织起来以另一种方式重新与业务逻辑“耦合”在一起。比如，在WEB项目中，往往需要对接口做鉴权、性能统计、日志记录、事务处理等，这些逻辑跟业务逻辑无关、是独立的，但它也是多数业务逻辑都需要的。将这些横跨多种业务逻辑的、与业务无关的逻辑抽取出来，在合适的地点“切入”目标方法的过程就叫做横切，而这些抽取的逻辑就叫横切关注点。
Spring框架（容器）--简介（实现原理、核心模块、组成部分）
睡不醒的每天
12-29 1193
1、Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。2、Spring是一个轻量级的``控制反转(IoC)和面向切面(AOP)的容器框架```。3、轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
spring揭密-容器类型
qaws9403的博客
10-10 626
Spring提供了两种容器类型，一个是BeanFactory，另一个是ApplicationContext。 BeanFactory 基础类型的IOC容器，提供完整的IOC服务支持。默认采用延迟初始化策略，即只有当客户端对象需要访问容器中的受管对象时，才对该受管对象进行初始化以及依赖注入操作。 ApplicationContext是在BeanFactory基础上构建（间接继承），是比较高级的容器实现。除了拥有BeanFactory的所有支持，还提供了其他高级特性，比如事件发布，国际化信息支持等。App
JAVA spring 系列案例50个和学习资料
03-01
Spring系列第3篇：Spring容器基本使用及原理。Spring系列第4篇：xml中bean定义详解(-)Spring系列第5篇：创建bean实例这些方式你们都知道？Spring系列第6篇：玩转bean scope，避免跳坑里！Spring系列第7篇：依赖注入...
Spring源码学习三：BeanFactory解析1
08-04
BeanFactory提供了对Bean的创建、初始化、销毁等操作的支持，是Spring容器的基础。当我们通过XML、Java配置或者注解定义Bean时，Spring会将这些配置解析成BeanDefinition对象，BeanDefinition包含了Bean的所有元数据...
SpringiA4_SourceCode:Spring实战第四版源码，学习用。
01-19
5. **研究注解处理**：Spring大量使用注解进行配置，学习如何解析和处理这些注解，以及它们在程序运行时如何起作用。 6. **参与社区**：加入Spring社区，阅读文档，参与讨论，这将有助于你获取最新的信息和解决问题...
第三章：Spring AOP API 设计与实现1
08-03
Spring AOP API 设计与实现是Spring框架的重要组成部分，它提供了面向切面编程的能力，使得开发者可以在不修改源代码的情况下，对程序进行横切关注点的处理，如日志记录、事务管理等。本章主要涵盖了Spring AOP的多...
Spring源代码解析(一)：IOC容器.doc
08-04
在Spring源代码解析的第一部分，我们将聚焦于IOC容器，特别是BeanFactory接口，它是所有Spring容器的基础。 BeanFactory接口是Spring的基石，它定义了基本的容器操作，如获取Bean、检查Bean是否存在、确定Bean的...
Spring的IOC容器使用
weixin_42352733的博客
11-19 409
Controller层、sevice层与dao层 这三层的联系，我们通过注解的方式进行， Controller层：控制层，最好是只存放对应控制文件；通过@controller来进行注解，让Spring知道这个为控制层 sevice层：代码业务层，后续所有的代码实现都在这块进行；通过@service注解来进行，交给Spring来识别并创建对应对象： StudentService为service的一个类 他与controller联系的话，通过 @Autowired priva...
将Bean交给Spring容器管理有几种方式？
m0_73311735的博客
10-12 1305
前两种方式，大家用的可能比较多，也是平时开发中必须要知道的，@Import注解用的可能不是特别多了，但是也是非常重要的，在进行Spring扩展时经常会用到，它经常搭配自定义注解进行使用，然后往容器中导入一个配置文件。他是所有Spring Bean的容器根接口，给Spring 的容器定义一套规范，给IOC容器提供了一套完整的规范，比如我们常用到的getBean方法等。方法，然后将我们要导入的类的全限定名写在里面即可，实现起来也是非常简单。注解的源码中，说的已经很清楚了，感兴趣的可以看下，我们实现一个。
Spring学习（二）容器、基于XML管理Bean
bollks的博客
04-03 652
不同于BeanFactory是spring内部的接口，用以达成IoC容器的实现，FactoryBean是spring提供的一种整合第三方框架的常用机制。Spring通过IoC容器来管理**所有Java对象的实例化和初始化，控制对象与对象间的依赖关系；同时在IoC容器初始化时完成单实例对象的创建，多实例只有在获取时才创建（所以不在输出中）根据类型获取，返回对应类型，要求指定类型Bean只能有一个，多个则选择第三个方法；由输出可知，单实例Bean对象唯一，多实例每次获取新对象；属性中的类对象，而是。
Spring基础篇——Spring容器和应用上下文理解
ymzdb7的博客
01-09 168
https://www.cnblogs.com/chenbenbuyi/p/8166304.html
Spring框架1-容器功能
new___Smile的博客
08-31 2114
核心容器(Core)这是Spring框架最基础的部分，它提供了依赖注入（Dependency Injection）特征来实现容器对Bean的管理。这里最基本的概念是BeanFactory，它是任何Spring应用的核心。BeanFactory是工厂模式的一个实现，它使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。 spring的容器中注入各个实例，使得他们在同一个空间，方便。而且是通过x
Spring学习笔记（一）spring的两种容器
qingniaowtg的博客
07-03 662
1.Sping 的 BeanFactory 容器 在 Spring 中，有大量对 BeanFactory 接口的实现。其中，最常被使用的是 XmlBeanFactory 类。这个容器从一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用。 在资源宝贵的移动设备或者基于 applet 的应用当中， BeanFactory 会被优先选择 XmlBeanFactory ...
spring in action 第三版
07-30
《Spring in Action 第三版》是一本经典的技术书籍，详细介绍了Spring框架的核心概念、特性和应用实践。该书由Craig Walls撰写，并通过丰富的示例代码和清晰的讲解，向读者深入解释了Spring框架的各个方面。 该书首先介绍了Spring框架的背景和基本概念，包括控制反转（IoC）和面向切面编程（AOP），探讨了Spring容器、Bean和依赖注入（DI）的工作原理。随后，书中深入讲解了如何使用Spring框架进行Web开发，包括使用Spring MVC开发Web应用程序、Spring Web Flow进行流程管理和使用Spring Security处理安全性问题。 此外，该书还介绍了Spring的数据访问和集成测试等关键主题。读者将学习如何使用Spring对数据库进行访问，包括使用JDBC、Hibernate和JPA进行数据访问。此外，书中还介绍了如何使用Spring进行事务管理、缓存、消息队列和调度等高级功能。 最后，该书还介绍了Spring Boot的基本概念和使用方法。Spring Boot是Spring框架的快速应用开发工具，它通过自动配置和约定优于配置的方式，简化了Spring应用程序的开发和部署过程。读者将了解如何使用Spring Boot来创建独立的Spring应用程序，并通过配置文件和命令行参数等方式进行灵活的配置。 总之，《Spring in Action 第三版》通过全面而详细的内容，帮助读者全面了解和掌握Spring框架的核心知识和实战技巧。无论是对于初学者还是有经验的开发人员，都是一本值得阅读和参考的优秀书籍。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怪 咖@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值