Spring5框架之何为Spring以及IOC容器的底层原理（一篇就会）

落日映苍穹つ 2023-09-28 19:03 5阅读 0赞

> **本篇主要讲述什么是Spring和它的IOC容器的实现原理，AOP切面编程以后再说。**

## 一、Spring概述 ##

### 1.1 什么是Spring ###

Spring是以**IOC(控制反转)**和**AOP（面向切面编程）**为内核的**轻量级开源框架。**

狭小方面来说相当于用一个容器来针对管理我们开发中的bean的生命周期。

宽广方面来说它可以集成其它框架技术来完成对JavaEE企业级的开发。

想了解更多可以移步至**[Spring官网。][Spring]**

![933015b66b4640239ef03d2e1c77f85c.png][]

### 1.2 Spring体系结构 ###

在Spring基本体系结构中是这样的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]

从上图可以看出，Spring核心是**Core Container来支撑，此外它也可以集成切面，WEB（控制层），以及数据库（持久层）。**

**核心依赖：**

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-beans</strong></span></td> 
   <td>负责配置文件，创建和管理bean，支持依赖注入和控制反转</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-core</strong></span></td> 
   <td>模块的核心基础，包含一些核心的工具类</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-context</strong></span></td> 
   <td>提供上下文的支持，最关键的就是<span style="color:#fe2c24;"><strong>ApplicationContext</strong></span></td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-expression</strong></span></td> 
   <td>Spring表达式语言，帮助spring运行时查询和操作对象，获取对象的属性和方法的调用</td> 
  </tr> 
 </tbody> 
</table>

**AOP模块：**

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-aop</strong></span></td> 
   <td>对于代理AOP的支持</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-Aspects</strong></span></td> 
   <td>对于Aspect的AOP支持</td> 
  </tr> 
 </tbody> 
</table>

**Web模块：**

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-web</strong></span></td> 
   <td>基础的web功能，在Web项目中提供Spring的容器</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-webmvc</strong></span></td> 
   <td>提供基于Servlet的SpringMVC</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-WebSocket</strong></span></td> 
   <td>提供WebSocket功能</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-webmvc-portlet</strong></span></td> 
   <td>提供portlet支持</td> 
  </tr> 
 </tbody> 
</table>

**数据库模块：**

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-jdbc</strong></span></td> 
   <td>提供jdbc访问数据库的支持</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-tx</strong></span></td> 
   <td>提供对数据库事务的支持</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-oxm</strong></span></td> 
   <td>提供对象xml的支持</td> 
  </tr> 
  <tr> 
   <td><span style="color:#4da8ee;"><strong>spring-jms</strong></span></td> 
   <td>提供对java消息服务的支持</td> 
  </tr> 
 </tbody> 
</table>

## 二、IOC与DI ##

### 2.1 IOC与DI的关系 ###

对于**IOC**在**[Spring官网][Spring 1]**是这样描述的：

> **IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse (hence the name, Inversion of Control) of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes or a mechanism such as the Service Locator pattern.**
> 
> **译文：**
> 
> **IoC也被称为依赖注入（DI）。它是一个对象仅通过构造函数的参数、工厂方法的参数或在对象实例构造，或从工厂方法返回后在对象实例上设置属性来定义其依赖关系（即，它们使用的其他对象）的过程。然后，容器在创建bean时注入这些依赖项。这个过程基本上是bean本身的逆过程（因此称为控制反转），通过使用类的直接构造或服务定位器模式等机制来控制其依赖项的实例化或位置。**

现在通俗易懂的来解释一下：

之前，我们需要硬编码方式去手动的创建对象， 周期。

现在将对象的创建，对象的生命周期以及它们之间的依赖关系全部交给Spring容器去管理，由Spring容器来负责控制对象的生命周期和对象之间的关系。

这种反转，**就叫做IOC（控制反转）**，就是通常我们所说的**IOC容器。**

从Spring容器的角度来看，Spring负责被依赖的对象赋值给调用者的成员变量，相当于为调用者注入它依赖的实例，就是Spring的**依赖注入（Dependency Inhection）**。

目的就是**降低耦合度****。**

### 2.2 耦合与解耦 ###

先看我们之前对数据的连接操作：

/**
     * @author jektong
     * @Date 2020/6/18-12:38
     */
    public class JdbcTemplate {
        public static void main(String[] args) throws SQLException {
            Connection conn=null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            try {
                //注册驱动
                Class.forName("com.mysql.cj.jdbc.Driver");
                //建立连接
                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bookmanage?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8",
                                                   "jektong",
                                                   "123456");
                //获取数据库连接的预处理对象
                ps = conn.prepareStatement("select * from book");
                //执行sql，得到结果集
                rs = ps.executeQuery();
                //遍历结果集
               while (rs.next()){
                       System.out.println(rs.getString("bname"));
                       System.out.println(rs.getString("author"));
               }
            } catch (ClassNotFoundException | SQLException e) {
                e.printStackTrace();
            }finally {
                //释放资源
                if (rs != null) {
                    rs.close();
                }
                if (ps != null) {
                    ps.close();
                }
                if (conn != null) {
                    conn.close();
                }
            }
        }
    }

这段代码是最初连接数据库的代码，运行此代码时，必须加入MySQL驱动包，不然会报错，这样就可以理解成程序间的耦合，也就是程序间的存在的依赖关系。

我们可以使用反射来创建JDBC对象，避免用new这个关键字，使用配置文件来获取到创建对象的全限定类名，来达到解耦的目的。

## 三、IOC过程（原理） ##

Spring对于IOC的实现主要原理就是**XML解析，反射，工厂模式。**

下面以图解方式逐渐的来说明什么是IOC原理。

### **3.1 原始的对象间调用** ###

下图简单的展示了最原始的对象调用的方式，直接在**UserService类**中的方法去创建**UserDao类**的对象然后调用**UserDao类**中的**add()**方法。

![cef3b3b2718846caa801bcb2c02e2253.png][]

这种原始的方式虽然可以达到我们所需要的效果，但是代码的**耦合度太高，如果UserDao中的路径与方法发生变化，毋庸置疑，UserService也要跟着变化。**

下面通过工厂模式将上面的过程进行一个解耦：

### **3.2 工厂模式解耦** ###

**![91e87c17e1b74f43a2f037fa2179e452.png][]**

现在我们将创建**UserDao**这个对象使用工厂模式去创建这个对象，然后**UserService**中用工厂来使用**UserDao**对象，这样就将这两个对象之间进行了解耦，降低了耦合度。

我们发现**UserFactory**中也创建了**UserDao**这个对象，说明对象与对象之间必然会存在着耦合度，但是如何将耦合度降低到最大的程度是值得深究的，很显然上面的这种方式并没有将耦合度降低到最低。

下面再通过加上**XML解析与反射**就可以将耦合度降到最低。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

### **3.3 XML，反射实现最大限度解耦** ###

首先，将**UserDao**对象配置到Spring提供的XML文件中。

再次使用工厂模式去创建**UserDao**这个对象，不过此时就需要使用**XML解析**的方式去获取上面xml配置的**class标签**中的值，也就是类所在的包路径。

得到这个包名之后可以通过反射机制来创建对象，反射创建对象的方法是**newInstance(),这个方法要记住。****以下是这个过程的伪代码：**

class UserFactory{
        public static UserDao getUserDao(){
            String valueName = class.值 // xml解析获取值
            Class classzz = Class.forName(valueName) // 反射或取得类
            return (UserDao)classzz.newInstance();
        }
    }

这就是IOC的过程，以上代码是这样实现进一步解耦的，当**UserDao**这个类发生变化时，比如**UserDao路径发生变化**，我们只需要修改XML文件中的class标签值即可，无需修改其他额外内容。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

## 四、IOC容器实现 ##

下面就来说说，Spring是如何使用IOC思想来实现IOC控制反转的。IOC本质是一种思想，那么IOC容器就是它的实现方式。而IOC容器的底层就是对象工厂。

IOC容器的实现方式，Spring提供了两种：**BeanFactory与ApplicationContext**

**1. BeanFactory**

IOC最基本的实现，是Spring内部最基本的实现，不提供给开发人员去使用。加载配置文件的时候，使用的是延迟加载的方式，只有获取到某个对象的时候，才会调用**getBean()**方法的时候才会创建对象，这样做如果出现一些Bean的配置问题就不好被发现。

**2. ApplicationContext**

作为**BeanFactory**的子接口，提供更多强大的功能，一般在开发时使用。当加载配置文件的时候，即容器一开始创建的时候，就加载所有的对象，唯一不足就是占用内存比较大。

**ApplicationContext所有的实现类如下：**

![2a91058bf8f64656b4dd08487cd440b7.png][]

[Spring]: https://spring.io/
[933015b66b4640239ef03d2e1c77f85c.png]: https://img-blog.csdnimg.cn/933015b66b4640239ef03d2e1c77f85c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200618103509686.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1,size_16,color_FFFFFF,t_70
[Spring 1]: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans
[cef3b3b2718846caa801bcb2c02e2253.png]: https://img-blog.csdnimg.cn/cef3b3b2718846caa801bcb2c02e2253.png
[91e87c17e1b74f43a2f037fa2179e452.png]: https://img-blog.csdnimg.cn/91e87c17e1b74f43a2f037fa2179e452.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/87df51d5c0224e5da096d68237646412.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5YyX5oWV55-l56eL,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/103159b982b14aa0b10e43ab4b33e3fc.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5YyX5oWV55-l56eL,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[2a91058bf8f64656b4dd08487cd440b7.png]: https://img-blog.csdnimg.cn/2a91058bf8f64656b4dd08487cd440b7.png