【Spring】（二）从零开始的 Spring 项目搭建与使用

文章目录

• 前言
• [一、Spring 项目的创建](#一、Spring 项目的创建)
• • [1.1 创建 Maven 项目](#1.1 创建 Maven 项目)
  • [1.2 添加 Spring 框架支持](#1.2 添加 Spring 框架支持)
  • [1.3 添加启动类](#1.3 添加启动类)
• [二、储存 Bean 对象](#二、储存 Bean 对象)
• • [2.1 创建 Bean](#2.1 创建 Bean)
  • [2.1 将 Bean 注册到 Spring 容器](#2.1 将 Bean 注册到 Spring 容器)
• [三、获取并使用 Bean 对象](#三、获取并使用 Bean 对象)
• • [3.1 获取Spring 上下文](#3.1 获取Spring 上下文)
  • [3.2 ApplicationContext 和 BeanFactory 的区别](#3.2 ApplicationContext 和 BeanFactory 的区别)
  • [3.3 获取指定的 Bean 对象](#3.3 获取指定的 Bean 对象)
• 四、总结

---

前言

通过前面的文章我们知道了，Spring 其实就是一个包含了众多工具的 IoC 容器。既然是容器那么主要就涉及到两个操作，即：

• 将对象储存到 Spring 容器中；
• 使用的使用将对象从 Spring 容器中取出。

因此，学习 Spring 容器，主要就是学习它的存取操作。下文详细介绍了 Spring 项目的创建与使用。

一、Spring 项目的创建

下文将以 Maven 的方式来创建一个 Spring 项目，创建 Spring 项目的方式与 Servlet 类似，主要分为以下三步骤：

1. 创建 Maven 项目；
2. 添加 Spring 框架支持；
3. 添加启动类。

以下就是围绕这三个步骤来创建 Spring 项目的具体过程。

1.1 创建 Maven 项目

创建好后其目录结构如下：

1.2 添加 Spring 框架支持

1. 在 Maven 中央仓库搜索 Spring，选择 "Spring Context"：
   
2. 选择 5.xxxx版本

3. 选择 Maven，然后将其复制粘贴到 pom.xml 文件中

最后的 pom.xml文件样式如下：

1.3 添加启动类

即在 Java 目录下创建一个类，其中包含一个 main 方法即为启动类：

二、储存 Bean 对象

什么是 Bean：

在 Spring 框架中，Bean 是一个非常重要的概念，它是Spring容器中被管理和维护的对象 。Bean 可以是任何的Java对象 ，例如 POJO（Plain Old Java Object）、实体类、服务类等。这些对象在 Spring 容器中被实例化、组装、管理和销毁，以提供各种功能和服务。

储存 Bean 分为两个步骤：

1. 先创建 Bean 类；
2. 然后将创建的 Bean 注册到 Spring 容器中。

2.1 创建 Bean

此处以一个 Student 类为例：

public class Student {
    
    public Student(){
        System.out.println("init student");
    }
    
    public void sayHi(){
        System.out.println("Hi, I am a student.");
    }
}

2.1 将 Bean 注册到 Spring 容器

要想将 Bean 对象注册到 Spring 容器中，首先需要在 resources 目录下创建一个配置文件，一般取名为 spring-config.xml：

Spring 配置文件的固定为以下内容：

<?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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
</beans>

然后将 Student 对象注册到 Spring 中，即在 <beans>添加以下配置：

其中 id 字段表示给 Bean 取的名，class 字段则是 包名 + 类名。

三、获取并使用 Bean 对象

获取并使用 Bean 对象也大致可分为以下三步：

1. 获取 Spring 上下文对象，因为对象都交给 Spring 管理了，所有要获取 Spring 中的 Bean，首先就需要获取 Spring；
2. 通过回去的 Spring 上下文对象，获取指定的 Bean 对象；
3. 使用 Bean 对象。

3.1 获取Spring 上下文

获取 Spring 上下文对象的方式主要有两个，即使用ApplicationContext和BeanFactory来获取。

1. 使用ApplicationContext获取

    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
    }

2. 使用BeanFactory获取

    public static void main(String[] args) {
        BeanFactory beanFactory =
                new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
    }

3.2 ApplicationContext 和 BeanFactory 的区别

此时，分别执行 ApplicationContext 和 BeanFactory 获取 Spring 上下文对象的 main方法：

ApplicationContext ：

此时，可以发现当使用 ApplicationContext获取 Spring 上下文的时候，会立即初始化 Spring 容器中的 Bean 对象。

BeanFactory：

当使用BeanFactory 获取 Spring 上下文的时候，并没有立即初始化 Spring 中的 Bean 对象，而是在获取 Bean 对象的时候才初始化，即是一种懒加载模式。

ApplicationContext 和 BeanFactory之间的区别可总结如下：

继承关系和功能层面：

• ApplicationContext 接口继承了 BeanFactory 接口，其中 BeanFactory 提供了基础的访问容器的能力，而 ApplicationContext 除了继承 BeanFactory的所有功能之外，还拥有独特的功能，比如添加了对国际化的支持、资源的访问支持、事件传播等方面的支持。

性能方面：

• ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，而 BeanFactory 是需要哪个 Bean 对象的时候才会去加载，因此更加轻量。
• 因此当性能要求较高而内存充足的场景下推荐使用 ApplicationContext；而在内存空间较小，对性能要求不高的场景下推荐使用BeanFactory。

3.3 获取指定的 Bean 对象

1. 直接通过 Bean 对象的名称获取

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
Student student = (Student) context.getBean("student");

getBean方法直接通过 Bean 对象的名称获取返回的是一个 Object 对象，因此需要强制类型转换。

2. 通过 Bean 的类型获取

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
Student student = context.getBean(Student.class);

getBean方法通过 Bean 对象的类型获取，此时不需要进行强制类型转换，但是这种方法存在一个问题：如果当 Spring 容器中存在多个相同类型的 Bean 对象的时候就会出现歧义，即找不到返回哪个对象。

比如在 Spring 容器中再添加一个 Student 对象：

此时启动 main 函数的时候，就会出现如下问题：

此时，Spring 容器中存在两个相同类型的 Bean 对象，而通过类型获取的话，就不知道获取哪一个了。因此要解决这个问题就可以采用 通过 Bean 名称 + 类型获取。

3. 通过 Bean 名称 + 类型获取

    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        Student student = context.getBean("student", Student.class);
        Student student2 = context.getBean("student2", Student.class);
        
        student.sayHi();
        student2.sayHi();
    }

此时，通过 Bean 名称 + 类型获取的方式，即使是 Spring 容器中存在多个相同类型的 Bean 对象，但由于其名称不同，也能够正确获取到指定的 Bean 对象。

四、总结

以上详细介绍了 Spring 项目的创建和使用过程，下面是对其整个流程的总结。

1. 通过 Maven 项目创建 Spring 项目，并且还要添加对 Spring 框架的支持；
2. 创建 Bean 对象，然后通过 spring-config.xml 配置文件将其储存到 Spring 容器中；
3. 获取 Bean 对象：
   • 首先通过 ApplicationContext 或者 BeanFactory 获取配置文件，即获取 Spring 上下文对象。
   • 通过 getBean 方法获取 Bean 对象。
   • 使用 Bean 对象。