基础框架 Spring

痛定思痛。 2024-03-24 23:44 79阅读 0赞

## 引言 ##

我们常说，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.  **从容器中取出对象**

**具体操作流程如下：**  
![d07091620aca44528367b130be1c3027.png][]

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

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

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>

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

public class GetBean {
        
        public static void main(String[] args) {
        
            
        }
    }

### 2、注册 Bean ###

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

package com.work.demo;
    
    public class User {
        
        public void sayHi() {
        
            System.out.println("Hi,UserService!");
        }
    }

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

![57ce45afd44d4b6d80b48f4a6b8eefba.png][]

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

<?xml version="1.0" encoding="UTF-8"?>
    <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>

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

**注**：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"));
        }
    }

**注**：`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");

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

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

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

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

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

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

![8db6d5a1d92c429f8e327c167a22a50d.png][]

## 知识补充 ##

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

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

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

[d07091620aca44528367b130be1c3027.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/fac2a87497984698972d09fbf2c2f9af.png
[57ce45afd44d4b6d80b48f4a6b8eefba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/b7ba5c916d6c4f0cbb162f9360faaa25.png
[8db6d5a1d92c429f8e327c167a22a50d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/00d62135d2af45f6b590401596a338c0.png