Spring IoC&DI

🕗 发布于 2024-07-21 21:22 spring mybatis mysql

一，Spring IoC&DI 的定义

我们知道Spring是一个开源框架，简单来说就是一个包含众多工具的IoC容器。容器都知道是用来装东西的，那么什么是IoC？IoC是Spring的核心思想之一，在上一篇SpringMVC的博客中也使用到了，即类的注解，比如@RestController，@Controller注解，它们就表示将这个对象交给Spring管理，Spring框架启动时就会加载该类，把对象交给Spring管理，就是IoC思想。

1.1 IoC——控制反转

IoC，全称 Inversion of Control（控制反转），就是将控制权反转，再进一步来说就是将获得依赖对象的过程反转。IoC思想的主要目的就是降低代码的耦合度。比如说，做一件事，要先做...，再做...，最后做,,,，每一个操作要依赖于前一个操作，而Spring IoC容器就是用来管理这些操作，使我们不必关心前一个操作是否完成，而是只关注于本身的实现。

举个例子，如果不使用IoC思想：

public class demo1 {
    public static void main(String[] args) {
        Car car = new Car();
    }
    static class Car{
        private  Framework framework;
        public Car(){
            framework = new Framework();
            System.out.println("初始化car");
        }
    }

    static class Framework{
        private Bottom bottom;
        public Framework(){
            bottom = new Bottom();
            System.out.println("初始化framework");
        }
    }

    static class Bottom{
        public Bottom(){
            System.out.println("初始化bottom");
        }
    }
}

如果我们要改变bottom的大小，就需要把所有的代码都修改，即代码耦合度太高：

public class demo1 {
    public static void main(String[] args) {
        int size = 100;
        Car car = new Car(size);
    }
    static class Car{
        private  Framework framework;
        public Car(int size){
            framework = new Framework(size);
            System.out.println("初始化car");
        }
    }

    static class Framework{
        private Bottom bottom;
        public Framework(int size){
            bottom = new Bottom(size);
            System.out.println("初始化framework");
        }
    }

    static class Bottom{
        public Bottom(int size){
            System.out.println("初始化bottom");
        }
    }
}

1.2 DI——依赖注入

依赖注入就是实现控制反转的一种方式，我们不在每一个类中自己创建需要依赖的类，而是通过传递参数的形式来获得依赖的类（这里指自己实现，Spring中有专门的注解来帮我们实现，下面会讲），这种获得依赖的方式就称为DI（依赖注入），这样就实现了程序的解耦。

举个例子，将上述程序使用DI的方式实现：

public class demo1 {
    public static void main(String[] args) {
        int size = 100;
        Bottom bottom = new Bottom(size);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
    }
    static class Car{
        private Framework framework;
        public Car(Framework framework){
            this.framework = framework;
            System.out.println("初始化car");
        }
    }

    static class Framework{
        private Bottom bottom;
        public Framework(Bottom bottom){
            this.bottom = bottom;
            System.out.println("初始化framework");
        }
    }

    static class Bottom{
        private int size;
        public Bottom(int size){
            System.out.println("初始化bottom");
        }
    }
}

这样写的话，之后底层类无论如何变化，整个调用链都不用做出任何改变，这样就实现了代码之间的解耦。

1.3 IoC容器的优势

原本代码中类的创建顺序是：Car -> Framework -> Bottom
使用DI后代码中类的创建顺序是：Bottom -> Framework -> Car

可以发现改进后的代码，它创建类的顺序是反的，也是我们之前说的控制权发生了反转，不再是使用法对象创建并控制依赖对象了，而是把依赖对象注入到当前对象中，依赖对象的控制权不再由当前类控制了，这样的话无论依赖类发生任何改变，当前类都是不受影响的，这就是为什么我们将其称之为"控制反转"，这也是IoC的实现思想。

这里我们就彻底了解了上面所说的IoC思想，那么这里的IoC容器究竟有什么作用呢？

Bottom bottom = new Bottom(size);
Framework framework = new Framework(bottom);
Car car = new Car(framework);

上述代码就是IoC容器所做的工作，也就是说我们将需要使用的资源交给不使用资源的第三方管理，这可以带来很多好处：

实现了资源的集中管理：IoC容器会帮我们管理一些对象，当我们需要使用时，直接去IoC容器中取就行了
创建实例时不需要了解其中的细节，降低了耦合度

二，IoC 详解

既然Spring是一个IoC（控制反转）容器，作为容器，那么它就具备两个基本功能：存储，获取。Spring容器管理的主要是对象，这些对象，我们称之为"Bean"，我们将这些对象交给Spring管理，我们程序只要告诉Spring，哪些存，以及如何从Spring中取出对象。

2.1 Bean的存储

要把某个对象交给IoC容器管理，需要在类或方法上添加一个注解：

类注解：@Controller、@Service、@Repository、@Component、@Configuration
方法注解：@Bean

接下来分别来看

2.1.1 @Controller（控制器存储）

@Controller//将对象存储到Spring容器中
public class UserController {
    public void run(){
        System.out.println("UserController running...");
    }
}

为了观察这个对象是否存储到Spring中，我们需要从Spring中获取对象，代码如下：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserController userController = context.getBean(UserController.class);
        //使用对象
        userController.run();
    }
}

这里出现了一个Spring上下文，上下文就是指当前的运行环境，我们可以把它当作一个容器，容器中存储的就是当前的运行环境。

观察运行结果，发现成功从Spring中获取到UserController对象，并执行了它的run方法：

2.1.2 获取Bean的方式

上述代码是根据类型来查找对象，如果Spring容器中，同一个类存在多个Bean（即对象）的话，我们就需要通过其他方式获取，这里介绍三种常用的方法：

public interface BeanFactory {
    //以上省略...

    //根据bean的名称获取bean
    Object getBean(String var1) throws BeansException;
    
    //根据bean的名称和类型获取bean
    <T> T getBean(String var1, Class<T> var2) throws BeansException;
  
    //根据类型获取bean
    <T> T getBean(Class<T> var1) throws BeansException;

    //以下省略...
}

前两种方法都涉及到根据名称来获取对象，那么bean的名称是什么呢？Spring bean是Spring框架再运行时管理的对象，Spring会给管理的对象取一个名字，根据Bean的名称就可以获取到对应的对象。它的底层代码是这样的：

    //如果name前两个字符是大写，那么直接返回name
    //否则将name的第一个字符小写后，返回name
    public static String decapitalize(String name) {
        if (name == null || name.length() == 0) {
            return name;
        }
        if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
                        Character.isUpperCase(name.charAt(0))){
            return name;
        }
        char chars[] = name.toCharArray();
        chars[0] = Character.toLowerCase(chars[0]);
        return new String(chars);
    }

演示一下上述三种方法：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserController userController1 = (UserController) context.getBean("userController");
        UserController userController2 = context.getBean("userController", UserController.class);
        UserController userController3 = context.getBean(UserController.class);
        //使用对象
        System.out.println(userController1);
        System.out.println(userController2);
        System.out.println(userController3);
    }
}

2.1.3 @Service（服务存储）

@Service
public class UserService {
    public void run(){
        System.out.println("userService run...");
    }
}

获取该对象：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserService userService = context.getBean(UserService.class);
        //使用对象
        userService.run();
    }
}

2.1.4 @Repository（仓库存储）

@Repository
public class UserRepository {
    public void run(){
        System.out.println("UserRepository run...");
    }
}

获取该对象：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserRepository userRepository = context.getBean(UserRepository.class);
        //使用对象
        userRepository.run();
    }
}

2.1.5 @Component（组件存储）

@Component
public class UserComponent {
    public void run(){
        System.out.println("UserComponent run...");
    }
}

2.1.6 @Configuration（配置存储）

@Configuration
public class UserConfiguration {
    public void run(){
        System.out.println("UserConfiguration run...");
    }
}

获取与上面的做法一样，这里就不做过多的赘述。

2.2 五大注释的区别与作用

之所以有这么多注释就是为了让程序员区分被该注释的类的用途：

@Controller：控制层，接收请求，对请求进行处理，并进行响应
@Service：业务逻辑层，处理具体的业务逻辑
@Repository：数据访问层，也称为持久层，负责访问数据库的操作
@Configuration：配置层，处理项目中的一些配置

通过源码来看一下类注解之间的关系：

//@Component源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
    String value() default "";
}

//@Repository源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

//@Configuration源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";

    boolean proxyBeanMethods() default true;
}

//@Controller源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

//@Service源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

可以发现@Controller / @Service / @Repository / @Configuration这些注解中都有一个@Component注解，说明它们本身就属于@Component的子类，@Component 是⼀个元注解，也就是说可以注解其他类注解，如 @Controller , @Service , @Repository 等. 这些注解被称为 @Component 的衍⽣注解，@Component也是Spring能够自动识别并管理类的实例的原因。

下图可以看出它们之间的关系

2.3 方法注释@Bean

为什么还需要有一个方法注释？

如果要使用第三方库中的类，就没法自主添加类注释
一个类可能会创建多个对象，使用类注释无法实现

2.3.1 定义一个对象

@Component
public class UserBean {
    @Bean
    public User user(){
        User user = new User(18,"zhangsan");
        return user;
    }
}

注意：@Bean注解必须搭配类注解一起使用！！！，不然不会存储到Spring容器中

2.3.2 定义多个对象

@Component
public class UserBean {
    @Bean
    public User user1(){
        User user = new User(18,"zhangsan");
        return user;
    }
    @Bean
    public User user2(){
        User user = new User(10,"lisi");
        return user;
    }
}

当一个类出现多个对象时，我们就不能使用类来获取对象，不然会出现下面的报错：

这时就必须要通过它们的名字来获取对象，注意@Bean注释定义的对象，默认名称就是方法名，不需要额外去判断修改，我们可以通过名称获取：

当然我们也可以通过name属性来重命名：

@Component
public class UserBean {
    @Bean({"UserInfo"})//可以取多个名称
    public User user(){
        User user = new User(18,"zhangsan");
        return user;
    }
}

2.4 扫描路径

想要将对象交给Spring管理，不仅需要添加类注解，方法注解，还需要让这些类在Spring的扫描路径下。

这时我们可以通过@ComponentScan()注解来配置Spring的扫描路径：

注：{}中可以配置多个路径

三，DI详解

在Spring中，我们可以使用@Autowired注解来完成依赖注入的操作，Spring提供了三种方式：

属性注入
构造方法注入
Setter注入

3.1 属性注入

注入多个对象时，每个对象都要添加@Autowired注解

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @Autowired 
    private UserConfiguration userConfiguration

    public void run(){
        userService.run();
        System.out.println("UserController running...");
    }
}

3.2 构造方法注入

当只有一个构造方法，@Autowired注解可以不加

@Controller
public class UserController {
    private UserService userService;
    @Autowired
    public UserController(UserService userService){
        this.userService = userService;
    }
    public void run(){
        userService.run();
        System.out.println("UserController running...");
    }
}

当有多个构造方法，如果有@Autowired注解，那么就会调用有注解的那个；如果没有@Autowired注解，那么就会默认调用无参的构造方法。

@Controller
public class UserController {
    private UserService userService;
    private UserRepository userRepository;
    public UserController(){}
    public UserController(UserService userService){
        this.userService = userService;
    }
    @Autowired
    public UserController(UserService userService, UserRepository userRepository){
        this.userService = userService;
        this.userRepository = userRepository;
    }
    public void run(){
        userService.run();
        userRepository.run();
        System.out.println("UserController running...");
    }
}

3.3 Setter注入

@Controller(value = "u1")//可以通过value属性重命名
public class UserController {
    private UserService userService;
    private UserRepository userRepository;
    @Autowired
    public void setUserService(UserService userService){
        this.userService = userService;
    }
    @Autowired
    public void setUserRepository(UserRepository userRepository){
        this.userRepository = userRepository;
    }

    public void run(){
        userService.run();
        userRepository.run();
        System.out.println("UserController running...");
    }
}

3.4 @Autowired存在的问题

@Autowired注解会先根据类来查找需要注入的对象，如果该类有多个对象，就会根据名称来选择注入的对象，但是不推荐这种用法（因为在公司中一个项目通常是由多个人完成，默认变量名的修改不会影响业务的实现）：

为了避免上述做法，Spring提供了以下几种解决方法：@Primarily，@Qualifier，@Resource

@Primarily：可以在其中一个bean上添加@Primary注解，以指示Spring容器在存在多个候选者时应该优先考虑哪一个bean。如果有且仅有一个bean被标记为@Primary，则Spring将使用该bean进行注入。

@Component
public class UserBean {
    @Bean
    @Primary
    public User user1(){
        User user = new User(18,"zhangsan");
        return user;
    }
    @Bean
    public User user2(){
        User user = new User(10,"lisi");
        return user;
    }
}

@Qualifier：如果@Primary不足以解决问题（例如，如果有多个@Primary标记的bean，或者想基于不同的条件注入不同的bean），可以使用@Qualifier注解来明确指定要注入的bean的名称。@Qualifier可以与@Autowired一起使用，或者与@Bean方法一起使用在配置类中

@Repository
public class UserRepository {
    @Autowired
    @Qualifier("user1")
    private User user;
    public void run(){
        System.out.println("UserRepository run...");
    }
}

@Resource：是按照bean的名称进⾏注⼊，通过name属性指定要注⼊的bean的名称。

@Repository
public class UserRepository {
    @Resource(name = "user1")
    private User user;
    public void run(){
        System.out.println(user);
        System.out.println("UserRepository run...");
    }
}

四，常见面试题

4.1 三种注入方式的优缺点

1.属性注入

优点：简洁方便
缺点：只能在IoC容器中使用；不能注入一个final修饰的属性

2.构造方法注入：

优点：可以注入final修饰的属性；通用性好，是JDK支持的，可以任用于其他框架；注入对象不会被修改；依赖对象在使⽤前⼀定会被完全初始化，因为构造方法在类加载阶段就会执行
缺点：代码比较繁琐

3.Setter注入：

优点：方便在类实例之后, 重新对该对象进行配置或者注入
缺点：不能注入一个Final修饰的属性；注入对象可能会被改变, 因为setter方法可能会被多次调用, 就有被修改的风险

4.2 @Autowired与@Resource的区别

@Autowired 是spring框架提供的注解，⽽@Resource是JDK提供的注解
@Autowired 默认是按照类型注入，⽽@Resource是按照名称注入. 相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如 name 设置，根据名称获取 Bean。

4.3 ApplicationContext与BeanFactory

BeanFactory 提供了基础的访问容器的能力，ApplicationContext是BeanFactory的子类，继承了BeanFactory的所有功能之外，还有独特的功能，比如：支持国际化，支持资源访问。

ApplicationContext是一次性加载并初始化所有Bean对象，而BeanFactory是用到哪个才去加载哪个，所以BeanFactory比ApplicationContext更加轻量。（空间换时间）

原文地址：https://blog.csdn.net/m0_74859835/article/details/140478283

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：一个集Swagger2 和 OpenAPI3为一体的增强接口文档工具，一把为您的API文档需求量身定制的“利刃”（附源码）
下一篇：Linux