Spring中如何用注解方式存取JavaBean？有几种注入方式？

╰半夏微凉° 2024-03-18 00:38 61阅读 0赞

![d7633f7109da40b58ef42644826d4da9.gif][]

>  *  **博主简介：想进大厂的打工人**
>  *  **博主主页：**[@xyk:][xyk]
>  *  **所属专栏: [JavaEE进阶][JavaEE]**

本篇文章将讲解如何在spring中使用注解的方式来存取Bean对象，spring提供了多种注入对象的方式，**常见的注入方式包括 构造函数注入，Setter 方法注入和属性注入**，不同的注入方式都有优缺点，下面我们来讲解一下~~

--------------------

**目录**

文章目录

一、使用注解方式的前提

1.1 前置工作

1.2 什么是注解？

二、spring基于注解存储Bean对象

2.1 类注解方式

2.2 如何读取Bean对象？

2.3 读取Bean对象时的命名规则

2.4 方法注解方式

三、基于注解获取Bean对象（对象装配）

3.1 属性注入

3.2 Setter方法注入

3.3 构造方法注入

3.4 三种注入方式的优缺点：

缺点3：设计原则问题

优点3：完全初始化

优点4：通用性更好

四、@Resource另⼀种注⼊关键字

4.1 @Autowired 和 @Resource 的区别

4.2 同⼀类型多个 Bean 报错处理

--------------------

## **一、使用注解方式的前提** ##

### 1.1 前置工作 ###

在我们使用注解方式来存储 Bean对象 的前提，我们要先将配置文件写好，因为在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="com.demo"/>
        
    </beans>

![6f9682bffd344ad193ff10a635b3a9f0.png][]

其中 **base-package** 中的路径对应你项目中的包名即可

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

**pom.xml：**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.example</groupId>
        <artifactId>spring-demo1</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
        </properties>
    
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.3.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>5.2.3.RELEASE</version>
            </dependency>
        </dependencies>
    </project>

### 1.2 什么是注解？ ###

注解就是代码中的特殊标记，无需在xml中配置繁琐的Bean对象代码，注解可以作用在类、方法、属性上。spring 针对 Bean对象的管理提供了注解方式，在 spring中，注解可以分为两大类：

1.  **类注解：** 以下四个注解都可以用来创建bean实例，只是为了便于开发者清晰区分当前层。
2.  **方法注解：@Bean**

*  @Controller：表示的是业务逻辑层；
 *  @Service：服务层；
 *  @Repository：持久层；
 *  @Configuration：配置层;
 *  @Component：组件层

**为什么需要这么多个类注解呢？**

这是因为让程序猿看到类注解之后，就能直接了解当前类的用途，也是为了开发更加方便~

![ac26ece425ef4c17aadcc9c2a2054086.png][]

在我们查看上面类注解的源码中，可以发现：

![679261d3d6fe411bbaa2e24b18e80bbc.png][]

其实这些注解⾥⾯都有⼀个注解 @Component，说明它们本身就是属于 @Component 的“⼦类”

## 二、spring基于注解存储Bean对象 ##

### 2.1 类注解方式 ###

**@Controller 控制器存储**

@Controller
    public class BController {
        public String sayHi() {
            return "Hi,Controler.";
        }
    }

**@Service 服务存储**

@Service
    public class StudentService {
        public void sayHi(){
            System.out.println("Hi,Service");
        }
    }

**@Repository 仓库存储**

@Repository
    public class UserRepository {
        public String sayHi(){
            return "Hi,@Repository";
        }
    }

**@Component 组件存储**

@Component
    public class UserComponent {
        public String sayHi() {
            return "Hi,@Component.";
        }
    }

**@Configuration 配置存储**

@Configuration
    public class UserConfiguration {
        public String sayHi(){
            return "Hi,@Configuration";
        }
    }

### 2.2 如何读取Bean对象？ ###

这里以读取 BController 对象为例， 由于前两个首字母都是大写的，所以我们使用原类名就可以读取到相应的 JavaBean 了。

![fd6c9009d3d34854adee239e45c36574.png][]

![48742dfb1837451dac8fecb692278e3c.png][]

那如果我们的首字母不大写，或者只有一个字母大写会发生什么？

### 2.3 读取Bean对象时的命名规则 ###

这个时候，我们就要查询 Spring 关于 bean 存储时⽣成的命名规则了。我们可以在 Idea 中使⽤搜索关键字“beanName”可以看到以下内容。  
![32cd974ce8fe47d7a536a2de8150ff96.png][]

![e943a7a9cbb0445aa8e9a07c6723d51a.png][]

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

public static String decapitalize(String name) {
            if (name == null || name.length() == 0) {
                return name;
            }
            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.  如果第⼀个字⺟和第⼆个字⺟都为⼤写的情况，是把 bean 的⾸字⺟也⼤写存储了
> 2.  其他的命名规则都是首字母小写即可（默认）

如果不遵守这个规则的话，可是会报错的，如下：找不到此Bean对象

![51ad4556fd60465bad381b5d685612cb.png][]

### 2.4 方法注解方式 ###

类注解用于标记类为Spring Bean，使用@ComponentScan扫描时，**每个注解只会创建一个Bean对象，因此在同一个ApplicationContext容器中，获得的对象是同一个。**

**那么如果想要获取不同的对象怎么办呢？** 下面我们就来聊一聊方法注解~

顾名思义，⽅法注解就是是放到某个⽅法上的，以下是简单的代码实现：需要注意的是 **⽅法注解 @Bean 要配合类注解才能将对象正常的存储到 Spring 容器中**

@Component
    public class StudentBeans {
    
        //    @Bean(name = {"s1", "s2"})
        @Bean
        public Student student1() {
            // 伪代码，构建对象
            Student stu = new Student();
            stu.setId(1);
            stu.setName("张三");
            stu.setAge(18);
            return stu;
        }
    
        @Bean
        public Student student2() {
            // 伪代码，构建对象
            Student stu = new Student();
            stu.setId(2);
            stu.setName("李四");
            stu.setAge(20);
            return stu;
        }
    
    }

public class App {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
            Student student = context.getBean("student1",Student.class);
            System.out.println(student);
    
            Student student2 = context.getBean("student2",Student.class);
            System.out.println(student2);
        }
    }

![f1d50d3ca71b445dac2be5bba863f48a.png][]

@Bean默认情况下，Bean name = 方法名

## 三、基于注解获取Bean对象（对象装配） ##

获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注⼊。

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

1.  属性注⼊
2.  构造⽅法注⼊
3.  Setter 注⼊

不同的注入方式有不同的适用场景和优缺点。以下案例则以将 Service 类注⼊到 Controller 类中为切入点，帮助大家了解三种注入方式的优缺点和区别~

### 3.1 属性注入 ###

Controller

@Controller
    public class BController {
        
        @Autowired
        private StudentService studentService;
        
        public void sayHi() {
            studentService.sayHi();
        }
    }

Service

@Service
    public class StudentService {
        public void sayHi(){
            System.out.println("Hi,Service");
        }
    }

此时，通过如下的代码，即可通过 Controller 的 sayHello() 方法调用 service 中的 sayHi() 方法。其余两种装配实现方式，该部分代码等同，Service 也等同，就不再赘述了。

public class App {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
            BController controller = context.getBean("BController",BController.class);
            controller.sayHi();
        }
    }

![be25a4b1f43d4d6c9dbbb849d60b417b.png][]

### 3.2 Setter方法注入 ###

即，在 setter 方法前加上 @Autowired 注解。

@Controller
    public class BController {
        
        private StudentService studentService;
    
        @Autowired
        public void setStudentService(StudentService studentService){
            this.studentService = studentService;
        }
    
        public void sayHi() {
            studentService.sayHi();
        }
    }

### 3.3 构造方法注入 ###

构造⽅法注⼊是在类的构造⽅法中实现注⼊。在类中添加带有参数的构造方法，Spring会根据参数类型和名称，在容器中找到相应的Bean进行注入。**特别地，如果只有⼀个构造⽅法，那么 @Autowired 注解可以省略~**

@Controller
    public class BController {
    
        private StudentService studentService;
    
        @Autowired
        public BController(StudentService studentService){
            this.studentService = studentService;
        }
    
        public void sayHi() {
            studentService.sayHi();
        }
    }

### 3.4 三种注入方式的优缺点： ###

1.属性注入最大的优点就是实现简单、使用简单

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

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

缺点1：功能性问题

**使用属性注入无法注入一个不可变的对象（final 修饰的对象）**，如下图所示：

![2156cd57889049b6a5bfa0df895d5958.png][]

> 原因也很简单：**在 Java 中 final 对象（不可变）要么直接赋值，要么在构造方法中赋值，所以当使用属性注入 final 对象时，它不符合 Java 中 final 的使用规范，所以就不能注入成功了。**
> 
> 如果要注入一个不可变的对象，要怎么实现呢？使用下面的构造方法注入即可。

缺点2：通用性问题

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

##### 缺点3：设计原则问题 #####

单一设计原则 定义: 就一个类而言, 应该仅有一个引起它变化的原因。单一设计原则就是自己只负责自己的事,不需要去关心别人的事。

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

2.Setter 注入的优缺点

**要说 Setter 注入有什么优点的话，那么首当其冲的就是它完全符合单一职责的设计原则，因为每一个 Setter 只针对一个对象**。

它的缺点主要体现在以下 2 点：

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

![9aa29849a1f64874be21a4c8d6956117.png][]

缺点2：注入对象可被修改

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

3. 构造方法注入的优缺点

**构造方法注入是 Spring 官方从 4.x 之后推荐的注入方式。**

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

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

![6f7439a615e3410a8b4731c300012c0d.png][]

**优点2：注入对象不会被修改**

因为加了final关键字，而且构造方法注入不会像 Setter 注入那样，**构造方法在对象创建时只会执行一次，因此它不存在注入对象被随时（调用）修改的情况。**

##### 优点3：完全初始化 #####

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

##### 优点4：通用性更好 #####

构造方法和属性注入不同，构造方法注入可适用于任何环境，无论是 IoC 框架还是非 IoC 框架，构造方法注入的代码都是通用的，所以它的通用性更好。

## 四、@Resource另⼀种注⼊关键字 ##

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

@Controller
    public class BController {
    
        @Resource
        private StudentService studentService;
    
        public void sayHi() {
            studentService.sayHi();
        }
    }

### 4.1 @Autowired 和 @Resource 的区别 ###

1.  出身不同：@Autowired 来⾃于 Spring，⽽ @Resource 来⾃于 JDK 的注解；
2.  使⽤时设置的参数不同：相⽐于 @Autowired 来说它只支持required，@Resource ⽀持更多的参数设置，例如name 设置，根据名称获取 Bean。
3.  @Autowired 可⽤于 Setter 注⼊、构造函数注⼊和属性注⼊，⽽ @Resource 只能⽤于 Setter 注⼊和属性注⼊，不能⽤于构造函数注⼊

### 4.2 同⼀类型多个 Bean 报错处理 ###

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

@Component
    class UserComponent {
        @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 UserController {
        // 注⼊
        @Resource
        private User user;
        public User getUser() {
            return user;
        }
    }

解决同⼀个类型，多个 bean 的解决⽅案有以下两个：

1.  使⽤ @Resource(name="user1") 定义。
2.  使⽤ @Qualifier 注解定义名称，结合@Autowired

**使⽤ @Resource(name="XXX")**

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

**使⽤ @Qualifier**

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

@Qualifier中value可以省略~

--------------------

![13d31ffed52c4c3a91aa41a4bd0ef81d.gif][]

##  ##

创作不易，欢迎大家私信我，一起探讨问题~

[d7633f7109da40b58ef42644826d4da9.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/964fbe270d2f4bd4b7f0cfb9c7f55d9f.png
[xyk]: https://blog.csdn.net/asad21654864?spm=1000.2115.3001.5343
[JavaEE]: http://t.csdn.cn/SpyLE
[6f9682bffd344ad193ff10a635b3a9f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ec1a80d544a641dd8904aff81e5a9546.png
[ac26ece425ef4c17aadcc9c2a2054086.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c96ff65ef4bb49e580a72bdf45ec933a.png
[679261d3d6fe411bbaa2e24b18e80bbc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5b8c11b81c7a484f87241226dc9ef816.png
[fd6c9009d3d34854adee239e45c36574.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7630cccb574b42e7aefee9ffe8ab2d84.png
[48742dfb1837451dac8fecb692278e3c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3c546c43f41a495db414b7943e7315d1.png
[32cd974ce8fe47d7a536a2de8150ff96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/bc6a5eff6c1e469dbc5dcc943dae575d.png
[e943a7a9cbb0445aa8e9a07c6723d51a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1135932f5474493c82528db5d4bd42da.png
[51ad4556fd60465bad381b5d685612cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ff383053299a4f6ca710fe7d46b96477.png
[f1d50d3ca71b445dac2be5bba863f48a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/d806f85c00324e98beffb1db6d38392d.png
[be25a4b1f43d4d6c9dbbb849d60b417b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f7a852df73264fc088724c6e18fda598.png
[2156cd57889049b6a5bfa0df895d5958.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0a881761788940db9af3283a65ed3c9e.png
[9aa29849a1f64874be21a4c8d6956117.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1c3c1a882295429a80b54e2e773e6bf6.png
[6f7439a615e3410a8b4731c300012c0d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4ef314d099b84c2783afdf90daeb2d91.png
[13d31ffed52c4c3a91aa41a4bd0ef81d.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/094b79ae60a74b2fb0faa5598a333c5b.png