【Spring】Spring IOC&DI（万字详解）
文章目录
- 1. Spring是什么？
- 2. 认识IOC
-
- 2.1 传统程序开发
-
- 1. Main.java
- 2. Car.java
- 3. Framework.java
- 4. Bottom.java
- 5. Tire.java
- 2.2 分析传统开发
- 2.3 IOC程序开发
-
- 1. Main.java
- 2. Car.java
- 3. Framework.java
- 4. Bottom.java
- 5. Tire.java
- 2.4 分析IOC开发
- 2.5 IOC容器优点
- 3. 认识DI
- 5. IOC详解
-
- 5.1 Bean存储
-
- 1. @Controller（控制器存储）
-
- 不同的getBean()参数，取Bean的一些规则
- 根据Bean名称取Bean
- 根据类型和Bean的名称取Bean
- BeanFactory
- 2. @Service（服务存储）
- 3. @Repository（仓库存储）
- 4. @Component（组件存储）
- 5. @Configuration（配置存储）
-
- 为什么要这么多类注解？
- 类注解之间的关系
- 5.2 ⽅法注解 @Bean
-
- 1. @Bean注解使用
- 2. 定义多个对象
- 3. 重命名Bean
- 4. 扫描路径
- 6. DI详解
-
- 6.1 属性注入
- 6.2 构造方法注入
- 6.3 Setter 注⼊
- 6.4 三种DI优缺点
- 6.5 @Autowired存在问题
1. Spring是什么？
想要学习IOC&DI，就要知道Spring是什么？
Spring其实就是一个开源框架，它使Java程序员开发更加方便，它支持广泛的应用场景，有着活跃且庞大的社区。
上面说的还是比较抽象，那么具体点来说：Spring是包含众多工具方法的IOC容器。
这时便引出了IOC容器的概念，先不管IOC容器，先知道容器是什么呢？
百度百科中是这样解释的：
⽣活中的⽔杯, 垃圾桶, 冰箱等等这些都是容器。
Java中List/Map就是一种数据存储的容器，TomCat就是一中Web容器。
知道Spring和容器是什么后，下面就来进入主题，学习具体的IOC。
2. 认识IOC
IoC 是Spring的核⼼思想, 例如在类上⾯添加 @RestController 和 @Controller 注解, 就是把这个对象交给Spring管理, Spring 框架启动时就会加载该类，把对象交给Spring管理, 就是IoC思想。
IOC全称Inversion of Control，翻译中文就是 控制反转，也就是说 Spring 是⼀个"控制反转"的容器。控制反转是什么？
就是控制权反转。什么的控制权发⽣了反转? 获得依赖对象的过程被反转了也就是说, 当需要某个对象时, 传统开发模式中需要⾃⼰通过 new 创建对象, 现在不需要再进⾏创建, 把创建对象的任务交给容器, 程序中只需要依赖注⼊ (Dependency Injection,DI)就可以了。
这个容器称为：IoC容器. Spring是⼀个IoC容器, 所以有时Spring 也称为Spring 容器例如：现实中招聘，解雇员工的控制权在老板手中，把权力交给HR，这就是控制反转。
2.1 传统程序开发
上面属于一些概念，也可以通过案例进一步理解IOC。
下图是一个造车的简单思路，传统程序开发，先设计轮⼦(Tire)，然后根据轮⼦的⼤⼩设计底盘(Bottom)，接着根据底盘设计⻋⾝(Framework)，最后根据⻋⾝设计好整个汽⻋(Car)。这⾥就出现了⼀个"依赖"关系：汽⻋依赖⻋⾝，⻋⾝依赖底盘，底盘依赖轮⼦.：
每个类实现功能在不同类中，Main类为程序入口：
1. Main.java
当我们要造一个没有任何要求的车时，那么要创建Car对象，代码如下：
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.run();
}
}
2. Car.java
按照上面图流程，创建Car需要依赖Framework，则代码如下：
public class Car {
private Framework framework;
public Car() {
framework = new Framework();
System.out.println("car init...");
}
public void run(){
System.out.println("car run...");
}
}
3. Framework.java
创建Framework又需要依赖Bottom，代码如下：
public class Framework {
private Bottom bottom;
public Framework() {
bottom = new Bottom();
System.out.println("framework init...");
}
}
4. Bottom.java
创建Bottom需要依赖Tire：
public class Bottom {
private Tire tire;
public Bottom() {
tire = new Tire();
System.out.println("bottom init...");
}
}
5. Tire.java
public class Tire {
public Tire() {
System.out.println("tire init... ");
}
}
2.2 分析传统开发
按照上面的设计，可以成功造出一个没有任何要求的车。但是它的维护性却很低。例如，想继续创建一个轮胎尺寸为17的车，就需要对代码进行修改：
修改Tire.java：
修改后，其他调用程序也会报错，还需要继续修改：
通过上面修改代码的量，可以看出以上程序的问题是：当最底层代码改动之后，整个调⽤链上的所有代码都需要修改。
修改一处代码，其他的代码也需要修改，这叫做耦合。
可以看出上面设计耦合程度是非常高的，如软件设计的原则，是高内聚低耦合。⾼内聚指的是：⼀个模块中各个元素之间的联系的紧密程度，如果各个元素(语句、程序段)之间的联系程度越⾼，则内聚性越⾼，即 “⾼内聚”。
低耦合指的是：软件中各个层、模块之间的依赖关联程序越低越好。修改⼀处代码, 其他模块的代码改动越少越好。上面的设计，很明显不符合要求，需要修改方案，这时就可以使用IOC思想，进行反转。
2.3 IOC程序开发
先设计汽⻋的⼤概样⼦，然后根据汽⻋的样⼦来设计⻋⾝，根据⻋⾝来设计底盘，最后根据底盘来设计轮⼦. 这时候，依赖关系就倒置过来了：轮⼦依赖底盘， 底盘依赖⻋⾝，⻋⾝依赖汽⻋。
各个类如下：
1. Main.java
基于以上思路，我们把调⽤汽⻋的程序⽰例改造⼀下，把创建⼦类的⽅式，改为注⼊传递的⽅式.具体实现代码如下：
public class Main {
public static void main(String[] args) {
Tire tire = new Tire();
Bottom bottom = new Bottom(tire);
Framework framework = new Framework(bottom);
Car car = new Car(framework);
car.run();
}
}
2. Car.java
public class Car {
private Framework framework;
public Car(Framework framework) {
this.framework = framework;
System.out.println("car init...");
}
public void run(){
System.out.println("car run");
}
}
3. Framework.java
public class Framework {
private Bottom bottom;
public Framework(Bottom bottom) {
this.bottom = bottom;
System.out.println("framework init...");
}
}
4. Bottom.java
public class Bottom {
private Tire tire;
public Bottom(Tire tire) {
this.tire = tire;
System.out.println("bottom init...");
}
}
5. Tire.java
public class Tire {
public Tire() {
System.out.println("tire init...");
}
}
2.4 分析IOC开发
通过这种方法，如果要创建一个轮胎尺寸为17的车，只需要做出简单的修改，整个调用链就不需要修改了，这样就完成了代码之间的解耦，从⽽实现了更加灵活、通⽤的程序设计了。
通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下，⽽改进之后的控制权发⽣的反转，不再是使⽤⽅对象创建并控制依赖对象了，⽽是把依赖对象注⼊将当前对象中，依赖对象的控制权不再由当前类控制了。
这样的话, 即使依赖类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。
2.5 IOC容器优点
上面的就是控制反转, 而控制反转容器（IOC容器）就是存对象的，使用使可以直接注入。
优点：
- 资源集中管理: IoC容器会帮我们管理⼀些资源(对象等), 我们需要使⽤时, 只需要从IoC容器中去取就可以了。
- 我们在创建实例的时候不需要了解其中的细节, 降低了使⽤资源双⽅的依赖程度, 也就是耦合度。
3. 认识DI
DI: Dependency Injection(依赖注⼊)，容器在运⾏期间, 动态的为应⽤程序提供运⾏时所依赖的资源，称之为依赖注⼊。
上述代码中, 是通过构造函数的⽅式, 把依赖对象注⼊到需要使⽤的对象中的。
IoC 是⼀种思想，也是"目标", 而思想只是⼀种指导原则，最终还是要有可行的落地⽅案，而 DI 就属于具体的实现。所以也可以说, DI 是IoC的⼀种实现。
5. IOC详解
上面看完后会对IOC和DI有初步的了解，接下来就具体学习Spring IOC和DI的实现。
既然 Spring 是⼀个 IoC（控制反转）容器，作为容器, 那么它就具备两个最基础的功能：
- 存
- 取
Spring 容器 管理的主要是对象, 这些对象, 我们称之为"Bean"。 我们把这些对象交由Spring管理, 由Spring来负责对象的创建和销毁。 我们程序只需要告诉Spring, 哪些需要存, 以及如何从Spring中取出对象。
下面就来学习Bean的存储。
5.1 Bean存储
把某个对象交给IOC容器管理，需要在类上添加⼀个注解，⽽Spring框架为了更好的服务web应⽤程序, 提供了更丰富的注解。
共有两种注解类型可以实现：
- 类注解：@Controller、@Service、@Repository、@Component、@Configuration
- ⽅法注解：@Bean
1. @Controller（控制器存储）
使用@Controller存储Bean，代码如下：
@Controller // 将对象存储到 Spring 中
public class UserController {
public void doController(){
System.out.println("do Controller...");
}
}
把某个对象交给IOC容器管理，需要在类上添加⼀个注解，如何观察这个对象已经存在Spring容器当中了呢？接下来我们学习如何从Spring容器中获取对象。
启动类中代码：
public class IocDemoApplication {
public static void main(String[] args) {
//Spring上下文
ApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);
//根据类获得Bean
UserController bean = context.getBean(UserController.class);
bean.doController();
}
}
ApplicationContext 翻译过来就是: Spring 上下⽂。因为对象都交给Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到 Spring 的上下⽂。
再使用getBean方法，就可以获得这个Bean，就可以调用这个Bean中的方法。
运行结果：
如果去掉@Controller注解，那么就会报错了，无法获得Bean。
不同的getBean()参数，取Bean的一些规则
getBean方法源码，如上图，常用的就是红圈中的三种，1中的取Bean就是第三种。
通过类型的方式取Bean。
如果再次取这个类型的Bean，它们是否为同一个？只需要代码验证结果即可。
修改代码如下：
运行结果：
根据运行结果，得出结论： 同一个类型的取两次相同的Bean，两个Bean地址相同，则Bean为同一个。
根据Bean名称取Bean
UserController userController = (UserController) context.getBean("userController");
userController.doController();
运行结果：
根据Bean的名称取Bean，就是把Bean的名称第一个单词首字符改成小写，如果名称前两个字符都是大写，则不需要。如果不遵循上面规则，则无法或者Bean。这种方法取到的Bean要进行强转。
根据类型和Bean的名称取Bean
UserController userController1 = context.getBean("userController", UserController.class);
userController1.doController();
Bean的名称规则与上面的规则相同，但是不需要进行强转。
BeanFactory
获取bean对象, 是⽗类BeanFactory提供的功能
ApplicationContext VS BeanFactory（常⻅⾯试题）
- 继承关系和功能⽅⾯来说：Spring 容器有两个顶级的接⼝：BeanFactory 和ApplicationContext。其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ApplicationContext 属于 BeanFactory
的⼦类，它除了继承了BeanFactory
的所有功能之外，它还拥有独特的特性，还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持。- 从性能⽅⾯来说：ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，⽽BeanFactory 是需要那个才去加载那个，因此更加轻量. (空间换时间)。
2. @Service（服务存储）
使⽤ @Service 存储 bean 的代码如下所⽰：
@Service
public class UserService {
public void doService(){
System.out.println("do service...");
}
}
启动类代码，如下，取的规则和@Controller注解相同：
UserService bean = context.getBean(UserService.class);
bean.doService();
3. @Repository（仓库存储）
使⽤ @Repository 存储 bean 的代码如下所⽰：
@Repository
public class UserRepository {
public void doRepository(){
System.out.println("do Repository...");
}
}
取的规则与上面相同。
4. @Component（组件存储）
使⽤ @Component 存储 bean 的代码如下所⽰：
@Component
public class UserComponent {
public void doComponent(){
System.out.println("do Component...");
}
}
取的规则与上面相同。
5. @Configuration（配置存储）
使⽤ @Configuration 存储 bean 的代码如下所⽰：
@Configuration
public class UserConfiguration {
public void doConfiguration(){
System.out.println("do Configuration...");
}
}
取的规则与上面相同。
为什么要这么多类注解？
经过上面的介绍，可以发现这些类注解的功能和使用规则都相同，那么为什么还有使用这么多种注解，这个和应⽤分层是呼应的，目的让程序员看到类注解之后，就能直接了解当前类的⽤途。
- @Controller：控制层, 接收请求, 对请求进⾏处理, 并进⾏响应.
- @Servie：业务逻辑层, 处理具体的业务逻辑.
- @Repository：数据访问层，也称为持久层. 负责数据访问操作 •
- @Configuration：配置层. 处理项⽬中的⼀些配置信息
程序的应用分层，调用流程如下：
而@Component注解去哪了呢？下面就来介绍。
类注解之间的关系
查看 @Controller / @Service / @Repository / @Configuration 等注解的源码会发现，它们四个源码相同，并且都有@Component注解：
其实这些注解⾥⾯都有⼀个注解 @Component，说明它们本⾝就是属于 @Component 的“⼦类”。@Component 是⼀个元注解，也就是说可以注解其他类注解，如 @Controller , @Service ,@Repository 等. 这些注解被称为 @Component 的衍⽣注解。
@Controller , @Service 和 @Repository ⽤于更具体的⽤例(分别在控制层, 业务逻辑层, 持久化层), 在开发过程中, 如果你要在业务逻辑层使⽤ @Component 或@Service，显然@Service是更好的选择。
这是一种规范，而且可以使程序员更好的知道该注解下的代码是干什么的。
5.2 ⽅法注解 @Bean
前面那些注解都是类注解，作用在类上面，但是这样存在两个问题：
- 使⽤外部包⾥的类, 没办法添加类注解。
- ⼀个类, 需要多个对象, ⽐如多个数据源。
这种场景, 我们就需要使⽤⽅法注解 @Bean。
1. @Bean注解使用
@Bean注解需要搭配前面的类注解使用。
项目启动时，默认扫描的范围是SpringBoot启动类所在包及其⼦包，如果类前不加注解，类中注解无法被扫描到。
下面就具体，代码如下：
UserInfo.java类：
package com.example.iocdemo.configuration;
import lombok.Data;
@Data
public class UserInfo {
private int id;
private String name;
private int age;
}
BeanConfiguration.java类：
@Configuration //类注解
public class BeanConfiguration {
//方法注解
@Bean
public UserInfo userInfo(String name){
UserInfo userInfo = new UserInfo();
userInfo.setId(1);
userInfo.setName("zhangsan");
userInfo.setAge(18);
return userInfo;
}
}
IocDemoApplication.java类：
@SpringBootApplication
public class IocDemoApplication {
public static void main(String[] args) {
ApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);
UserInfo bean = context.getBean(UserInfo.class);
System.out.println(bean);
}
}
执行结果：
2. 定义多个对象
上面一个一个类中只有一个Bean，如果类中定义多个Bean呢？
是否还可以通过类型取Bean？
@Bean 可以针对同⼀个类, 定义多个对象。
在BeanConfiguration.java类中添加一个新Bean，其他代码不能变，代码如下：
@Bean
public UserInfo userInfo(){
UserInfo userInfo = new UserInfo();
userInfo.setId(1);
userInfo.setName("zhangsan");
userInfo.setAge(18);
return userInfo;
}
//新添Bean
@Bean
public UserInfo userInfo1(){
UserInfo userInfo = new UserInfo();
userInfo.setId(2);
userInfo.setName("lisi");
userInfo.setAge(19);
return userInfo;
}
直接运行：
会发现当类中多个Bean，通过类型获得Bean，会报错。那么就可以通过另一种方法获得对应的Bean——通过Bean名称。
代码如下：
//当类中有多个Bean注解，不能使用类获得Bean，要使用名称，即方法名
UserInfo userInfo = (UserInfo) context.getBean("userInfo");
System.out.println(userInfo);
再次运行，就可以正确的取到Bean。
**注意名称要一致。**当然，也可以不一致，需要对代码进行修改，即重命名Bean。
3. 重命名Bean
//重命名Bean
@Bean(name = {"u","userInfo"})
public UserInfo userInfo(){
UserInfo userInfo = new UserInfo();
userInfo.setId(1);
userInfo.setName("zhangsan");
userInfo.setAge(18);
return userInfo;
}
UserInfo userInfo = (UserInfo) context.getBean("u");
System.out.println(userInfo);
可以通过设置 name 属性给 Bean 对象进⾏重命名操作，代码如上，此刻通过u就可以获得UserInfo对象。
注解@Bean后代码也可以进行简写：
@Bean({"u","userInfo"})//简写
当类中Bean只有一个，还可以进一步简写：
@Bean("u")//简写
4. 扫描路径
当项目启动时，Bean想生效，就需要被Spring扫描到，但前面四个类注解一定会被扫描到吗？
其实不一定，前面启动类和那些类都在一个包中，如下：
那么，如果把启动类放在一个空包中，那些注解还能被扫描到吗？
运行前面代码：
代码就会报错，找不到Bean了，这就是因为Spring默认扫描的范围是SpringBoot启动类所在包及其⼦包。
所以启动类一定要放到需要扫描的路径中。
6. DI详解
DI是依赖注入，依赖注⼊是⼀个过程，是指IoC容器在创建Bean时, 去提供运⾏时所依赖的资源，⽽资源指的就是对象。
简单来说, 就是把对象取出来放到某个类的属性中。
可以把IOC看成一种思想，DI是IOC的一种实现方式。
关于依赖注⼊, Spring也给我们提供了三种⽅式:
- 属性注⼊(Field Injection)
- 构造⽅法注⼊(Constructor Injection)
- Setter 注⼊(Setter Injection)
下⾯按照实际开发中的模式，将 Service 类注⼊到 Controller 类中。
6.1 属性注入
属性注入是通过注解@Autowired实现的，下面将 Service 类注⼊到 Controller 类中。
UserService.java类：
@Service
public class UserService {
public void doService(){
System.out.println("do service...");
}
}
UserController.java类：
@Controller
public class UserController {
// 属性DI,使用@Autowired注解
@Autowired
private UserService userService;
public void doController(){
userService.doService();
System.out.println("do Controller...");
}
}
@SpringBootApplication
public class IocDemoApplication {
public static void main(String[] args) {
ApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);
UserController bean = context.getBean(UserController.class);
bean.doController();
}
运行结果如下：
如果去掉注解@Autowired，就会报错。
6.2 构造方法注入
修改上面UserController.java代码：
private UserService userService;
@Autowired
public UserController(UserService userService) {
this.userService = userService;
}
public void doController(){
userService.doService();
System.out.println("do Controller...");
}
如果类只有⼀个构造⽅法，那么 @Autowired 注解可以省略；如果类中有多个构造⽅法，
那么需要添加上 @Autowired 来明确指定到底使⽤哪个构造⽅法。
6.3 Setter 注⼊
Setter 注⼊和属性的 Setter ⽅法实现类似，只不过在设置 set ⽅法的时候需要加上 @Autowired 注解。
如下代码所⽰：
@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}
public void doController(){
userService.doService();
System.out.println("do Controller...");
}
6.4 三种DI优缺点
- 属性注⼊ :
优点: 简洁，使⽤⽅便；
缺点: 1. 只能⽤于 IoC 容器，如果是⾮ IoC 容器不可⽤，并且只有在使⽤的时候才会出现 NPE(空指针异常)； 2. 不能注⼊⼀个Final修饰的属性 。- 构造函数注⼊:
缺点: 注⼊多个对象时, 代码会⽐较繁琐；
优点: 1. 可以注⼊final修饰的属性; 2. 注⼊的对象不会被修改; 3. 依赖对象在使⽤前⼀定会被完全初始化，因为依赖是在类的构造⽅法中执⾏的，⽽构造⽅ 法是在类加载阶段就会执⾏的⽅法; 4. 通⽤性好,构造⽅法是JDK⽀持的, 所以更换任何框架,他都是适⽤的.- Setter注⼊:
缺点: 1. 不能注⼊⼀个Final修饰的属性; 2. 注⼊对象可能会被改变, 因为setter⽅法可能会被多次调⽤, 就有被修改的⻛险;
优点: ⽅便在类实例之后, 重新对该对象进⾏配置或者注⼊。
6.5 @Autowired存在问题
如图，当一个类中存在多个Bean，使用@Autowired就会报错。因为类中有多个Bean，@Autowired并不知道是哪一个。
而Spring提供了三种方式：
- @Primary
- @Qualifier
- @Resource
使⽤@Primary注解：当存在多个相同类型的Bean注⼊时，加上@Primary注解，来确定默认的实现。
使⽤@Qualifier注解：指定当前要注⼊的bean对象。 在@Qualifier的value属性中，指定注⼊的bean的名称。
@Qualifier注解不能单独使⽤，必须配合@Autowired使⽤
使⽤@Resource注解：是按照bean的名称进⾏注⼊。通过name属性指定要注⼊的bean的名称。
@Autowird 与 @Resource的区别
- @Autowired 是spring框架提供的注解，⽽@Resource是JDK提供的注解。
- @Autowired 默认是按照类型注⼊，⽽@Resource是按照名称注。
