【Java EE】Spring IOC&DI

我焦虑的编程日记2024-07-02 11:14

Spring IOC & DI

文章目录

  • [Spring IOC & DI](#Spring IOC & DI)
    • 一、Spring是什么？
    • 二、IOC(控制反转)
      • [2.1 通俗理解](#2.1 通俗理解)
      • [2.2 造汽车的例子理解IOC](#2.2 造汽车的例子理解IOC)
      • [2.3 IOC详解](#2.3 IOC详解)
        • [1. 获取Bean](#1. 获取Bean)
        • [2. 方法注解------@Bean](#2. 方法注解——@Bean)
          • [1. 应用场景：](#1. 应用场景：)
          • [2. 应用方法：](#2. 应用方法：)
          • [3. 注意要点：](#3. 注意要点：)
      • 特别注意:
    • 四、DI
      • [4.1 属性注入](#4.1 属性注入)
      • [4.2 构造方法注入](#4.2 构造方法注入)
      • [4.3 在setter方法注入](#4.3 在setter方法注入)
      • 4.4三种注⼊优缺点分析
      • [4.5 @Autowired出现多个同类型Bean的情况](#4.5 @Autowired出现多个同类型Bean的情况)
        • 原因：
        • 解决方法：
          • [1. 使用 `@Primary` 指定默认匹配的项目](#1. 使用 @Primary 指定默认匹配的项目)
          • [2. 使用`autowireCandidate = false`去除默认匹配](#2. 使用autowireCandidate = false去除默认匹配)
          • [3. 使用 `@Resource(name="**")`对于特定名称的Bean进行注入](#3. 使用 @Resource(name="**")对于特定名称的Bean进行注入)
      • [4.6 @Autowired和@Rescource的区别](#4.6 @Autowired和@Rescource的区别)

一、Spring是什么？

Spring是一个开发的框架，包含了很多的依赖，比如Spring MVC， Spring Boot等，这些让我们开发变得容易，可以说，Spring是一个包含很多工具方法的容器。

二、IOC(控制反转)

2.1 通俗理解

Inversio of Control ，也就是说，Spring是一个 "控制反转" 的容器。

控制反转就是让一个事物的控制权交由其他人。

2.2 造汽车的例子理解IOC

造汽车的流程：

代码：
汽车类：

java 复制代码 
package com.example.springioc.v1;

public class Car {
    // 汽车依赖于框架
    private Frame frame;

    public Car() {
        frame = new Frame();
        System.out.println("汽车安装框架中...");
    }
}

框架类：

java 复制代码 
package com.example.springioc.v1;

public class Frame {
    // 框架依赖于底盘
    private Bottom bottom;
    public Frame() {
        bottom = new Bottom();
        System.out.println("框架安装底盘中...");
    }
}

底盘类：

java 复制代码 
package com.example.springioc.v1;

import jdk.jfr.Frequency;

public class Bottom {
    // 底盘依赖于轮胎
    private Tire tire;
    // 有了尺寸的需求，需要进行传参
    public Bottom(int size) {
        tire = new Tire(size);
        System.out.println("底盘安装轮胎中...");
    }
}

轮胎类：

java 复制代码 
package com.example.springioc.v1;

public class Tire {
    public Tire() {
        System.out.println("打造默认尺寸轮胎中...");
    }
}

运行结果：

这种代码架构，每个类的控制权都在调用他的那一方中，调用的一方创造了怎样的他，那他就是怎样的。

如果想要更换任意尺寸的轮胎，那就需要传递一个size参数，此时要依次对于代码做修改。

首先是轮胎类，需要增加 size 属性，但是这样最上层的 Car 类并不能够选择自己想要的尺寸，仍然需要对于控制着 Tire 的Bottom进行添加参数以便Frame能够添加参数，这样依赖，Frame也得添加size参数，Car 也需要。

最终代码（对于每一级都添加了size参数）：

汽车类：

java 复制代码 
package com.example.springioc.v1;

public class Car {
    // 汽车依赖于框架
    private Frame frame;

    // 对于汽车类添加了size参数构造
    public Car(int size) {
        frame = new Frame(size);
        System.out.println("汽车安装框架中...");
    }
}

框架类：

java 复制代码 
package com.example.springioc.v1;

public class Frame {
    // 框架依赖于底盘
    private Bottom bottom;
    public Frame(int size) {
        bottom = new Bottom(size);
        System.out.println("框架安装底盘中...");
    }
}

底盘类：

java 复制代码 
package com.example.springioc.v1;

import jdk.jfr.Frequency;

public class Bottom {
    // 底盘依赖于轮胎
    private Tire tire;
    public Bottom(int size) {
        tire = new Tire(size);
        System.out.println("底盘安装轮胎中...");
    }
}

轮胎类：

java 复制代码 
package com.example.springioc.v1;

public class Tire {
    // 轮胎的大小
    private Integer size;

    public Tire() {
        System.out.println("打造默认尺寸轮胎中...");
    }
    public Tire(int size) {
        System.out.println("打造"+size+"号的轮胎中...");
    }
}

显而易见，这样的代码架构维护起来非常臃肿：

每一下级的控制权都由上一级保管，如果对于下一级的需求发生了变化，那么这就需要改动所有的类。（比如：如果现在用户需要对于轮胎的轮毂进行制定，那就还需要给Tire的构造函数增添一个 style 属性，如果还有颜色等的需求，那就还得一直加；只加Tire一个类的还好，因为每一上级都直间或者间接依赖于这个Tire，每一个类都需要进行修改，耦合度非常高。）

所以就需要 "控制反转" 思想，将整个控制反转：

修改后的代码：

java 复制代码 
package com.example.springioc.v2;

import com.example.springioc.v1.Frame;

public class Main {
    static class Tire {
        int size;

        public Tire(int size) {
            this.size = size;
            System.out.println("打造"+size+"号轮胎...");
        }
    }
    static class Bottom{
        Tire tire;

        public Bottom(Tire tire) {
            this.tire = tire;
            System.out.println("打造底盘...");
        }
    }
    static class Framework {
        Bottom bottom;

        public Framework(Bottom bottom) {
            this.bottom = bottom;
            System.out.println("打造框架...");
        }
    }

    static class Car {
        Framework framework;

        public Car(Framework framework) {
            this.framework = framework;
            System.out.println("打造汽车...");
        }
    }

    public static void main(String[] args) {
        Tire tire = new Tire(1);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
    }
}

这样一来，如果用户对于轮胎有新的需求，那也只需要修改轮胎这一个类，完成了整个代码的解耦。

也就是说，我们将控制权转让给了Tire自己，Tire的上级类不再享有控制权，传来什么Tire，就用什么。

2.3 IOC详解

控制反转之后，对象进入Spring容器就会变成Bean，也就是说，Spring中的对象都叫做Bean。

1. 获取Bean
  1. 注册Bean：使用五大注解，让Spring Boot能够发现@Bean
  2. 主要方法：使用 context 的 getBean() 进行获取
  3. 得到的Bean就相当于从Spring Boot中取到了这个对象
2. 方法注解------@Bean
1. 应用场景：

  1. 当对于外部类的方法，无法通过修改源码进行注册Bean，所以可以使用Spring的@Import注解来导入一个配置类，在这个配置类中你可以使用@Bean注解来声明这个外部类作为一个Bean，并对其进行配置。

  2. 如果一个类中需要多个实例，可以使用@Bean对于实例进行别名命名（value和name），以示区分。

2. 应用方法：
java 复制代码 
		/**
         * 使用@Bean的演示
         */
        // 使用类，获得整个类的Bean
        User bean1 = context.getBean(User.class);
        System.out.println(bean1);
        // li4是使用name属性定的别名
        User bean2 = (User) context.getBean("li4");
        System.out.println(bean2);
        // user3是方法的名字
        User bean3 = (User) context.getBean("user3");
        System.out.println(bean3);
3. 注意要点：
  1. @Bean是方法级的注解
  2. 需要配合类注解进行使用
  3. 使用value和name属性可以命名别名
  4. Bean的名字就是方法的名字
  5. autowireCandidate 可以消除：当有多个能够匹配的实例的时候，排除这个实例

特别注意:

@ComponentScan 可以定义Spring的扫描路径。

使用方法：

java 复制代码 
@ComponentScan({"com.example.springioc.bean_test"})

直接在()中使用{}定义路径。

四、DI

DI就是依赖注入。

4.1 属性注入

使用 @Autowired 注入。

使用方法
java 复制代码 
package com.example.springioc.di_test.controller;

import com.example.springioc.di_test.service.TireSeervice;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class TireController {
    @Autowired
    TireSeervice tireSeervice;
    public void doTire() {
        System.out.println("成功调用轮胎控制器...");
        tireSeervice.doTire();
    }
}

使用 @Autowired 将service属性注入到控制器中。

java 复制代码 
package com.example.springioc.di_test.service;

import com.example.springioc.di_test.model.Tire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TireService {
    @Autowired
    Tire tire;
    public void doTire() {
        tire.setSize(12);
        tire.setColor("红");
        System.out.println("制作"+tire.getSize()+"号"+tire.getColor()+"色的轮胎");
    }
}

同时在服务类中将需要的轮胎对象注入。

4.2 构造方法注入

将构造方法使用 @Autowired 注入。

使用方法
java 复制代码 
package com.example.springioc.di_test2.service;

import com.example.springioc.di_test2.model.Tire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TireService {
    Tire tire;

    @Autowired //构造函数上注入
    public TireService(Tire tire) {
        this.tire = tire;
        tire.setSize(12);
        tire.setColor("红");
    }

    public void doTire() {
        System.out.println("制作"+tire.getSize()+"号"+tire.getColor()+"色的轮胎");
    }

}

在服务类的构造方法中使用@Autowired 中注入。

java 复制代码 
package com.example.springioc.di_test2.controller;

import com.example.springioc.di_test2.service.TireService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class TireController {
    TireService tireService;

    @Autowired //构造函数上注入
    public TireController(TireService tireService) {
        this.tireService = tireService;
    }

    public void doTire() {
        System.out.println("成功调用轮胎控制器...");
        tireService.doTire();
    }

}

在控制类的构造方法使用@Autowired 中注入。

4.3 在setter方法注入

将构造方法使用 @Autowired 注入。

使用方法
java 复制代码 
package com.example.springioc.di_test3.service;

import com.example.springioc.di_test3.model.Tire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TireService {
    Tire tire;

    @Autowired //set方法上注入
    public void setTire(Tire tire) {
        this.tire = tire;
        tire.setSize(1);
        tire.setColor("green");
    }


    public void doTire() {
        System.out.println("制作"+tire.getSize()+"号"+tire.getColor()+"色的轮胎");
    }

}

在服务类的setter方法中使用@Autowired 中注入。

java 复制代码 
package com.example.springioc.di_test3.controller;

import com.example.springioc.di_test3.model.Tire;
import com.example.springioc.di_test3.service.TireService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class TireController {
    private TireService tireService;

    @Autowired //set方法上注入
    public void setTireService(TireService tireService) {
        this.tireService = tireService;
    }

    public void doTire() {
        System.out.println("成功调用轮胎控制器...");
        tireService.doTire();
    }

}

在控制类的setter方法使用@Autowired 中注入。

4.4三种注⼊优缺点分析

  1. 属性注⼊

    ◦ 优点: 简洁，使⽤⽅便；

    ◦ 缺点:

    ▪ 只能⽤于 IoC 容器，如果是⾮ IoC 容器不可⽤，并且只有在使⽤的时候才会出现 NPE（空指

    针异常）

    ▪ 不能注⼊⼀个Final修饰的属性

  2. 构造函数注⼊(Spring 4.X推荐)

    ◦ 优点:

    ▪ 可以注⼊final修饰的属性

    ▪ 注⼊的对象不会被修改

    ▪ 依赖对象在使⽤前⼀定会被完全初始化，因为依赖是在类的构造⽅法中执⾏的，⽽构造⽅法

    是在类加载阶段就会执⾏的⽅法.

    ▪ 通⽤性好, 构造⽅法是JDK⽀持的, 所以更换任何框架,他都是适⽤的

    ◦ 缺点:

    ▪ 注⼊多个对象时, 代码会⽐较繁琐

  3. Setter注⼊(Spring 3.X推荐)

    ◦ 优点: ⽅便在类实例之后, 重新对该对象进⾏配置或者注⼊

    ◦ 缺点:

    ▪ 不能注⼊⼀个Final修饰的属性

    ▪ 注⼊对象可能会被改变, 因为setter⽅法可能会被多次调⽤, 就有被修改的⻛险

4.5 @Autowired出现多个同类型Bean的情况

会发生报错：

控制器类:

java 复制代码 
package com.example.springioc.autowired_test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class TestController {
    @Autowired// 有两个String类型的Bean
    String name;

    public void sayHi() {
        System.out.println(name);
    }
}

组件类:

java 复制代码 
package com.example.springioc.autowired_test;

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class BeanConfig {
    @Bean
    public String test1() {
        return new String("zhang3");
    }
    @Bean
    public String test2() {
        return new String("li4");
    }
}

可以看出组件中有两个String类型的Bean。

原因：

@Autowired不知道选择哪个Bean进行注入，发生了冲突，需要解决这个冲突。

解决方法：
1. 使用 @Primary 指定默认匹配的项目
2. 使用autowireCandidate = false去除默认匹配
3. 使用 @Resource(name="**")对于特定名称的Bean进行注入

​

4.6 @Autowired和@Rescource的区别

  1. @Autowired 是spring提供的注解，@Rescource是Java EE提供的注解

  2. @Autowired按照默认规则进行注入，但是@Rescource根据名称注入，有更多的选项。

    默认规则:

相关推荐
程序员张33 小时前
Maven编译和打包插件
java·spring boot·maven
ybq195133454314 小时前
Redis-主从复制-分布式系统
java·数据库·redis
weixin_472339465 小时前
高效处理大体积Excel文件的Java技术方案解析
java·开发语言·excel
小毛驴8505 小时前
Linux 后台启动java jar 程序 nohup java -jar
java·linux·jar
DKPT6 小时前
Java桥接模式实现方式与测试方法
java·笔记·学习·设计模式·桥接模式
好奇的菜鸟7 小时前
如何在IntelliJ IDEA中设置数据库连接全局共享
java·数据库·intellij-idea
DuelCode8 小时前
Windows VMWare Centos Docker部署Springboot 应用实现文件上传返回文件http链接
java·spring boot·mysql·nginx·docker·centos·mybatis
优创学社28 小时前
基于springboot的社区生鲜团购系统
java·spring boot·后端
幽络源小助理8 小时前
SpringBoot基于Mysql的商业辅助决策系统设计与实现
java·vue.js·spring boot·后端·mysql·spring
猴哥源码9 小时前
基于Java+springboot 的车险理赔信息管理系统
java·spring boot
热门推荐
01Java学习第十五部分——MyBatis02集群聊天服务器---MySQL数据库的建立03Coze扣子平台完整体验和实践（附国内和国际版对比）04基于odoo17的设计模式详解---装饰模式05使用Ruby接入实时行情API教程06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07Everything文件检索工具 几秒检索几百G的文件08基于odoo17的设计模式详解---单例模式09DeepSeek各版本说明与优缺点分析10【无标题】