基础框架 Spring

引言

我们常说，Java 程序员不会 Spring，那还叫 Java 程序员吗？由此可见Spring在Java领域的重要性，本章我们就来谈谈 Spring 到底是何方神圣？

一、Spring 核心概念（重要）

1、Spring 是什么？

一句话概括：Spring 是包含了众多工具方法的 IoC 容器。

2、什么是 IoC ？

IoC 全称为 Inversion of Control，即控制权反转。这也就是说 Spring 是⼀个“控制权反转”的容器。这里的“控制权反转”是一种设计思想。

1. 在传统的编程模式中，对象的生命周期是由当前代码自身控制的。这种模式的诟病就是代码之间的耦合性较高，会导致代码拓展性和可维护性降低。例如如果一个对象 A 需要使用对象 B 的功能，那么对象 A 就需要创建并维护一个对象 B，这也就导致了 A 和 B 之间的强耦合关系，如果此时对象 B 发生改变，A 也要跟着修改。

2. IoC 则是将对象的生命周期交由外部容器来控制。它的一大特点就是实现代码之间的解耦。此时 A 对象需要使用 B 对象的功能就不再需要自己实例化 B 了，而是将控制权交给容器，容器进行实例化和管理组件，并将所需的对象 B 导入到 A 中，后续即使 B 发生改变，只需要修改容器中的 B 即可。

3、什么是 DI ？

DI 全称为 Dependency Injection，即依赖注入。指的是在程序运行期间，动态的将依赖对象获取到的过程。

4、IoC 和 DI 的关系和区别？

关系：

IoC -Inversion of Control 控制权反转，DI-Dependency Injection 依赖注入，他俩是从不同角度来描述同一件事情，就是当我们的程序需要某个依赖对象时，不自己取创建它了，而是去从容器中取，也就是将对象的生命周期交由控制器控制，实现对象之间的解耦。

区别：

IoC是一种设计思想，而 DI 是IoC思想的一种实现方式。

二、Spring 的创建和使用

Spring（IoC）容器，管理的资源是 对象，这个对象通常被称为 Bean。既然是一个容器，那么它一定具备两个基础功能：

1. 将对象存入到容器中
2. 从容器中取出对象

具体操作流程如下：

1、创建 Spring 项目（Maven+依赖）

（1）创建一个普通的 Spring 项目，首先使用 IDEA 创建一个 Maven 项目，然后再 pom.xml 中添加 Spring 框架的依赖文件：

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.2.3.RELEASEversion>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-beansartifactId>
    <version>5.2.3.RELEASEversion>
dependency>
1
2
3
4
5
6
7
8
9
10
11

（2）添加启动测试类
在创建好的项目 java 文件夹下创建⼀个启动类，包含 main 方法即可：

public class GetBean {
    public static void main(String[] args) {
        
    }
}
1
2
3
4
5

2、注册 Bean

（1）这一步也就是将 Bean 对象存储到 Spring（IoC）容器中，当然前提是我们先创建一个 Bean：

package com.work.demo;

public class User {
    public void sayHi() {
        System.out.println("Hi,UserService!");
    }
}
1
2
3
4
5
6
7

（2）将 Bean 注册到 Spring 容器中

配置文件的固定格式如下：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="http://www.springframework.org/schema/context"
       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">
    
    <bean id="user" class="com.work.demo.User">bean>

beans>
1
2
3
4
5
6
7
8
9

3、获取并使用 Bean

（1）得到 Spring 上下文对象

这里的上下文对象，可以理解为当前的容器管理对象，因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到 Spring 的上下文。

方式一：使用 ApplicationContext 作为上下文。

public class GetBean {
    public static void main(String[] args) {
        // 1.获取 Spring 上下文对象（这里需要填写上一步的配置文件名）
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
    }
}
1
2
3
4
5
6
7

注：ClassPathXmlApplicationContext 属于 ApplicationContext 的子类，拥有 ApplicationContext 的所有功能，是通过 xml 的配置来获取所有的 Bean 的。

方式二：使用 BeanFactory 作为上下文。

public class GetBean {
    public static void main(String[] args) {
        // 1.获取 Spring 上下文对象
        BeanFactory beanFactory =
                new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
    }
}
1
2
3
4
5
6
7

注：new ClassPathResource("spring-config.xml")它创建了一个ClassPathResource对象，用于加载位于类路径下的spring-config.xml配置文件。

ApplicationContext & BeanFactory 的区别？

1. 从继承关系和功能方面来说：ApplicationContext 属于 BeanFactory 的子类，ApplicationContext 拥有更多的功能。
2. 从性能方面来说：加载 Bean 机制不同。BeanFactory 是懒加载，即需要哪个才去加载哪个，因此它的启动比较快，但是之后获取比较慢；而ApplicationContext 一次性加载并初始化所有的 Bean 对象，因此它的启动比较慢，但是后期获取非常快。

（2）获取指定的 Bean 对象（依赖查找）

获取 Bean 对象，是通过 Spring 上下文对象中的 getBean() 方法进行获取的（IoC的一种实现方式，依赖查找），它主要有如下三种用法。

用法一：根据名称获取 Bean 对象

User user1 = (User) context.getBean("user");
1

用法二：根据类型获取 Bean 对象

User user2 = context.getBean(User.class);
1

注意：当有一个类型被重复注册到 spring-config.xml 中时，就只能使用根据名称获取了。

用法三：根据名称+类型获取 Bean 对象（常用）

User user3 = context.getBean("user",User.class);
1

（3）使用 Bean 对象

获取到 Bean 对象之后，直接使用即可。

public class GetBean {
    public static void main(String[] args) {
        // 1.得到 Spring 上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 2.获取 Bean 【依赖查找 -> IoC 的一种实现方式】
        User user = beanFactory.getBean("user",User.class);
        // 3.使用 Bean 对象
        user.sayHi();
    }
}
1
2
3
4
5
6
7
8
9
10
11

知识补充

被Spring管理的对象在整个项目中只存在一份，也就是说它们是单例的。当Spring容器启动时，会根据配置信息创建这些对象，并将它们保存在容器中。之后，每当需要使用这些对象时，Spring会从容器中获取已创建的实例，而不会再次创建新的实例。

通过将对象声明为单例，可以有效地减少资源消耗，提高性能和效率。在大多数情况下，单例对象是足够满足需求的。但有时也会存在需要多个实例的情况，针对这种情况，Spring也提供了其他作用域（如原型作用域）来管理对象的生命周期。

如果需要将被Spring管理的对象设置为非单例，可以通过在配置文件中进行相应的配置，将其作用域设置为原型（Prototype）。这样，每次从容器中获取该对象时，都会得到一个新的实例。