Spring存储和读取对象 -- 2

前言
一、存储 Bean 对象
- 1.1 前置工作：配置扫描路径 (重要)
- 1.2 添加注解存储 Bean 对象
- - 1.2.1 五大类注解
  - - Bean 命名规则
  - 1.2.2 方法注解 @Bean
  - - Bean 命名规则与重命名
二、获取 Bean 对象 (对象注入)
- 2.1 属性注入
- - 优点分析
  - 缺点分析
- 2.2 Setter 注入
- - 优点分析
  - 缺点分析
- 2.3 构造方法注入
- - 优点分析
  - 缺点分析
- 2.4 @Resource：另一种注入关键字
- 2.5 同一类型多个 @Bean 报错
- - 2.5.1 问题
  - 2.5.2 处理
  - - 1）使用 @Resource 的参数
    - 2）@Autowired 配合 @Qualifier 注解

前言

经过上篇的学习 (博客链接：https://blog.csdn.net/yyhgo_/article/details/128609134?spm=1001.2014.3001.5501)，我们已经可以实现基本的 Spring 存储和读取对象的操作了，但在操作的过程中我们发现存储和读取对象并没有想象中的那么“简单”，所以接下来我们要学习更加简单的操作 Bean 对象的方法。

在 Spring 中想要更简单的存储和读取对象的核心是使用注解，接下来我们要学习 Spring 中的相关注解，来存储和读取 Bean 对象。

一、存储 Bean 对象

之前我们存储 Bean 时，需要在 spring-config 中添加⼀行 bean 注册内容才行。而现在我们只需要⼀个注解就可以替代之前要写⼀⾏配置的尴尬了，不过在开始存储对象之前，我们先要来点准备工作。

1.1 前置工作：配置扫描路径 (重要)

注意：想要将对象成功的存储到 Spring 中，我们需要配置⼀下存储对象的扫描包路径，只有被配置的包下的所有类，添加了注解才能被正确的识别并保存到 Spring 中。

在 spring-config.xml 添加如下配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <content:component-scan base-package="yyh.service"></content:component-scan>
</beans>

其中：
在这里插入图片描述

也就是说，即使添加了注解，如果不是在配置的扫描包下的类对象，也是不能被存储到 Spring 中的。

这种方式与添加 <bean> 的方式可以同时使用，都能存储对象到 Spring 中 ~~

1.2 添加注解存储 Bean 对象

想要将对象存储在 Spring 中，有两种注解类型可以实现：

类注解：@Controller、@Service、@Repository、@Component、@Configuration
分别为 控制器存储、服务存储、仓库存储、组件存储、配置存储
方法注解：@Bean

1.2.1 五大类注解

以 @Controller 为例：

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

此时我们先使用之前读取对象的方式来读取上面的 UserController 对象，如下代码所示：

public class Application {
	public static void main(String[] args) {
		// 1.得到 spring 上下⽂
		ApplicationContext context = new ClassPathXmlApplicationContext("springconfig.xml");
		// 2.得到 bean
		UserController userController = context.getBean("userController", UserController.class);
		// 3.调⽤ bean ⽅法
		userController.sayHi("Bit");
	}
}

其余四类用法相同！

既然功能是⼀样的，为什么需要这么多的类注解呢？
这和为什么每个省/市都有自己的车牌号是⼀样的。这样做的一个重要作用是可以直观标识⼀辆车的归属地。
需要这么多的类注解也是相同的原因，就是让程序员看到类注解之后，就能直接了解当前类的用途：

@Controller：表示的是业务逻辑层
@Servie：服务层
@Repository：持久层
@Component：组件存储
@Configuration：配置层

程序的工程分层，调用流程如下：

比如进入一家银行，需要先进行一些安全检查 (Controller)。因为办理不同的业务要去不同的区域，所以需要先去服务台咨询一下 (Servie)。根据不同的业务需求，需要访问不同的数据库 (Repository)。
Component 一般是一些工具类；Configuration 一般是关于配置的。

查看 @Controller / @Service / @Repository / @Configuration 等注解的源码发现：

其实这些注解里面都有⼀个注解 @Component，说明它们本身就属于 @Component 的“子类”。

Bean 命名规则

通过上面示例，我们可以看出，通常我们 bean 使用的都是标准的大驼峰命名，而读取的时候首字母小写就可以获取到 bean 了，如下图所示：

在这里插入图片描述

然⽽，当我们首字母和第⼆个字母都是大写时，就不能正常读取到 bean 了，如下图所示：

在这里插入图片描述

这个时候，我们就要查询 Spring 关于 bean 存储时的命名规则了。

我们在 Idea 中搜索关键字 “beanName” 可以看到以下内容：

在这里插入图片描述

顺藤摸瓜，我们最后找到了 bean 对象的命名规则的方法：

在这里插入图片描述

它使⽤的是 JDK Introspector 中的 decapitalize 方法，源码如下：

public static String decapitalize(String name) {
	if (name == null || name.length() == 0) {
		return name;
	}
	// 如果第⼀个字⺟和第⼆个字⺟都为⼤写的情况，是把 bean 的⾸字⺟也⼤写存储了
	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);
}

所以对于上面报错的代码，我们只要改为以下代码就可以正常运行了：

在这里插入图片描述

1.2.2 方法注解 @Bean

类注解是添加到某个类上的，而方法注解是放到某个方法上的，如以下代码的实现：

public class Users {
	@Bean
	public User user1() {
		User user = new User();
		user.setId(1);
		user.setName("Java");
		return user;
	}
}

然而，当我们写完以上代码，尝试获取 bean 对象中的 user1 时却发现根本获取不到：

public class Application {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
		User user = (User) context.getBean("user1");
		System.out.println(user.toString());
	}
}

以上程序的执行结果如下：
在这里插入图片描述

这是为什么嘞？
方法注解要配合类注解使用！

在 Spring 框架的设计中，方法注解 @Bean 要配合类注解才能将对象正常存储到 Spring 容器中，如下代码所示：

@Component
public class Users {
	@Bean
	public User user1() {
		User user = new User();
		user.setId(1);
		user.setName("Java");
		return user;
	}
}

再次执行以上代码，运行结果如下：
在这里插入图片描述

注意：@Bean方法注解只能使用在无参的方法上 (Spring初始化存储时，没办法提供相应参数)。

Bean 命名规则与重命名

命名规则： id 为注解方法名！

重命名：
可以通过设置 name 属性给 Bean 对象进行重命名操作，如下代码所示：

@Component
public class Users {
	@Bean(name = {"u1"})
	public User user1() {
		User user = new User();
		user.setId(1);
		user.setName("Java");
		return user;
	}
}

此时我们使⽤ u1 就可以获取到 User 对象了，如下代码所示：

class App {
	public static void main(String[] args) {
		// 1.得到 spring 上下⽂
		ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
		// 2.得到某个 bean
		User user = (User) context.getBean("u1");
		// 3.调⽤ bean ⽅法
		System.out.println(user);
	}
}

有三种写法，例如：

Bean 重命名之后，使用方法名就不能获取Bean对象了！！！

二、获取 Bean 对象 (对象注入)

获取 bean 对象也叫作 对象装配，是把对象取出来放到某个类中，也叫 对象注入。
也就是之前所讲的 依赖注入(DI) 的一种 ~~

对象装配（对象注⼊）的实现⽅法以下 3 种：

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

接下来我们分别来看。我们按照实际开发中的模式，将 Service 类注入到 Controller 类中。

注意： 静态方法中不能使用对象注入。

所以启动类 main 方法中依然需要使用最初的获取上下文、getBean ~

2.1 属性注入

属性注入是使用 @Autowired 实现的，将 Service 类注入到 Controller 类中。

Service 类的实现代码如下：

import org.springframework.stereotype.Service;
@Service
public class UserService {
    /**
     * 根据 ID 获取⽤户数据
     *
     * @param id
     * @return
     */
    public User getUser(Integer id) {
        // 伪代码，不连接数据库
        User user = new User();
        user.setId(id);
        user.setName("Java-" + id);
        return user;
    }
}

Controller 类的实现代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class UserController {
    // 注⼊⽅法1：属性注⼊
    @Autowired
    private UserService userService;
    
    public User getUser(Integer id) {
        return userService.getUser(id);
    }
}

获取 Controller 中的 getUser 方法：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserControllerTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserController userController = context.getBean(UserController.class);
        System.out.println(userController.getUser(1).toString());
    }
}

最终结果如下：
在这里插入图片描述

属性注入的核心实现：
在这里插入图片描述

这是根据类来获取 Spring 中存储的 Bean。

优点分析

属性注入最大的优点就是实现简单、使用简单。 只需要给变量上添加一个注解（@Autowired），就可以在不 new 对象的情况下，直接获得注入的对象了（这就是 DI 的功能和魅力所在），所以它的优点就是使用简单。

缺点分析

然而，属性注入虽然使用简单，但也存在着很多问题，甚至编译器 Idea 都会提醒你“不建议使用此注入方式”，Idea 的提示信息如下：
在这里插入图片描述

属性注入的缺点主要包含以下 3 个：

功能性问题：无法注入一个不可变的对象（final 修饰的对象）；
通用性问题：只能适应于 IoC 容器；
设计原则问题：更容易违背单一设计原则。

接下来我们一一来看。

缺点1：功能性问题
使用属性注入无法注入一个不可变的对象（final 修饰的对象），如下图所示：
在这里插入图片描述
原因也很简单：在 Java 中 final 对象（不可变）要么直接赋值，要么在构造方法中赋值。 所以当使用属性注入 final 对象时，它不符合 Java 中 final 的使用规范，所以就不能注入成功了。

缺点2：通用性问题
使用属性注入的方式只适用于 IoC 框架（容器）。 如果将属性注入的代码移植到其他非 IoC 的框架中，那么代码就无效了，所以属性注入的通用性不是很好。

缺点3：设计原则问题
使用属性注入的方式，因为使用起来很简单，所以开发者很容易在一个类中同时注入多个对象，而这些对象的注入是否有必要？是否符合程序设计中的单一职责原则？就变成了一个问题。
但可以肯定的是，注入实现越简单，那么滥用它的概率也越大，所以出现违背单一职责原则的概率也越大。
注意：这里强调的是违背设计原则（单一职责）的可能性，而不是一定会违背设计原则， 二者有着本质的区别。

2.2 Setter 注入

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

@Controller
public class UserController3 {
    // 注⼊⽅法3：Setter注⼊
    private UserService userService;
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public User getUser(Integer id) {
        return userService.getUser(id);
    }
}

优点分析

从上面代码可以看出，Setter 注入比属性注入要麻烦很多。 要说 Setter 注入有什么优点的话，那么首当其冲的就是它完全符合单一职责的设计原则，因为每一个 Setter 只针对一个对象。

缺点分析

但它的缺点也很明显，它的缺点主要体现在以下 2 点：

不能注入不可变对象（final 修饰的对象）；
注入的对象可被修改。

接下来我们一一来看。

缺点1：不能注入不可变对象
使用 Setter 注入依然不能注入不可变对象，比如以下注入会报错：
在这里插入图片描述

缺点2：注入对象可被修改
Setter 注入提供了 setXXX 的方法，意味着你可以在任何时候、在任何地方，通过调用 setXXX 的方法来改变注入对象，所以 Setter 注入的问题是，被注入的对象可能随时被修改。

2.3 构造方法注入

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

@Controller
public class UserController2 {
    // 注⼊⽅法2：构造⽅法注⼊
    private UserService userService;

    @Autowired
    public UserController2(UserService userService) {
        this.userService = userService;
    }
    public User getUser(Integer id) {
        return userService.getUser(id);
    }
}

注意： 如果只有⼀个构造⽅法，那么 @Autowired 注解可以省略，如下图所示：

但是如果类中有多个构造方法，那么需要添加上 @Autowired 来明确指定到底使⽤哪个构造⽅法，且只能在一个构造方法上添加，否则程序会报错，如下图所示：

总结：
当有多个构造方法的时候，加了@Autowired 的构造方法才会执行，并且构造方法中的参数（对象）必须要存在于 Spring 容器中，否则就会报错。

优点分析

构造方法注入相比于前两种注入方法，它可以注入不可变对象，并且它只会执行一次，也不存在像 Setter 注入那样，被注入的对象随时被修改的情况，它的优点有以下 4 个：

可注入不可变对象；
注入对象不会被修改；
注入对象会被完全初始化；
通用性更好。

接下来我们一一来看。

优点1：注入不可变对象
使用构造方法注入可以注入不可变对象，如下代码所示：
在这里插入图片描述

优点2：注入对象不会被修改
构造方法注入不会像 Setter 注入那样，构造方法在对象创建时只会执行一次，因此它不存在注入对象被随时（调用）修改的情况。

优点3：完全初始化
因为依赖对象是在构造方法中执行的，而构造方法是在对象创建之初执行的，因此被注入的对象在使用之前，会被完全初始化，这也是构造方法注入的优点之一。

优点4：通用性更好
构造方法和属性注入不同，构造方法注入可适用于任何环境，无论是 IoC 框架还是非 IoC 框架，构造方法注入的代码都是通用的，所以它的通用性更好。
( 因为构造方法是 Java (JDK) 支持的【最底层的框架】，所以更换任何的上层框架，它都是适用的 )

缺点分析

构造方法的参数也可能会有多个对象，所以可能会出现违背单一职责原则的问题 ~~

2.4 @Resource：另一种注入关键字

在进行类注入时，除了可以使用 @Autowired 关键字之外，我们还可以使用 @Resource 进行注入，如以下代码所示：

@Controller
public class UserController {
    // 注⼊
    @Resource
    private UserService userService;
    
    public User getUser(Integer id) {
        return userService.getUser(id);
    }
}

@Autowired 和 @Resource 的区别：

出身不同：@Autowired 来自于 Spring，而 @Resource 来自于 JDK。
@Autowired 可用于属性注入、Setter 注入、构造方法注入；而 @Resource 只能用于 Setter 注入和属性注入，不能用于构造函数注入。
使用时设置的参数不同：相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如 name 设置：根据名称获取 Bean。
@Autowired 在搜索时先根据类找，再根据 id 找；@Resource 是先根据 id 找，再根据类找。

2.5 同一类型多个 @Bean 报错

2.5.1 问题

因为我们定义类时就尽量不会让类名重复；而方法返回值类型是很容易重复的，所以会出现同一类型多个 @Bean 报错的问题！

当出现以下多个 Bean，返回同⼀对象类型时程序会报错，如下代码所示：

@Component
public class Users {
    @Bean
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("Java");
        return user;
    }
    @Bean
    public User user2() {
        User user = new User();
        user.setId(2);
        user.setName("MySQL");
        return user;
    }
}

在另一个类中获取 User 对象，代码如下：

@Controller
public class UserController4 {
    // 注⼊
    @Resource
    private User user;
    
    public User getUser() {
        return user;
    }
}

以上程序的执行结果如下：
在这里插入图片描述
报错的原因是：非唯⼀的 Bean 对象。

2.5.2 处理

同一个类型，多个 bean 的问题有以下两个解决方案：

1）使用 @Resource 的参数

对比一下 @Resource 与 @Autowired 的参数列表：

@Resource 带上 name 参数，就可以根据 id 来找：

@Controller
class UserController4 {
    // 注⼊
    @Resource(name = "user1")
    private User user;
    
    public User getUser() {
        return user;
    }
}

2）@Autowired 配合 @Qualifier 注解

@Autowired 并没有提供更多参数，但是可以搭配 @Qualifier 使用 ~

@Controller
public class UserController5 {
    // 注⼊
    @Autowired
    @Qualifier(value = "user2")
    // 或者 @Qualifier("user2")
    private User user;
    
    public User getUser() {
        return user;
    }
}