前言
前面的文章详细的介绍了 Spring 对象的创建，以及对 Bean 对象的存取操作，但是通过配置文件注册 Bean 对象以及使用 ApplicationContext 或 BeanFactory 的方式获取 Bean 对象的操作就显得格外的复杂。因此，本文主要就是详细介绍了一种更加简单的方式来实现对 Bean 对象更加简单的储存和读取操作。
在 Spring 中，要想更加简单的实现对 Bean 对象的储存和使用，其核心就是使用注解，本文主要就是演示如何使用注解实现对 Bean 对象的存取操作。
一、使用注解储存 Bean 对象
在之前储存 Bean 对象的时候，还需在 spring-congig 文件中添加一行 <bean> 内容才行，而且，每需要新增一个 Bean 对象到 Spring 容器中就需要新增一行，这样的操作就显得非常麻烦了。
而现在只需要使用一个注解就能代替这一行 <bean> 内容，此时就变得非常方便。想要通过注解的方式将对象储存到 Spring 容器中，主要有两种注解类型可以实现：
-
使用类注解（五大类注解）:
@Controller（控制储存）：验证用户请求的数据合法性，相当于安保系统；@Service（服务储存）：用于编排和调度具体的执行方法；@Repository（仓库储存）：持久层，与数据库进行交换；@Component（组件储存）：相当于工具类；@Configuration（配置储存）：项目中的一些配置。
-
使用方法注解：
@Bean：作用在方法上，需要配合上述的类注解使用。
但在此之前还需要配置一下扫描路径。
1.1 配置扫描路径
在 spring-config.xml文件中添加如下一行记录：
其含义是，指定一个 base package，即所有需要添加到 Spring 容器中的 Bean 对象都在 base package 所指定包或者其子包下。这里我知道的包是com.spring.demo，那么就意味着，如果不是此包下的 Bean 对象，即使加上了注解，也不会被添加到 Spring 容器中。
1.2 类注解储存 Bean 对象
1.2.1 @Controller（控制器存储）
使用 @Controller 注解储存 Bean 对象：
@Controller
public class StudentController1 {
public void sayHi(){
System.out.println("do studentController1 sayHi().");
}
}
使用 ApplicationContext的方式获取 Bean 对象：
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
StudentController1 studentController1 =
context.getBean("studentController1", StudentController1.class);
studentController1.sayHi();
}
关于 Bean 对象的命名规则可见后文。
1.2.2 @Service（服务储存）
使用 @Service 注解储存 Bean 对象：
@Service
public class StudentController2 {
public void sayHi(){
System.out.println("do studentController2 sayHi().");
}
}
获取 Bean 对象：
StudentController2 studentController2 =
context.getBean("studentController2", StudentController2.class);
1.2.3 @Repository（仓库存储）
使用 @Repository 注解储存 Bean 对象：
@Repository
public class StudentController3 {
public void sayHi(){
System.out.println("do studentController3 sayHi().");
}
}
获取 Bean 对象：
StudentController3 studentController3 =
context.getBean("studentController3", StudentController3.class);
1.2.4 @Component（组件储存）
使用 @Component 注解储存 Bean 对象：
@Component
public class StudentController4 {
public void sayHi(){
System.out.println("do studentController4 sayHi().");
}
}
获取 Bean 对象：
StudentController4 studentController4 =
context.getBean("studentController4", StudentController4.class);
1.2.5 @Configuration（配置储存）
使用 @Configuration 注解储存 Bean 对象：
@Configuration
public class StudentController5 {
public void sayHi(){
System.out.println("do studentController5 sayHi().");
}
}
获取 Bean 对象：
StudentController5 studentController5 =
context.getBean("studentController5", StudentController5.class);
1.2.6 Bean 命名规则
通过上述代码可以发现，在创建 Bean 对象的时候，都是使用的标准 “大驼峰” 的命名方式，而读取的时候 Bean 的名称则是其类名称的首字母小写，即小驼峰。
但是，此时创建一个 SController 类，并使用注解将其添加到 Spring 容器中，那么此时它的 Bean 对象的名称是什么呢？根据上面代码的规律，难道还是SController 吗？
SController sController = context.getBean("sController", SController.class);
当运行程序的时候，发现报错了：
其意思是不存在名称为 sController 这样 Bean 对象。此时如果将其改成 SController，会是正确的吗？
此时发现便能正常运行了。
关于 Bean 的名称生成的源码：
- 查找 beanname，选择
AnnotationBeanNameGenerator类
- 继续查找
- 继续查找
4. 找到了源码，即Introspector类下的decapitalize 方法
该方法通过检查字符串的首字母是否为大写，并且第二个字符也是大写的情况下，直接返回原字符串，不做小写化处理。这样做是为了避免一些特殊情况下，例如缩写或首字母缩写词，不被误处理。
1.3 五大类注解的作用
在Spring框架中，五大类常用的注解，分别是：@Component、@Controller、@Service、@Repository和@Configuration。
-
@Component： 通用的组件注解，表示类是一个Spring管理的组件（Bean）。 -
@Controller： 用于标识控制器类，通常用于Spring MVC中，处理HTTP请求和视图渲染。 -
@Service： 用于标识服务类，表示该类提供一些业务逻辑处理。 -
@Repository： 用于标识仓库类，表示该类用于数据访问，通常与数据库交互。 -
@Configuration： 用于标识配置类，表示该类包含Spring配置信息，通常与@Bean一起使用，用于定义 Bean。
1.3.1 为什么有这么多的注解
通过上面代码的演示，发现这些注解的功能都是一样的，既然都是一样的为什么还需要有这么多不同的注解呢？
Spring 之所以提供这么多的注解，是为了更好的组织和管理应用程序的组件和依赖关系。因为每个注解都有自己特定的用途，让开发人员在应用程序中能够更方便地标识和区分不同类型的类。同时也提现了程序的工程分层：
- 其中
@Controller表示的是控制层，负责与用户进行交互，以及验证用户提交数据的合法性； @Service表示的是服务层，用于编排和调度具体的执行方法，相当于车站中的服务台；@Repository表示的是持久层，负责将数据持久化储存，通常需要与数据库进行交互。
以上三个层次实现了程序的工程分层，同时也是 Java EE 标准分层的最核心分层。
1.3.2 类注解之间的关系
-
查看
@Controller / @Service / @Repository / @Configuration等注解的源码发现：
它们都是 @Component子类注解，这意味着，被标注为@Controller / @Service / @Repository / @Configuration的类也被视为@Component。 -
另外，
@Configuration注解是一个特殊的注解，它表明该类是 Spring 的配置类，用于定义 Bean 和配置应用程序的其他元素。配置类中的@Bean注解用于定义 Bean。
1.4 方法注解储存 Bean 对象
首先创建一个 User 实体类：
package com.spring.demo.entity;
/**
* 普通的用户实体类
*/
public class User {
private Integer uid;
private String username;
private String password;
private Integer age;
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"uid=" + uid +
", username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
'}';
}
}
1.4.1 @Bean 注解的使用
创建一个组件类 UserBeans，并使用方法注解 @Bean 将 User 类添加到 Spring 容器中：
@Controller
public class UserBeans {
@Bean
public User getUser(){
User user = new User();
user.setUid(1);
user.setUsername("王五");
user.setPassword("123456");
user.setAge(18);
return user;
}
}
注意，使用方法注解 @Bean 的时候需要搭配五大类注解才能生效。
获取 Bean 对象：
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
User user = context.getBean("getUser", User.class);
System.out.println(user);
}
注意，当使用方法注解@Bean 的时候，Bean 对象的默认名称就是其 添加到 Spring 容器中的方法名。
1.4.2 Bean 对象重命名
如果直接使用方法名作为 Bean 对象的名称，例如getUser就显得非常的不合理，因此往往需要对 Bean 进行改名操作。但查看@Bean源码的时候可以发现，其中的name或 value属性是一个数组，那么就意味着可以一个 Bean 对象取多个名称。
例如：
此时，可通过这两个名称，获取该 Bean 对象，发现它们是同一个 Bean：
另外需要注意的是，如果对 Bean 进行了重命名，则原来默认的方法名就失效了。
二、使用注解获取 Bean 对象
2.1 Bean 对象通过注解获取的方法
获取 Bean 对象也叫做对象装配，即把对象取出来放到某个类当中，同时也叫做对象注入。
对象注入的实现方式有以下三种：
-
属性注入：属性注入是通过在属性上使用注解实现的。常见的注解有
@Autowired和@Resource。属性注入是在 Bean 对象的属性上直接进行注入，不需要提供setter方法。 -
Setter注入：Setter注入是通过在 Bean 对象的setter方法上使用注解实现的。这种注入方式是在调用 Bean 的setter方法时，将依赖对象作为参数传入。 -
构造方法注入：构造方法注入是通过在 Bean 对象的构造方法上使用注解实现的。这种注入方式是在创建 Bean 对象的时候，通过构造方法参数传入依赖对象。
2.2 三种注入方法的使用
下⾯按照实际开发中的模式，将 Service 类注入到 Controller 类中，然后通过 main 方法获取 Controller 中的 Bean 对象。
首先创建一个 UserService 类和 UserController 类：
@Service
public class UserService {
public void sayHi(){
System.out.println("hi, userService.");
}
}
2.2.1 属性注入
@Controller
public class UserController {
// 1. 属性注入
@Autowired
private UserService userService;
public void sayHi(){
System.out.println("do userController sayHi().");
userService.sayHi();
}
}
2.2.2 Setter 注入
@Controller
public class UserController {
// 2. setter 注入
private UserService userService;
@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}
public void sayHi(){
System.out.println("do userController sayHi().");
userService.sayHi();
}
}
2.2.3 构造方法注入
@Controller
public class UserController {
// 3. 构造方法注入
private UserService userService;
// @Autowired
public UserController(UserService userService) {
this.userService = userService;
}
public void sayHi(){
System.out.println("do userController sayHi().");
userService.sayHi();
}
}
注意，如果此时只有一个构造方法，则@Autowired 可以省略。
2.3 三种注入方法的优缺点
属性注入
- 优点：简洁，代码量少，适合对属性直接注入的情况；
- 缺点：
- 对于必须注入的属性，如果没有找到匹配的Bean，会导致运行时错误；
- 兼容不好，只能用于 IoC 容器；
- 没办法实现
finally修饰的变量实现注入； - 过于简单，容易违背单一设计原则。
Setter注入：
-
优点：符合单一设计原则，每个方法只能传递一个对象。
-
缺点：
- 没办法实现
finally修饰的变量实现注入； - 使用 Setter 注入的对象可能会被修改。
- 没办法实现
构造方法注入：
-
优点：
- 可以实现
finally修饰的变量实现注入； - 注入的对象不会被改变，即构造方法只能执行一次；
- 构造方法注入可以保证注入对象完全被初始化。
- 可以实现
-
缺点：构造方法参数较多时，代码显得冗长。
2.4 @Resource 注入
在进行类注入时，除了可以使用 @Autowired 关键字之外，我们还可以使用 @Resource 进行注入，如下代码所示：
属性注入：
public class UserController {
// 1. 属性注入
@Resource
private UserService userService;
public void sayHi(){
System.out.println("do userController sayHi().");
userService.sayHi();
}
}
Setter注入：
@Controller
public class UserController {
// 2. setter 注入
private UserService userService;
@Resource
public void setUserService(UserService userService) {
this.userService = userService;
}
public void sayHi(){
System.out.println("do userController sayHi().");
userService.sayHi();
}
}
遗憾的是，@Resource 不支持构造方法注入：
2.5 @Autowired 和 @ Resource的区别
@Autowired是 Spring 框架提供的注解，而@Resource是JSR-250规范提供的注解，但是 Spring 也对其进行了支持。@Autowired默认按照类型装配 Bean，如果多个类型匹配，可以配合@Qualifier注解指定具体的 Bean 名称。而@Resource默认按照属性名进行装配，可以通过 name 属性指定具体的 Bean 名称。@Autowired是 Spring 的专有注解，更加灵活，功能更强大。@Resource是标准的 Java 注解，适用于更通用的情况@Autowired可用于Setter注入、构造函数注入和属性注入，而@Resource只能用于Setter注入和属性注入，不能用于构造函数注入。
2.6 注入同一类型的多个 @Bean 报错问题
当存在多个类型相同的 Bean 对象，并且需要通过注解将其注入到其他 Bean 对象中时，如果没有明确指定注入哪个 Bean，就会导致报错。
2.6.1 报错问题
例如，通过 Component 中的 UserBeans 将 User 注入到 Controller 中的 UserController 中。
首先，在UserBeans 使用@Bean 添加两个 User 对象到 Spring 容器中：
@Controller
public class UserBeans {
@Bean(name = {
"user1", "u1"})
public User getUser1(){
User user = new User();
user.setUid(1);
user.setUsername("张三");
user.setPassword("123456");
user.setAge(18);
return user;
}
@Bean(name = "user2")
public User getUser2(){
User user = new User();
user.setUid(1);
user.setUsername("李四");
user.setPassword("123456");
user.setAge(18);
return user;
}
}
在 UserController 中分别使用 @Autowired 和 @Resource注入获取 Bean 对象：
@Autowired：
此时，由于存在两个相同类型的 Bean 对象，但是其名称不同，所以使用@Autowired注解不知道获取哪个对象。
@Resource
使用@Resource注解同样无法判断获取哪一个对象。
关于
@Autowired和@Resource查找 Bean 对象的顺序：
@Autowired首先按照类型查找，然后再按照名称查找；@Resource首先按照名称查找，然后再按照类型查找。
2.6.2 使用 @Resource(name=“XXX”) 解决
@Controller
public class UserController {
@Resource(name = "user1")
private User user;
public void sayHi(){
System.out.println("do userController sayHi().");
}
}
2.6.3 @Autowired 配合使用 @Qualifier 解决
@Controller
public class UserController {
@Autowired
@Qualifier(value = "user1")
private User user;
public void sayHi() {
System.out.println("do userController sayHi().");
}
}