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 进行管理

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

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

@SpringBootApplication
public class SpringIocDemoApplication {
 public static void main(String[] args) {
 //获取Spring上下⽂对象 
 ApplicationContext context = SpringApplication.run(SpringIocDemoApplicatio
 //从Spring上下⽂中获取对象 
 UserController userController = context.getBean(UserController.class);
 //使⽤对象 
 userController.sayHi();
 }
}

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

---

2.@Service（服务存储）

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

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

@Service
public class UserService {
 public void sayHi(String name) {
 System.out.println("Hi," + name);
 }
}

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

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

        获得 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 管理的对象名）

@Component
public class BeanConfig {
 @Bean
 public User user(){
 User user = new User();
 user.setName("zhangsan");
 user.setAge(18);
 return user;
 }
}

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

        定义多个对象

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

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

@Component
public class BeanConfig {
 @Bean
 public User user1(){
 User user = new User();
 user.setName("zhangsan");
 user.setAge(18);
 return user;
 }
 @Bean
 public User user2(){
 User user = new User();
 user.setName("lisi");
 user.setAge(19);
 return user;
 }
}

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

        通过 getBean 方法获取对象的三种常用参数

@SpringBootApplication2 
public class SpringIocDemoApplication {
public static void main(String[] args) {
//获取Spring上下⽂对象
ApplicationContext context = SpringApplication.run(SpringIocDemoApplicatio
//从Spring上下⽂中获取对象      
//根据bean类型, 从Spring上下⽂中获取对象      
UserController userController1 = context.getBean(UserController.class);      
//根据bean名称, 从Spring上下⽂中获取对象      
UserController userController2 = (UserController)context.getBean("userController");
//根据bean名称+类型, 从Spring上下⽂中获取对象      
UserController userController3 = context.getBean("userController",UserController.class);
  }
}

        Bean（对象） 的重命名

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

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

@Bean(name = {"u1","user1"})
public User user1(){
 User user = new User();
 user.setName("zhangsan");
 user.setAge(18);
 return user;
}

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

@Bean("u1")
public User user1(){
 User user = new User();
 user.setName("zhangsan");
 user.setAge(18);
 return user;
}

Bean的获取

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

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

        1. 属性注⼊(Field Injection) 

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

        3. Setter 注⼊(Setter Injection) 

1. 属性注⼊

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

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

public class UserController {
 //注⼊⽅法1: 属性注⼊ 
 @Autowired
 private UserService userService;
 public void sayHi(){
 System.out.println("hi,UserController...");
 userService.sayHi();
 }
}

2.构造⽅法注⼊

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

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

public class UserController2 {
 //注⼊⽅法2: 构造⽅法 
 private UserService userService;
 @Autowired
 public UserController2(UserService userService) {
 this.userService = userService;
 }
 public void sayHi(){
 System.out.println("hi,UserController2...");
 userService.sayHi();
 }
}

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

3.Setter 注⼊

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

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

@Controller
public class UserController3 {
 //注⼊⽅法3: Setter⽅法注⼊ 
 private UserService userService;
 @Autowired
 public void setUserService(UserService userService) {
 this.userService = userService;
 }
}

三种注⼊的优缺点分析

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 对象

@Component
public class BeanConfig {
 @Primary //指定该bean为默认bean的实现 
 @Bean("u1")
 public User user1(){
 User user = new User();
 user.setName("zhangsan");
 user.setAge(18);
 return user;
 }
 @Bean
 public User user2() {
 User user = new User();
 user.setName("lisi");
 user.setAge(19);
 return user;
 }
}

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

@Qualifier

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

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

public class UserController {
 @Qualifier("user2") //指定bean名称 
 @Autowired
 private User user;
 public void sayHi(){
 System.out.println("hi,UserController...");
 System.out.println(user);
 }
}

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

@Resource

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

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

public class UserController {
 @Resource(name = "user2")
 private User user;
 public void sayHi(){
 System.out.println("hi,UserController...");
 System.out.println(user);
 }
}

@Autowird 与 @Resource 的区别

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

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