【Spring】Spring IOCDI（万字详解）

文章目录

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是按照名称注。