初学spring——Spring内核之IoC/DI（控制反转/依赖注入）

本是古典何须时尚 2023-10-10 10:54 5阅读 0赞

#### 文章目录 ####

*   *   *  什么是IoC/DI？
         *  搭建Spring环境
         *  实现IoC
         *   *  定义一个UserDao接口：
             *  UserDaoImpl去实现它
             *  将UserDao装配到容器
             *  测试
         *  实现DI
         *   *  setter方法注入
             *  构造器注入
         *  我的目录结构

#### 什么是IoC/DI？ ####

它的全称是:Inversion of Control/Dependency InJect，翻译过来就是**控制反转/依赖注入**。IoC是spring的基础，它实现一种控制反转的功能。说白了就是把对象的控制权交给了Spring而不再由应用程序来创建。DI与IoC的功能相同，因为他们的主语都是Spring，只不过是换了一个说法来表述同一件事情，它实现的是依赖注入，因为它已经被赋予了相关的值，直接使用就OK。

#### 搭建Spring环境 ####

下面先看一下Spring基础包的说明：

<table> 
 <thead> 
  <tr> 
   <th>包名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>spring-core-xxx-x.jar</td> 
   <td>Spring框架的核心工具类 ，Spring的其他组件都要使用这个包</td> 
  </tr> 
  <tr> 
   <td>spring-beans-xxx-x.jar</td> 
   <td>Spring所有的应用都需要用到的Jar，他能访问配置文件、创建和管理bean以及实现IoC和DI操作相关的所有类</td> 
  </tr> 
  <tr> 
   <td>spring-context-xxx-x.jar</td> 
   <td>提供了IoC的扩展服务还提供许多企业级服务的支持。如：远程访问、缓存、邮件等</td> 
  </tr> 
  <tr> 
   <td>spring-expression-xxx-x.jar</td> 
   <td>定义了spring表达式语言</td> 
  </tr> 
 </tbody> 
</table>

使用Spring时，需要把这四个基础包导入（后面有一个坑要踩）：  
![基础包][20200225095942879.jpg]

#### 实现IoC ####

IoC理论上是借助于“第三方”实现了具有依赖关系对象之间的解耦。

##### 定义一个UserDao接口： #####

package com.dz.ioc_di;
    
    public interface UserDao {
        
    	/**
    	 * 讲一下哈：你好
    	 */
    	public abstract void sayHello();
    
    }

##### UserDaoImpl去实现它 #####

package com.dz.ioc_di;
    
    public class UserDaoImpl implements UserDao {
        
    
    	@Override
    	public void sayHello() {
        
    		System.out.println("你好！");
    	}
    
    }

##### 将UserDao装配到容器 #####

（配置文件可以到官网找到：[spring配置文件获取][spring]）配置文件起名为applicationContext.xml，因为大多数人都这么用。

id=“userDao”：我们将要根据id从容器中取值。  
class=“com.dz.ioc\_di.UserDaoImpl”:将对象创建出来放到id里面。

##### 测试 #####

public class Test {
        
    
    	public static void main(String[] args) {
        
    	    //加载配置文件
    		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    		//根据容器里面的id去获取到里面的对象
    		UserDao userDao = ac.getBean("userDao", UserDao.class);
    		//调用执行接口的方法
    		userDao.sayHello();
    	}
    }

结果，报出一个错误？找不到日志类？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70]  
看了一下官方文档，里面说**Logging是Spring唯一一个强制依赖的类，因为有一些人想要去看它的执行日志**。所以我们把它导入进去就OK了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70 1]  
再看结果，成功执行了方法：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70 2]

#### 实现DI ####

实现依赖注入的方法就多了，可以使用setter方法注入、可以使用构造器注入、也可以使用注解注入。

##### setter方法注入 #####

下面在实现IoC的基础上升级一小下，定义一个User实体类：

public class User {
        
    
    	private String name;
    
    	private Integer age;
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public Integer getAge() {
        
    		return age;
    	}
    
    	public void setAge(Integer age) {
        
    		this.age = age;
    	}
    
    }

同样滴，在applicationContext.xml里面进行配置：（注意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 id="user" class="com.dz.ioc_di.User">
    		<property name="name" value="dz"></property>
    		<property name="age" value="23"></property>
    	</bean>
    	
    	
    	<bean id="userDao" class="com.dz.ioc_di.UserDaoImpl">
    	
    		<property name="user" ref="user"></property>
    	</bean>
    
    </beans>

property 标签：里面配置的是类里面的属性。  
name属性：对应的是类里面属性的名称。  
value属性：就是给属性赋值了。  
ref属性：引用的是当前配置文件里面其他bean的id。

userDaoImpl变为：

package com.dz.ioc_di;
    
    public class UserDaoImpl implements UserDao {
        
    
    	User user;  //需要注入对象，相当于user=new User();
    
    	@Override
    	public void sayHello() {
        
    		System.out.println("你好！" + user.getName() + "。你是" + user.getAge() + "吗？");
    	}
    	
    	//提供setter方法，实现注入
    	public void setUser(User user) {
        
    		this.user = user;
    	}
    
    }

其他的不进行改变，看结果：  
![在这里插入图片描述][2020022510365391.jpg]

##### 构造器注入 #####

实体类、UserDao接口、测试方法不进行改变，改变UserDaoImpl实现类：

package com.dz.ioc_di;
    
    public class UserDaoImpl implements UserDao {
        
    
    	User user;
    	
    	//提供了一个构造方法注入user
    	public UserDaoImpl(User user) {
        
    		super();
    		this.user = user;
    	}
    
    	@Override
    	public void sayHello() {
        
    		System.out.println("你好！" + user.getName() + "。你是" + user.getAge() + "吗？");
    	}
    
    }

修改配置文件：

<?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="user" class="com.dz.ioc_di.User">
    		<property name="name" value="dz"></property>
    		<property name="age" value="23"></property>
    	</bean>
    	
    	
    	<bean id="userDao" class="com.dz.ioc_di.UserDaoImpl">
    		
    		<constructor-arg name="user" ref="user"></constructor-arg>
    	</bean>
    
    </beans>

执行结果：  
![在这里插入图片描述][2020022510365391.jpg]

在回过头来看一下测试类里面：

加载完Spring容器之后，使用getBean方法根据配置文件里面bean的id去调用，并返回它的接口。到这里就看出，实际上userDao的这个对象与Test类并没有什么关系。它只是通过容器拿到了一个userDao进行使用，并没有在这里面去new 它的实现类，所以他们之间就没有产生依赖的关系。  
而在UserDaoImpl里面去注入的一个User对象，也是同样的道理，从容器里面拿到了user对象并且使用它。  
这就是IoC的控制反转，对象不交给程序去new了，而是在容器里面拿。至于DI依赖注入也是在容器里面拿出来注入给一个对象。既然都是从容器里面拿出来用，那么IoC和DI是不是一样的？只是他们的说法不同罢了！

#### 我的目录结构 ####

![目录结构][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70 3]

[20200225095942879.jpg]: https://img-blog.csdnimg.cn/20200225095942879.jpg
[spring]: https://docs.spring.io/spring/docs/4.3.26.RELEASE/spring-framework-reference/htmlsingle/#beans-factory-metadata
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/202002251020412.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020022510233850.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200225102423645.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ==,size_16,color_FFFFFF,t_70
[2020022510365391.jpg]: https://img-blog.csdnimg.cn/2020022510365391.jpg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200225110814216.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rvbmd6aV95dQ==,size_16,color_FFFFFF,t_70