Spring IoC&DI（下）—DI的尾声

        我们之前学习了控制反转IoC，接下来就开始学习依赖注入DI的细节。

        依赖注入是一个过程，是指IoC容器在创建Bean时，去提供运行时所依赖的资源，而资源指的就是对象。我们使用 @Autowired 注解，完成依赖注入的操作。简单来说，就是把对象取出来，放到某个类的属性中。由此，依赖注入也被称之为 “对象注入”、“属性装配”，具体含义需要结合文章的上下文来理解。

        关于依赖注入，Spring也给我们提供了三种方式：

1、属性注入（Field Injection）

2、构造方法注入（Construct Injection）

3、Setter 注入（Setter Injection）

1. 属性注入

        属性注入是使用 @Autowired 实现的，将UserService 类注入到UserController类中，UserService 类代码如下：

package com.example.zxslzw2014_8_11;

import org.springframework.stereotype.Service;

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

         UserController类的实现代码如下：

package com.example.zxslzw2014_8_11;

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

@Controller
public class UserController1 {
    //注入方法1：属性注入
    @Autowired
    private UserService userService;
    public void sayHi() {
        userService.doService();
        System.out.println("hi, UserController");
    }
}

        启动类获取到UserController的doService方法，代码如下：

package com.example.zxslzw2014_8_11;


import com.example.zxslzw2014_8_11.controller.UserController;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.ComponentScan;


@SpringBootApplication
public class Zxslzw2014811Application {

    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(Zxslzw2014811Application.class, args);
        //从Spring上下文中获取对象
        UserController1 userController1 = (UserController1) context.getBean("userController1");
        //使用对象
        userController1.sayHi();


    }
}

        运行结果如下：

        去掉注解@Autowired，运行结果如下：

         报错信息显示空指针异常，没办法调用doService() 方法，因为userServer为空。没有加@Autowired注解，即没有注入依赖，Spring拿不到这个属性，就不会给它初始化了，那么它肯定就是一个空指针了。 

2. 构造方法注入

        构造方法注入就是在类的构造方法中实现注入，代码如下：

package com.example.zxslzw2014_8_11;

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

@Controller
public class UserController1 {
    private UserService userService;
    //注入方法2：构造方法注入
    @Autowired
    public UserController1(UserService userService) {
        this.userService = userService;
    }
    public void doController() {
        userService.doService();
        System.out.println("hi, UserController");
    }
}

或

package com.example.zxslzw2014_8_11;

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

@Controller
public class UserController1 {
    private UserService userService;
    //注入方法2：构造方法注入
    public UserController1(UserService userService) {
        this.userService = userService;
    }
    public void doController() {
        userService.doService();
        System.out.println("hi, UserController");
    }
}

        运行结果如下：

 

       如果类只有一个构造方法，那么@Autowired注解可以省略；但如果类有多个构造方法，那么就需要添加上@Autowired来明确指定要使用哪个构造方法了。下面给userController1增加一个无参构造，代码如下：

package com.example.zxslzw2014_8_11;

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

@Controller
public class UserController1 {
    //注入方法1：属性注入
//    @Autowired
    private UserService userService;
    //注入方法2：构造方法注入
//    @Autowired
    public UserController1(){
        
    }
    public UserController1(UserService userService) {
        this.userService = userService;
    }
    public void doController() {
        userService.doService();
        System.out.println("hi, UserController");
    }
}

        运行结果如下：

        报错显示，空指针异常，我们的类交给Spring管理，Spring内部会给我们自动创建对象，但是是通过构造函数创建的，上图我们写了两个构造函数，如果不加@Autowired注解，Spring默认使用无参构造函数，如此就不能成功创建对象了，所以这个userService也自然是空指针了。

        现在代码改一下，把无参构造函数注释掉，更新构造函数，代码如下：

package com.example.zxslzw2014_8_11;

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

@Controller
public class UserController1 {
    //注入方法1：属性注入
//    @Autowired
    private UserService userService;
    private UserComponent userComponent;
    //注入方法2：构造方法注入
    public UserController1(UserService userService) {
        this.userService = userService;
    }
    public UserController1(UserService userService, UserComponent userComponent) {
        this.userService = userService;
        this.userComponent = userComponent;
    }
    public void doController() {
        userService.doService();
        userComponent.doComponent();
        System.out.println("hi, UserController");
    }
}

        运行结果如下：

          报错显示，没有找到默认的构造方法，因为这里出现了两个构造方法，Spring不知道该用哪个，现在给第二个构造方法加上@Autowired注解，表示让Spring使用被注解的构造方法，运行结果如下：

        综上：
1、只有一个构造函数的情况，可以不加@Autowired

2、如果有多个构造函数，需要指定默认的构造函数（通过@Autowired指定，如果未指定，默认使用无参的构造函数）。

        构造规范：如果添加构造函数，把无参构造函数显示添加（也就是把构造函数写下来，再给注释掉）

3. Setter注入

        Setter注入和属性的Setter方法实现类似，只不过在set方法的时候需要加上@Autowired注解，代码如下：

package com.example.zxslzw2014_8_11;

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

@Controller
public class UserController1 {
    private UserService userService;
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;

    }
    public void doController() {
        userService.doService();
        System.out.println("hi, UserController");
    }
}

        结果如下：

 

         同时我们把@Autowired注解去掉的话，又会出现空指针异常，原因和属性注入把@Autowired的情况一样，就是spring优先使用空参构造，结果空参构造的对象不能匹配到我们所调用的方法。

4. 三种注入的优缺点分析

4.1 属性注入

优点：
        1、简洁、使用方便。

缺点：
        1、只能用于IoC容器，如果非IoC容器则不可用，并且只有在使用的时候才会回出现NPE（空指针异常）。

         reason：如下图，可以看到，它的来源是Spring的，那么就只能用于IoC容器了。

        2、不能注入一个final修饰的属性。

        reason： final修饰的属性有个特点，必须初始化，如果我们给属性加上final，会有两种解决方案：

        方案1、提供构造函数，如图：

         如果加上构造方法，我们的属性注入就变成了构造方法注入。

        方案二： 给它初始化，new 一个对象：

         如此我们的代码就只能自己管理了，Spring不会帮我们管理，这不是ioc的思想；

 4.2 构造方法注入

        （Spring4.X推荐）

        SpringBoot和Spring的版本号对应：

Spring Boot3.X -> Spring 6

Spring Boot2.X -> Spring 4

优点：
        1、可以注入final修饰的属性。

        final修饰的属性要初始化，构造方法会进行初始化，复合它的要求。

        2、注入的对象不会被修改。

        因为构造方法在这个类创建的时候就会给它进行赋值了，不会再对它进行修改

        3、依赖对象在使用前一定会被完全初始化，因为依赖是在类的构造方法中执行的，而构造方法是在类加载阶段就会执行的方法。

        在类加载的这个阶段，就会执行构造方法了，把依赖对象给初始化完成。

        4、通用性好，构造方法是JDK支持的，所以更换任何框架，它都是适用的。

        因构造方法是JDK支持的，不再Spring框架也能正常的使用

缺点：
        注入多个对象时，代码会比较繁琐。

4.3 Setter注入

        （Spring3.X推荐）
优点：
        方便在类实例之后，重新对该对象进行配置或注入。

        因为Setter方法是可以被其他地方调用的，所以即使类已经被实例化了，也可以重新对该对象进行配置或注入。

缺点：
        1、不能注入一个final修饰的属性。

        因为可能会被多次修改，所以不能使用final修饰。

        2、注入对象可能会被改变，因为Setter方法可能会被多次调用，就有被修改的风险。

        Setter方法当然能被修改了，这即使它的优点，也是它的缺点。

4.4 Autowired查找依赖顺序

        1、根据名称和类型去查。

        2、如果根据名称查不到，就会根据类型去查。

        根据名称查不到了，去查找类型，这时如果类型匹配多个，就会报错。

5. @Autowired存在问题

        当同一类型存在多个bean时，使用@Autowired会存在问题。代码如下：

@Component
public class BeanConfig {
    @Bean
    public UserInfo userInfo1() {
        UserInfo user = new UserInfo();
        user.setId(6);
        user.setName("shenmengyao");
        user.setAge(18);
        return user;
    }
 
    @Bean
    public UserInfo userInfo2() {
        UserInfo user = new UserInfo();
        user.setId(7);
        user.setName("yuanyiqi");
        user.setAge(19);
        return user;
    }
}

        此时我们在UserController1类里面注入UserInfo类，代码如下：（下面这几个的注入方式都是错误的）

5.1 引入Autowired的错误代码：

5.1.1 属性注入：

        尝试运行出现如下结果： 

5.1.2 构造方法注入 

5.1.3 Setter方法注入 

5.1.4 启动类代码：

        上面这三种方式注入都会出问题，启动程序后，而报错信息也都是一样的，如上图所示：

        程序还没启动就失败了，可以看出来，Spring的依赖注入是在项目启动前就开始注入的了。

        上面报错提示：UserController1类需要一个bean，但是有两个，下面也打印出是哪两个bean了，Action介绍的就是解决方案。报错日志非常详细。

        报错信息说UserController1类找不到依赖注入的是哪一个，因为有多个方法被@bean注释，而依赖注入时，三个方法的属性名都是userInfo，系统先根据userInfo名称查找，但BeanConfig类没有这个方法名，那就只能去根据类名找了，但有2个bean，Spring就不知道要找那个了，并不是@bean注释下的方法名（userInfo1 / userInfo2），Spring并不知道该注入哪个依赖，所以报错了。

        在项目启动失败，可以把Filed看为属性，如上图：这个是使用属性注入的，会有Field；

         构造方法和Setter注入都是第一张报错图，但就不是Field了，而是Parameter，但其实三种注入的报错原因都是一样的。

        解决方案：使用属性注入时，就把属性名改成bean修饰的其中之一的方法名就好了；使用@Parimary注解；使用@Qualifier注解；使用@Resource注解。

5.2 解决方案

5.2.1 解决方案一：根据名称去查

        属性名改成bean修饰的其中之一的方法名

1、属性注入：

2、构造方法注入： 

3、Setter方法注入：

        上面三种执行结果都一样，这里虽然注入了依赖，但没有用这些依赖；

5.2.1 解决方案二：

        给想要拿到的对象加上@Primary注解

        这个可以理解为依赖注入后，有多个依赖的方法，但默认使用加了@Primary的方法，代码如下：

1、UserController类

2、BeanConfig类：

代码运行结果：

         其他注入的方式，使用@Primary注解用法也一样，把想要拿到的对象加上@Primary注解就好了。

5.2.3 解决方案三：

        加@Qualifier注解，指定引入的依赖对象

UserController类：

        BeanConfig类和启动类与最初的代码一样，不用变。代码最终能够成功运行，结果和之前类似；

5.2.4 解决方案四：加@Resource注解

        这里和上面的三方案代码改变的只有UserController类，其他都不变，UserController类的代码如下：

@Controller
public class UserController {
    @Resource(name = "userInfo1")
    @Autowired
    private UserInfo userInfo;
        
    public void sayHi() {
        System.out.println(userInfo.toString());
        System.out.println("hello, controller");
    }
}

        运行结果如下：

         这个注解不是Spring的，而是JDK本身自带的，JDK早期也有这样的注解，所以Spring不推荐使用这个注解，因为不是自己开发的，如果出现啥问题，不好处理，是有着不可控因素的原因；还有使用自家的东西也肯定会更放心一些。

5.3 @Autowired 与 @Resource 的区别

1、@Autowired 是 Spring框架提供的注解，而@Resource是JDK提供的注解。

2、@Autowired默认是按照类型注入，而@Resource是按照名称注入。相比于 @Autowired 来说，@Resource 支持更多的参数设置；例如 name 设置，根据名称获取 Bean。

6. Spring IoC&DI 的总结

1、Spring，Spring Boot 和 Spring MVC的关系以及区别
（1）、Spring
        简单来说，Spring是一个开发应用框架，其目的是用于简化企业级应用程序开发。

        Spring的主要功能：管理对象，以及对象之间的依赖关系，面向切面编程、数据库事务管理、数据访问、web框架支撑等等。

        Spring具备高度可开发性，并不强制依赖Spring，开发者可以自由选择Spring的部分或者全部，Spring可以无缝继承第三方框架，比如数据访问框架（Hibernate、JPA等等），web框架（如：Struts、JSF等等）。

（2）、Spring MVC
        Spring MVC是Spring的一个子框架，Spring诞生之后，大家按照MVC模式设计了一个MVC框架（用Spring解耦），主要用于开发WEB应用和网络接口，所以Spring MVC是一个Web框架。

        Spring MVC是基于Spring进行开发的，可以让我们更简洁的进行Web层开发，支持灵活的URL到页面控制器的映射，提供了强大的约定大于配置的契约式编程支持，非常容易与其他视图框架集成，如 Velocity、FreeMarker等等。

（3）、Spring Boot
        Spring Boot 是对Spring的一个封装，为了简化Spring一样的开发而出现的，使用Spring Boot 可以更加快速的搭建框架，降低开发成本，让开发人员更加专注于Spring应用的开发，而无需过多关注XML的配置和一些底层的实现。

        Spring Boot可以快速的集成其他框架进来。想使用Spring Boot开发Web项目，只需要引入Spring MVC框架即可，Web开发的工作是Spring MVC完成的，而不是Spring Boot，想完成数据访问，只需要引入Mybatis框架即可。

        Spring Boot只是辅助简化项目开发的，让开发变得更加简单，甚至不需要额外的web服务器，直接生成jar包执行即可。

（4）、总结
        Spring MVC和Spring Boot都属于Spring，Spring MVC是基于Spring的一个MVC框架，而Spring Boot是基于Spring的一套快速开发整合包。

        之前写的图书管理系统代码中，整体框架是通过SpringBoot搭建的IoC，DI功能是Spring提供的，而Web相关功能是Spring MVC提供的。

        因为这三个专注的领域不同，所以解决的问题也不一样，总的来说，Spring就像一个大家族，有众多衍生产品，但它们的基础都是Spring；

2、bean的命名

（1）、五大注解存储的bean
1、类名前面两位字母均为大写，则bean名称为该类名本身（特殊情况）。

2、不是上面的特殊情况，其他的类名，首字母小写，驼峰形式命名。

3、通过 value 属性设置bean名 ，例如：@Controller (value = "user")。

（2）、@Bean注解存储的bean

1、bean名称为方法名。

2、通过name属性设置bean名，例如：@Bean (name = {"u1", "user1"})。

ps：本次的内容就到这里了，如果对你有所帮助的话，就请一键三连哦！！！

本文的封面来自：bilibili苏杉杉的pv，侵权删 url：https://www.bilibili.com/video/BV1vo4y167eh/?spm_id_from=333.999.0.0&vd_source=866da5be2ef0ddd213b053523da53138
————————————————

电子签名：上嘉路