【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类为程序入口:
【Spring】Spring IOC&DI(万字详解)_第1张图片

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:
【Spring】Spring IOC&DI(万字详解)_第2张图片
修改后,其他调用程序也会报错,还需要继续修改:
【Spring】Spring IOC&DI(万字详解)_第3张图片
【Spring】Spring IOC&DI(万字详解)_第4张图片
【Spring】Spring IOC&DI(万字详解)_第5张图片
【Spring】Spring IOC&DI(万字详解)_第6张图片
通过上面修改代码的量,可以看出以上程序的问题是:当最底层代码改动之后,整个调⽤链上的所有代码都需要修改。
修改一处代码,其他的代码也需要修改,这叫做耦合
可以看出上面设计耦合程度是非常高的,如软件设计的原则,是高内聚低耦合

⾼内聚指的是:⼀个模块中各个元素之间的联系的紧密程度,如果各个元素(语句、程序段)之间的联系程度越⾼,则内聚性越⾼,即 “⾼内聚”。
低耦合指的是:软件中各个层、模块之间的依赖关联程序越低越好。修改⼀处代码, 其他模块的代码改动越少越好。

上面的设计,很明显不符合要求,需要修改方案,这时就可以使用IOC思想,进行反转。

2.3 IOC程序开发

先设计汽⻋的⼤概样⼦,然后根据汽⻋的样⼦来设计⻋⾝,根据⻋⾝来设计底盘,最后根据底盘来设计轮⼦. 这时候,依赖关系就倒置过来了:轮⼦依赖底盘, 底盘依赖⻋⾝,⻋⾝依赖汽⻋。【Spring】Spring IOC&DI(万字详解)_第7张图片
各个类如下:
【Spring】Spring IOC&DI(万字详解)_第8张图片

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的车,只需要做出简单的修改,整个调用链就不需要修改了,这样就完成了代码之间的解耦,从⽽实现了更加灵活、通⽤的程序设计了。
【Spring】Spring IOC&DI(万字详解)_第9张图片
【Spring】Spring IOC&DI(万字详解)_第10张图片
通⽤程序的实现代码,类的创建顺序是反的,传统代码是 Car 控制并创建了Framework,Framework 创建并创建了 Bottom,依次往下,⽽改进之后的控制权发⽣的反转,不再是使⽤⽅对象创建并控制依赖对象了,⽽是把依赖对象注⼊将当前对象中,依赖对象的控制权不再由当前类控制了。
这样的话, 即使依赖类发⽣任何改变,当前类都是不受影响的,这就是典型的控制反转,也就是 IoC 的实现思想。

2.5 IOC容器优点

上面的就是控制反转, 而控制反转容器(IOC容器)就是存对象的,使用使可以直接注入。
【Spring】Spring IOC&DI(万字详解)_第11张图片
优点:

  1. 资源集中管理: IoC容器会帮我们管理⼀些资源(对象等), 我们需要使⽤时, 只需要从IoC容器中去取就可以了。
  2. 我们在创建实例的时候不需要了解其中的细节, 降低了使⽤资源双⽅的依赖程度, 也就是耦合度。

3. 认识DI

DI: Dependency Injection(依赖注⼊),容器在运⾏期间, 动态的为应⽤程序提供运⾏时所依赖的资源,称之为依赖注⼊。
上述代码中, 是通过构造函数的⽅式, 把依赖对象注⼊到需要使⽤的对象中的。
【Spring】Spring IOC&DI(万字详解)_第12张图片
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...");
    }
}

把某个对象交给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的一些规则

【Spring】Spring IOC&DI(万字详解)_第13张图片
getBean方法源码,如上图,常用的就是红圈中的三种,1中的取Bean就是第三种。
通过类型的方式取Bean。
如果再次取这个类型的Bean,它们是否为同一个?只需要代码验证结果即可。
修改代码如下: 【Spring】Spring IOC&DI(万字详解)_第14张图片
运行结果:
【Spring】Spring IOC&DI(万字详解)_第15张图片
根据运行结果,得出结论: 同一个类型的取两次相同的Bean,两个Bean地址相同,则Bean为同一个。

根据Bean名称取Bean
        UserController userController = (UserController) context.getBean("userController");
        userController.doController();

运行结果:
【Spring】Spring IOC&DI(万字详解)_第16张图片
根据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:配置层. 处理项⽬中的⼀些配置信息

程序的应用分层,调用流程如下:
【Spring】Spring IOC&DI(万字详解)_第17张图片
而@Component注解去哪了呢?下面就来介绍。

类注解之间的关系

查看 @Controller / @Service / @Repository / @Configuration 等注解的源码会发现,它们四个源码相同,并且都有@Component注解:
【Spring】Spring IOC&DI(万字详解)_第18张图片
其实这些注解⾥⾯都有⼀个注解 @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;
}

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扫描到,但前面四个类注解一定会被扫描到吗?
其实不一定,前面启动类和那些类都在一个包中,如下:
【Spring】Spring IOC&DI(万字详解)_第19张图片
那么,如果把启动类放在一个空包中,那些注解还能被扫描到吗?
【Spring】Spring IOC&DI(万字详解)_第20张图片
运行前面代码:
【Spring】Spring IOC&DI(万字详解)_第21张图片
代码就会报错,找不到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...");
    }
}

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. 属性注⼊ :
    优点: 简洁,使⽤⽅便;
    缺点: 1. 只能⽤于 IoC 容器,如果是⾮ IoC 容器不可⽤,并且只有在使⽤的时候才会出现 NPE(空指针异常); 2. 不能注⼊⼀个Final修饰的属性 。
  2. 构造函数注⼊:
    缺点: 注⼊多个对象时, 代码会⽐较繁琐;
    优点: 1. 可以注⼊final修饰的属性; 2. 注⼊的对象不会被修改; 3. 依赖对象在使⽤前⼀定会被完全初始化,因为依赖是在类的构造⽅法中执⾏的,⽽构造⽅ 法是在类加载阶段就会执⾏的⽅法; 4. 通⽤性好,构造⽅法是JDK⽀持的, 所以更换任何框架,他都是适⽤的.
  3. Setter注⼊:
    缺点: 1. 不能注⼊⼀个Final修饰的属性; 2. 注⼊对象可能会被改变, 因为setter⽅法可能会被多次调⽤, 就有被修改的⻛险;
    优点: ⽅便在类实例之后, 重新对该对象进⾏配置或者注⼊。

6.5 @Autowired存在问题

【Spring】Spring IOC&DI(万字详解)_第22张图片
如图,当一个类中存在多个Bean,使用@Autowired就会报错。因为类中有多个Bean,@Autowired并不知道是哪一个。
而Spring提供了三种方式:

  1. @Primary
  2. @Qualifier
  3. @Resource

使⽤@Primary注解:当存在多个相同类型的Bean注⼊时,加上@Primary注解,来确定默认的实现。
【Spring】Spring IOC&DI(万字详解)_第23张图片
使⽤@Qualifier注解:指定当前要注⼊的bean对象。 在@Qualifier的value属性中,指定注⼊的bean的名称。
@Qualifier注解不能单独使⽤,必须配合@Autowired使⽤【Spring】Spring IOC&DI(万字详解)_第24张图片
使⽤@Resource注解:是按照bean的名称进⾏注⼊。通过name属性指定要注⼊的bean的名称。
【Spring】Spring IOC&DI(万字详解)_第25张图片
@Autowird 与 @Resource的区别

  1. @Autowired 是spring框架提供的注解,⽽@Resource是JDK提供的注解。
  2. @Autowired 默认是按照类型注⼊,⽽@Resource是按照名称注。

你可能感兴趣的:(Spring,spring,IOC,DI)