• Spring IoC & DI 使⽤

            关于 IoC 的含义，推荐看IoC含义介绍（Spring的核心思想）

            喜欢 Java 的推荐点一个免费的关注，主页有更多 Java 内容

    前言

            通过上述的博客我们知道了 IoC 的含义，既然 Spring 是⼀个 IoC（控制反转）容器，作为容器, 那么它就具备两个最基础的功能：‘存’和‘取’

            Spring容器管理的主要是对象, 这些对象, 我们称之为"Bean". 我们把这些对象交由Spring管理,我们的程序只需要告诉Spring,哪些对象需要存,以及在需要时从Spring中取出 对象

    Bean的存储

            要想将对象交给 Spring 进行管理，Spring 提供了丰富的注解来实现这一功能

            共有两种注解类型可以实现：

            1. 类注解：@Controller、@Service、@Repository、@Component、@Configuration.(五大注解)

            2. ⽅法注解：@Bean.

    1.@Controller（控制器存储）

            对应 Spring Web MVC 开发，三层架构中的 Controller （控制层），案例：

            如下的代码，对 UserController  这个控制类加上 @Controller 注解就表明将 UserController 类的对象交给 Spring 进行管理

    1. @Controller // 将对象存储到 Spring 中 
    2. public class UserController {
    3.  public void sayHi(){
    4.  System.out.println("hi,UserController");
    5.  }
    6. }

            通过下面的代码来验证，我们是否成功将 UserController 类的对象交给 Spring 进行管理，SpringIocDemoApplication 是当前 Spring Web MVC 项目中的启动类，SpringApplication 是 Spring Boot框架中用于启动应用程序的类，SpringApplication 调用 run 方法启动了当前的项目，并且返回了 Spring 的 IoC 容器（也叫做 Spring 上下文），用 ApplicationContext  类型的对象 context  来接收，获得了 Spring 的 IoC 容器后，调用 getBean 方法，传入 UserController 的类对象 我们便获得了 Spring IoC 容器中管理的 UserController 类型的 对象（Bean）

    1. @SpringBootApplication
    2. public class SpringIocDemoApplication {
    3.  public static void main(String[] args) {
    4.  //获取Spring上下⽂对象 
    5.  ApplicationContext context = SpringApplication.run(SpringIocDemoApplicatio
    6.  //从Spring上下⽂中获取对象 
    7.  UserController userController = context.getBean(UserController.class);
    8.  //使⽤对象 
    9.  userController.sayHi();
    10.  }
    11. }

            获得 userController 对象后调用 sayHi 方法，我们便在控制台发现 sayHi 方法正确执行，代表我们成功将 UserController 类型的对象交给了 Spring 进行管理（成功将创建 UserController 对象的控制权交给了 Spring ，控制反转），并成功从 Spring 获取到对象

    2.@Service（服务存储）

            对应 Spring Web MVC 开发，三层架构中的 Service（业务逻辑层），案例：

             如下的代码，对 UserService 这个业务逻辑类加上 @Service 注解就表明将 UserService 类的对象交给 Spring 进行管理

    1. @Service
    2. public class UserService {
    3.  public void sayHi(String name) {
    4.  System.out.println("Hi," + name);
    5.  }
    6. }

              通过下面的代码来验证，我们是否成功将 UserService 类的对象交给 Spring 进行管理

    1. @SpringBootApplication
    2. public class SpringIocDemoApplication {
    3.  public static void main(String[] args) {
    4.  //获取Spring上下⽂对象 
    5.  ApplicationContext context = SpringApplication.run(SpringIocDemoApplicatio
    6.  //从Spring中获取UserService对象 
    7.  UserService userService = context.getBean(UserService.class);
    8.  //使⽤对象 
    9.  userService.sayHi();
    10.  }

            获得 UserService 对象后调用 sayHi 方法，我们便在控制台发现 sayHi 方法正确执行，代表我们成功将 UserService  类型的对象交给了 Spring 进行管理（成功将创建 UserService 对象的控制权交给了 Spring ，控制反转）

            3.五大注解总结

            通过上述 @Controller 和 @Service 注解的使用以及检验，我们会发现有很多的相似之处，实际上 @Controller、@Service、@Repository、@Component、@Configuration 这五大注解的除了名称不同以外，作用都是将 对象 （Bean）交给 Spring 进行管理（将创建对象的控制权交给 Spring ）（此处我们不谈这些注解在其他地方的作用，比如 @Controlle 还代表该类是一个控制类，在接收到 Http 请求后 Spring 要遍历 带有 @Controlle 注解的类）

            既然 @Controller、@Service、@Repository、@Component、@Configuration 这五大注解在这里的作用都是一样的，那 Spring 为什么要提供这么多注解呢？实际上这和 Spring Web MVC 开发的三层架构对应，@Controller 这个注解对应三层架构的  Controller 控制层，@Service 对应三层架构的 Service 业务逻辑层，@Repository 对应三层架构的 Dao 数据层，不处于这三层中的类就用 @Component（组件） 注解，@Configuration 表示配置类的注解

            提供 @Controller、@Service、@Repository、@Component、@Configuration 这五大注解主要是为了让程序猿针对不同层次的类用对应的注解，让程序员看到类注解之后，就能直接了解当前类的⽤途.

            注意：使用五大注解，Spring 只会管理类的一个对象，无论获取这个类的对象多少次，都是同一个对象，是单例模式，那我们想要 Spring 管理一个类的多个对象的话就要看下面的方法注解@Bean 

            4.⽅法注解 @Bean 

            五大注解存在一些无法解决的问题，此时我们就需要使用方法注解，比如下面的问题：

            1. 使⽤外部包⾥的类,没办法添加类注解

            2. ⼀个类,需要多个对象,⽐如多个数据源

    这种场景,我们就需要使⽤⽅法注解 @Bean 

            方法注解的使用方式如下：

            根据下面的代码，我们便创建了一个类型为 User ，名称为 user 的对象交给了 Spring 管理（方法名就是 Spring 管理的对象名）

    1. @Component
    2. public class BeanConfig {
    3.  @Bean
    4.  public User user(){
    5.  User user = new User();
    6.  user.setName("zhangsan");
    7.  user.setAge(18);
    8.  return user;
    9.  }
    10. }
    11.

            注意:方法注解 @Bean  要搭配五大注解一起使用，因为 Spring 在项目运行时扫描的是加上相关注解，需要 Spring 处理的类，所以要是不加五大注解，Spring 压根就不会扫描到 @Bean 注解，也就不会管理方法创建的对象

            定义多个对象

            对于同⼀个类,如何定义多个对象呢? 代码如下

            我们通过下面的代码便创建了两个 User 类型的对象 user1 和 user2 交给 Spring 进行管理

    1. @Component
    2. public class BeanConfig {
    3.  @Bean
    4.  public User user1(){
    5.  User user = new User();
    6.  user.setName("zhangsan");
    7.  user.setAge(18);
    8.  return user;
    9.  }
    10.  @Bean
    11.  public User user2(){
    12.  User user = new User();
    13.  user.setName("lisi");
    14.  user.setAge(19);
    15.  return user;
    16.  }
    17. }

            注意：当 Spring 管理的一个类中有多个对象的时候，我们获取就不能通过类对象来获取了，要不然会报错,我们可以通过对象（Bean）的名称或者对象（Bean） 的名称加类型来从 Spring 那里获取指定的对象

            通过 getBean 方法获取对象的三种常用参数
    1. @SpringBootApplication2 
    2. public class SpringIocDemoApplication {
    3. public static void main(String[] args) {
    4. //获取Spring上下⽂对象
    5. ApplicationContext context = SpringApplication.run(SpringIocDemoApplicatio
    6. //从Spring上下⽂中获取对象      
    7. //根据bean类型, 从Spring上下⽂中获取对象      
    8. UserController userController1 = context.getBean(UserController.class);      
    9. //根据bean名称, 从Spring上下⽂中获取对象      
    10. UserController userController2 = (UserController)context.getBean("userController");
    11. //根据bean名称+类型, 从Spring上下⽂中获取对象      
    12. UserController userController3 = context.getBean("userController",UserController.class);
    13.   }
    14. }
            Bean（对象） 的重命名

            根据上面的介绍我们知道，使用 @Bean 注解让 Spring 管理方法创建的对象时，对象的名称就是方法名称，那我们可不可以修改 Spring 管理的对象名称呢？那必然是可以的

            通过在 @Bean 注解中设置属性 name 来重命名对象名称，如下的方式为该对象设置了两个名称，所以我们查找名称 u1 和 user1 都是这个对象

    1. @Bean(name = {"u1","user1"})
    2. public User user1(){
    3.  User user = new User();
    4.  user.setName("zhangsan");
    5.  user.setAge(18);
    6.  return user;
    7. }

            而如果一个对象就一个名称的话，重命名就更加的简单，直接在 @Bean 注解中加上要修改的名称即可

    1. @Bean("u1")
    2. public User user1(){
    3.  User user = new User();
    4.  user.setName("zhangsan");
    5.  user.setAge(18);
    6.  return user;
    7. }

    Bean的获取

            Bean的获取就是获取 Spring 管理的对象，也可以叫做依赖注⼊DI，简单来说,就是把对象取出来放到某个类的属性中

            关于依赖注⼊,Spring也给我们提供了三种⽅式: 

            1. 属性注⼊(Field Injection) 

            2. 构造⽅法注⼊(Constructor Injection) 

            3. Setter 注⼊(Setter Injection) 

    1. 属性注⼊

            属性注⼊是使⽤注解 @Autowired 实现的

            如下代码，UserController 类中有 UserService 类型的属性需要赋值，在 UserService 类型的属性前加上 @Autowired 注解，表明要从 Spring 那里获取到 UserService 类型的对象赋值给 userService 变量

    1. public class UserController {
    2.  //注⼊⽅法1: 属性注⼊ 
    3.  @Autowired
    4.  private UserService userService;
    5.  public void sayHi(){
    6.  System.out.println("hi,UserController...");
    7.  userService.sayHi();
    8.  }
    9. }

    2.构造⽅法注⼊

            构造⽅法注⼊是在类的构造⽅法中实现注⼊，如下代码所⽰：

            在构造方法前加上  @Autowired 注解，表明要从 Spring 那里获取到构造方法的参数，此时构造方法需要 UserService 类型的对象，便会从 Spring 那里获取到，完成构造方法

    1. public class UserController2 {
    2.  //注⼊⽅法2: 构造⽅法 
    3.  private UserService userService;
    4.  @Autowired
    5.  public UserController2(UserService userService) {
    6.  this.userService = userService;
    7.  }
    8.  public void sayHi(){
    9.  System.out.println("hi,UserController2...");
    10.  userService.sayHi();
    11.  }
    12. }

            注意：如果类只有⼀个构造⽅法，那么 @Autowired 注解可以省略；如果类中有多个构造⽅法， 那么需要添加上 @Autowired 来明确指定到底使⽤哪个构造⽅法。

    3.Setter 注⼊

            Setter 注⼊和属性的 Setter ⽅法实现类似，只不过在设置 set ⽅法的时候需要加 @Autowired 注 解 ，如下代码所⽰：

            在 set 方法前加上 @Autowired 注解就表示要从 Spring 那里获取到 set 方法的参数

    1. @Controller
    2. public class UserController3 {
    3.  //注⼊⽅法3: Setter⽅法注⼊ 
    4.  private UserService userService;
    5.  @Autowired
    6.  public void setUserService(UserService userService) {
    7.  this.userService = userService;
    8.  }
    9. }

    三种注⼊的优缺点分析

    1.属性注⼊

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

    ◦ 缺点: ▪ 1.只能⽤于 IoC 容器，如果是⾮ IoC 容器不可⽤，并且只有在使⽤的时候才会出现 NPE（空 指针异常）

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

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

    ◦ 优点: ▪ 1.可以注⼊final修饰的属性 

    ▪ 2.注⼊的对象不会被修改 

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

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

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

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

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

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

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

    @Autowired存在问题

            当同⼀类型存在多个 bean(对象) 时, 使⽤ @Autowired 会存在问题，因为 Spring 不知道你要获取该类型的哪个对象

            假设 Spring 中管理了 UserService 类型的多个对象，此时在一个类中有 UserService 类型的属性，并且加上了 @Autowired 注解表明要从 Spring 那里获取属性的值，此时 Spring 会先进行名称匹配，要是属性的名称和 Spring 那里管理的对象名称相同，那 Spring 就知道此时要获取哪个对象了，但要是名称都不同，就会报错

            如何解决上述问题呢？

            Spring提供了以下⼏种解决⽅案： 

            • @Primary

            • @Qualifier 

            • @Resource

    @Primary

            如下代码，要将 User 类型的 user1 和 user2 对象交给 Spring 进行管理，在 user1 方法前加上  @Primary 注解，就表明了 user1 是主要的对象，这样在不明确程序需要获取 User 类型的哪个对象的时候，Spring 就会提供 user1 对象

    1. @Component
    2. public class BeanConfig {
    3.  @Primary //指定该bean为默认bean的实现 
    4.  @Bean("u1")
    5.  public User user1(){
    6.  User user = new User();
    7.  user.setName("zhangsan");
    8.  user.setAge(18);
    9.  return user;
    10.  }
    11.  @Bean
    12.  public User user2() {
    13.  User user = new User();
    14.  user.setName("lisi");
    15.  user.setAge(19);
    16.  return user;
    17.  }
    18. }

            注意：但是实际上这个方法并不常用，因为要是设置了主要的对象，那么大多数情况下使用的都只会是主要的那个对象，该类型其他对象的存在就没有必要了

    @Qualifier

            指定当前要注⼊的bean对象。在 @Qualifier 的value属性中，指定注⼊的 bean 的名称。

            如下代码，加上注解 @Qualifier("user2") 就代表要获取 Spring 管理的名称为 user2 的对象注入到属性 user 中

    1. public class UserController {
    2.  @Qualifier("user2") //指定bean名称 
    3.  @Autowired
    4.  private User user;
    5.  public void sayHi(){
    6.  System.out.println("hi,UserController...");
    7.  System.out.println(user);
    8.  }
    9. }

    注意: @Qualifier 注解不能单独使⽤，必须配合 @Autowired 使⽤

    @Resource

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

            如下代码，加上注解  @Resource(name = "user2") 就代表要获取 Spring 管理的名称为 user2 的对象注入到属性 user 中

    1. public class UserController {
    2.  @Resource(name = "user2")
    3.  private User user;
    4.  public void sayHi(){
    5.  System.out.println("hi,UserController...");
    6.  System.out.println(user);
    7.  }
    8. }

    @Autowird 与 @Resource 的区别

            @Autowired 是spring框架提供的注解，⽽@Resource是JDK提供的注解

            @Autowired 默认是按照类型注⼊，⽽ @Resource 是按照名称注⼊（ @Autowired 搭配@Qualifier 也可以按照名称注入）
            

  • 相关阅读:
    注册域名，购买阿里云服务器，备案，域名解析图文教程简介
    ＞＞数据管理：读书笔记｜第一章 数据管理
    蚂蚁二面，面试官问我零拷贝的实现原理，当场懵了…
    layaBox---TypeScript---接口
    趣味成语接龙游戏里，如何判断用户输入的成语接龙成功？
    学习MySQL-第四章
    java集合之List接口实现类常用方法详解
    为什么我不推荐去SAP培训机构参加培训？
    Flutter环境配置遇到的问题
    实现动态大数结构
  • 原文地址：https://blog.csdn.net/q322359/article/details/134321687