【Spring】Spring IOC&DI详解

【Spring】Spring IOC&DI详解
文章目录
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();
    }
}
1
2
3
4
5
6
```
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...");
    }
}
1
2
3
4
5
6
7
8
9
10
```
3. Framework.java

创建Framework又需要依赖Bottom，代码如下：
```
public class Framework {
    private Bottom bottom;
    public Framework() {
        bottom = new Bottom();
        System.out.println("framework init...");
    }
}
1
2
3
4
5
6
7
```
4. Bottom.java

创建Bottom需要依赖Tire：
```
public class Bottom {
    private Tire tire;
    public Bottom() {
        tire = new Tire();
        System.out.println("bottom init...");
    }
}
1
2
3
4
5
6
7
```
5. Tire.java
```
public class Tire {
    public Tire() {
        System.out.println("tire init... ");
    }
}
1
2
3
4
5
```
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();
    }
}
1
2
3
4
5
6
7
8
9
```
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");
    }
}
1
2
3
4
5
6
7
8
9
10
11
```
3. Framework.java
```
public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
        System.out.println("framework init...");
    }
}
1
2
3
4
5
6
7
8
```
4. Bottom.java
```
public class Bottom {
    private Tire tire;

    public Bottom(Tire tire) {
        this.tire = tire;
        System.out.println("bottom init...");
    }
}
1
2
3
4
5
6
7
8
```
5. Tire.java
```
public class Tire {
    public Tire() {
        System.out.println("tire init...");
    }
}
1
2
3
4
5
```
2.4 分析IOC开发

通过这种方法，如果要创建一个轮胎尺寸为17的车，只需要做出简单的修改，整个调用链就不需要修改了，这样就完成了代码之间的解耦，从⽽实现了更加灵活、通⽤的程序设计了。

通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下，⽽改进之后的控制权发⽣的反转，不再是使⽤⽅对象创建并控制依赖对象了，⽽是把依赖对象注⼊将当前对象中，依赖对象的控制权不再由当前类控制了。
这样的话, 即使依赖类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

2.5 IOC容器优点
上面的就是控制反转, 而控制反转容器（IOC容器）就是存对象的，使用使可以直接注入。

优点：
1. 资源集中管理: IoC容器会帮我们管理⼀些资源(对象等), 我们需要使⽤时, 只需要从IoC容器中去取就可以了。
2. 我们在创建实例的时候不需要了解其中的细节, 降低了使⽤资源双⽅的依赖程度, 也就是耦合度。
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应⽤程序, 提供了更丰富的注解。
共有两种注解类型可以实现：
1. 类注解：@Controller、@Service、@Repository、@Component、@Configuration
2. ⽅法注解：@Bean
1. @Controller（控制器存储）

使用@Controller存储Bean，代码如下：
```
@Controller // 将对象存储到 Spring 中
public class UserController {
	public void doController(){
        System.out.println("do Controller...");
    }
}
1
2
3
4
5
6
```
把某个对象交给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();
    }
}
1
2
3
4
5
6
7
8
9
10
```
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();
1
2
```
运行结果：

根据Bean的名称取Bean，就是把Bean的名称第一个单词首字符改成小写，如果名称前两个字符都是大写，则不需要。如果不遵循上面规则，则无法或者Bean。这种方法取到的Bean要进行强转。

根据类型和Bean的名称取Bean
```
        UserController userController1 = context.getBean("userController", UserController.class);
        userController1.doController();
1
2
```
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...");
    }
}
1
2
3
4
5
6
```
启动类代码，如下，取的规则和@Controller注解相同：
```
        UserService bean = context.getBean(UserService.class);
        bean.doService();
1
2
```
3. @Repository（仓库存储）

使⽤ @Repository 存储 bean 的代码如下所⽰：
```
@Repository
public class UserRepository {
    public void doRepository(){
        System.out.println("do Repository...");
    }
}
1
2
3
4
5
6
```
取的规则与上面相同。

4. @Component（组件存储）

使⽤ @Component 存储 bean 的代码如下所⽰：
```
@Component
public class UserComponent {
    public void doComponent(){
        System.out.println("do Component...");
    }
}
1
2
3
4
5
6
```
取的规则与上面相同。

5. @Configuration（配置存储）

使⽤ @Configuration 存储 bean 的代码如下所⽰：
```
@Configuration
public class UserConfiguration {
    public void doConfiguration(){
        System.out.println("do Configuration...");
    }
}
1
2
3
4
5
6
```
取的规则与上面相同。

为什么要这么多类注解？
经过上面的介绍，可以发现这些类注解的功能和使用规则都相同，那么为什么还有使用这么多种注解，这个和应⽤分层是呼应的，目的让程序员看到类注解之后，就能直接了解当前类的⽤途。
- @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
前面那些注解都是类注解，作用在类上面，但是这样存在两个问题：
1. 使⽤外部包⾥的类, 没办法添加类注解。
2. ⼀个类, 需要多个对象, ⽐如多个数据源。
这种场景, 我们就需要使⽤⽅法注解 @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;
}
1
2
3
4
5
6
7
8
9
10
```
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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
```
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);
    }
}

1
2
3
4
5
6
7
8
9
10
```
执行结果：

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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
```
直接运行：

会发现当类中多个Bean，通过类型获得Bean，会报错。那么就可以通过另一种方法获得对应的Bean——通过Bean名称。
代码如下：
```
        //当类中有多个Bean注解，不能使用类获得Bean，要使用名称，即方法名
        UserInfo userInfo = (UserInfo) context.getBean("userInfo");
        System.out.println(userInfo);
1
2
3
```
再次运行，就可以正确的取到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;
    }
1
2
3
4
5
6
7
8
9
```
```
        UserInfo userInfo = (UserInfo) context.getBean("u");
        System.out.println(userInfo);
1
2
```
可以通过设置 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也给我们提供了三种⽅式:
1. 属性注⼊(Field Injection)
2. 构造⽅法注⼊(Constructor Injection)
3. Setter 注⼊(Setter Injection)
下⾯按照实际开发中的模式，将 Service 类注⼊到 Controller 类中。
6.1 属性注入

属性注入是通过注解@Autowired实现的，下面将 Service 类注⼊到 Controller 类中。

UserService.java类：
```
@Service
public class UserService {
    public void doService(){
        System.out.println("do service...");
    }
}
1
2
3
4
5
6
```
UserController.java类：
```
@Controller
public class UserController {
//    属性DI,使用@Autowired注解
    @Autowired
    private UserService userService;
    public void doController(){
        userService.doService();
        System.out.println("do Controller...");
    }
}
1
2
3
4
5
6
7
8
9
10
```
```
@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();
}   
1
2
3
4
5
6
7
```
运行结果如下：

如果去掉注解@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...");
    }
1
2
3
4
5
6
7
8
9
```
如果类只有⼀个构造⽅法，那么 @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...");
    }
1
2
3
4
5
6
7
8
```
6.4 三种DI优缺点
1. 属性注⼊ :
  优点: 简洁，使⽤⽅便；
  缺点: 1. 只能⽤于 IoC 容器，如果是⾮ IoC 容器不可⽤，并且只有在使⽤的时候才会出现 NPE(空指针异常)； 2. 不能注⼊⼀个Final修饰的属性。
2. 构造函数注⼊:
  缺点: 注⼊多个对象时, 代码会⽐较繁琐；
  优点: 1. 可以注⼊final修饰的属性; 2. 注⼊的对象不会被修改; 3. 依赖对象在使⽤前⼀定会被完全初始化，因为依赖是在类的构造⽅法中执⾏的，⽽构造⽅法是在类加载阶段就会执⾏的⽅法; 4. 通⽤性好,构造⽅法是JDK⽀持的, 所以更换任何框架,他都是适⽤的.
3. Setter注⼊:
  缺点: 1. 不能注⼊⼀个Final修饰的属性; 2. 注⼊对象可能会被改变, 因为setter⽅法可能会被多次调⽤, 就有被修改的⻛险;
  优点: ⽅便在类实例之后, 重新对该对象进⾏配置或者注⼊。
6.5 @Autowired存在问题
如图，当一个类中存在多个Bean，使用@Autowired就会报错。因为类中有多个Bean，@Autowired并不知道是哪一个。
而Spring提供了三种方式：
1. @Primary
2. @Qualifier
3. @Resource
使⽤@Primary注解：当存在多个相同类型的Bean注⼊时，加上@Primary注解，来确定默认的实现。

使⽤@Qualifier注解：指定当前要注⼊的bean对象。在@Qualifier的value属性中，指定注⼊的bean的名称。
@Qualifier注解不能单独使⽤，必须配合@Autowired使⽤
使⽤@Resource注解：是按照bean的名称进⾏注⼊。通过name属性指定要注⼊的bean的名称。

@Autowird 与 @Resource的区别
1. @Autowired 是spring框架提供的注解，⽽@Resource是JDK提供的注解。
2. @Autowired 默认是按照类型注⼊，⽽@Resource是按照名称注。
相关阅读:
sql索引分析-插入了 a、b、c、d 四个字段作为索引，只要带上了a，那么任何排列的组合，都可以走索引。
一文了解JavaScript 中数组所有API的使用
 基于元数据的无代码平台设计与开发概述
 让我们写一个 Win32 文本编辑器吧 - 1. 简介
 双点重发布&路由策略实验
 gcov c++代码覆盖率测试工具（原理篇）
Vue简单示例——weex
淘宝/天猫获取购买到的商品订单物流 API 返回值说明
 两年经验前端带你重学前端框架必会的ajax+node.js+webpack+git等技术 Day3
Mask R-CNN
原文地址：https://blog.csdn.net/weixin_73392477/article/details/134213233

文章目录

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存在问题