Spring入门（二）快速入门 - IOC/DI

晴天娃娃打烊了

已于 2022-12-06 18:15:38 修改

阅读量142

点赞数

CC 4.0 BY-SA版权

文章标签： spring java mybatis

于 2022-12-06 18:15:12 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_68893669/article/details/128207741

本文详细介绍了Spring的核心概念IOC（控制反转）和DI（依赖注入），通过代码实例展示了如何使用@Configuration和@Bean进行配置，以及如何通过@Autowired进行组件自动匹配和注入。文章还讨论了接口解耦和依赖注入的规则，强调了面向接口编程的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言
一、Spring核心之 IOC 、DI
1. IOC
IOC（Inversion of Control）：控制反转
控制反转指的是将对象的创建、管理权限从我们程序猿的手里，移交给我们Spring框架。
这时我们不再有创建、管理对象的主动权，改为被动的接收、使用，这种控制权的转换我们称之为控制反转。

主动控制：适合创建简单对象。
控制反转：适合管理创建过程复杂的对象。

2. DI
DI（Dependency Injection）：依赖注入
依赖注入指的是在程序运行期间，由外部容器（Spring）动态的将依赖对象注入到组件中。其实IOC 和 DI 其实是同一个概念。依赖注入是实现控制反转的方式。
目的：解耦
关系：has a

从概念来讲，实际太过于抽象，作为刚刚接触Spring框架的小伙伴们来说，真心不能够理解，实际我也曾经是其中的一员。但是对于操作来讲极其简便。这就是我上文说到的，刚刚学习框架，要做到不求甚解。

举个例子：
我们要完成某样有实际意义的功能，一般来讲都需要两个或两个以上的类组成，并互相之间协作完成的结果。按照传统来讲，我们的每个对象都需要管理和自己互相协作的对象（它所以依赖的对象）的引用，这将导致高度耦合。
而如果我们通过DI，这种对象的依赖关系就由Spring这个框架去进行管理，那我们就实现了松耦合。其次我们现在都是基于接口编程，也是使得其解耦低的原因所在，实现了可替换性。

在这里插入图片描述
面向接口编程（解耦 / 松耦合）

在这里插入图片描述

二、第一个Spring项目
1. IOC - 代码实现
1.1 第一种方式：@Configuration + @Bean
项目结构：

在这里插入图片描述

创建一个 Maven 项目，

导入依赖（pom.xml）

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.2.RELEASE</version>
</dependency>
</dependencies>
pom.xml 文件如图所示：

在这里插入图片描述
创建JavaBean - DemoBean

/**
* @Author lss
*/
public class DemoBean {
}

创建配置类

/**
* @Author lss
*/
@Configuration
public class Config {

@Bean
public DemoBean getDemoBean() {
return new DemoBean();
}

}

测试 DemoBean 对象是否交给Spring去管理

/**
* @Author lss
*/
public class IOCTest {
public static void main(String[] args) {
// 初始化Spring容器
ApplicationContext ac =
new AnnotationConfigApplicationContext(Config.class);
// 获取被管理的JavaBean
DemoBean bean = ac.getBean(DemoBean.class);
System.out.println(bean);
}
}
当然这里如果已经对于Juint 单元测试有些了解的情况下，我们测试也可以使用 Juint，能达到同样的效果

在 pom.xml 文件中导入 Juint 单元测试依赖

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
pom.xml 文件如图所示：

在这里插入图片描述

@Test
public void testIOC() {
// 初始化Spring容器
ApplicationContext ac =
new AnnotationConfigApplicationContext(Config.class);
// 获取被管理的JavaBean
DemoBean bean = ac.getBean(DemoBean.class);
System.out.println(bean);
}
如图所示：

在这里插入图片描述

运行输出结果为：

在这里插入图片描述
1.2 第二种方式：@Component + @ComponentScan 组件扫描
创建JavaBean - ExampleBean，类上添加 @Component 注解

/**
* @Author lss
*/
@Component
public class ExampleBean {
}

在配置类上，添加 @ComponentScan 注解

/**
* @Author tedu-sysh-lrf
*/
@Configuration
@ComponentScan("cn.cy.bean")
public class Config {

@Bean
public DemoBean getDemoBean() {
return new DemoBean();
}

}

测试在这里插入图片描述

运行输出结果为：

在这里插入图片描述
2. DI - 代码实现
DI（依赖注入）在上面讲述概念的时候已经提到过了，咱们这里再简单的剖析下：
依赖注入实际来讲分为两部分：

依赖（dependency）
实际依赖我们之前学习 maven 项目的时候就已经接触过这个名词，添加依赖 / 导入依赖…
那么什么才是我们的依赖呢？
依赖通俗意义上来讲，是指一个业务功能执行期间所需要的前提：煮米饭必须以米为前提，砍树需要以工具为前提。

<dependencies>

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

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
</dependencies>

注入
注入是指将我们需要的依赖给到 / 传递到使用者，我们称为注入。
实际我们在获取这个依赖的时候可以通过两种方式：主动获取（对象自己创建），和被动得到（对象别人创建，给只管使用即可）。而我们被动得到我们称之为注入。
以煮饭为例：米的生产过程我不需要关注，我只需要去使用即可，这个就是我们被动得到。
以砍树为例：工具的生产过程我不需要关注，我只需要去使用即可，这个就是我们被动得到。

我们这里还是以刚才的项目进行使用测试。

在这里插入图片描述
创建一个 Maven 项目，

导入依赖（pom.xml）

/**
* @Author lss
*/
public class Saw implements Serializable {

private String name = "电锯";

@Override
public String toString() {
return name;
}
}
Worker

/**
* @Author lss
*/
public class Worker implements Serializable {

private String name = "光头强";

public Saw saw;

public void work() {
System.out.println(name +"使用" + saw + "砍树");
}
}
创建配置类

/**
* @Author lss
*/
@Configuration
public class Config {

@Bean
public Saw saw() {
return new Saw();
}

@Bean
public Worker worker(Saw s) {
Worker worker = new Worker();
worker.saw = s;
return worker;
} }
创建测试类，测试，Saw对象是否被注入到 Worker对象中

/**
* @Author tlss
*/
public class DITests {

@Test
public void testDI() {
ApplicationContext ac =
new AnnotationConfigApplicationContext(Config.class);
Worker bean = ac.getBean("worker",Worker.class);
bean.work();
}

}
运行输出结果为：

在这里插入图片描述

2.1 Spring IOC组件注入时组件自动匹配规则

首先按照注入参数类型查找响应类型的Bean组件，如果没有则直接报错
如果在Spring容器中能够匹配上唯一类型的Bean组件，则进行注入成功
如果按照类型匹配到两个或两个以上的bean组件，则在查找组件ID和变量名是否匹配，如果匹配则注入成功
如果组件类型和组件ID都不能很好的匹配则报错

2.2 @Autowired

注解方式进行注入：
修改上述代码：
通过@Component将 Saw 和 Worker 对象交给Spring去管理

在这里插入图片描述

通过 @Autowired 注解，将 Saw 对象注入进去

在这里插入图片描述

在配置类上添加 @ComponentScan 注解，扫描组件

在这里插入图片描述

同样进行测试，得到相同的结果

在这里插入图片描述

一般来讲，我们开发中这种方式使用更加简便，也是我们常常使用的方式。

2.3 接口解耦

面向接口编程（解耦 / 松耦合）在这里插入图片描述

我们在上述代码上进行修改即可
添加工具接口 Tool 在这里插入图片描述

添加具体的工具-斧子 Ax ，实现工具接口Tool，并添加@Component注解在这里插入图片描述

修改具体的工具-锯 Saw ，实现工具接口Tool

在这里插入图片描述
修改 Worker类，修改注入对象，将注入对象类型改为接口类型

在这里插入图片描述

运行测试类：
这时我们的程序会报错，这个是正常的现象，或者说是我们想要出现的效果，这里我们来看下报错信息，分析下报错原因

在这里插入图片描述
这里出现了一个异常：NoUniqueBeanDefinitionException 不唯一的bean定义异常
异常错误描述：

没有一个合适的bean类型（cn.cy.bean.Tool）可用，预期有一个单独的匹配的bean，但是找到了 2个（saw，ax）
这里可以理解为，当我们想把工具注入到Worker对象中时，Spring容器找到了两个Tool工具类型，不知道应该注入哪个类型了，所以会抛出一个 NoUniqueBeanDefinitionException 异常。

解决办法：

这时，我们只需要去指定一下我们我们想要注入的类型即可

那这里需要先了解下@Autowired的注入规则

2.3 @Autowired的注入规则

首先按照类型进行注入（byType），如果没有则直接报错
如果在 Spring容器中能够匹配到唯一类型的 Bean 组件，则注入成功
如果按照类型匹配到两个或两个以上的组件，则再查找组件ID和变量名是否匹配（byType），如果匹配则注入成功
如果组件类型和组件ID都不能很好的匹配则报错

根据上面的注入规则，有以下两种解决办法：

利用组件自定义ID，当组件ID设置为 tool 时， @Autowired 注解会根据ID匹配成功
利用注解 @Qualifier(“beanID”)指定注入bean组件的ID
第一种解决办法：
将具体想要注入的组件，自己定义ID（名字），这样和要注入的名字一致，这样就可以注入进去了，但是这种方式不太常见，我们一般都是保证原生默认的beanID

在这里插入图片描述
第二种解决办法：
直接在要注入的地方添加 @Qualifier 注解，告诉 Spring容器通过指定的beanID（名字）进行注入