蚂蚁1面：Spring 自动装配的方式有哪些？

发表于 更新于 分类于 阅读次数： 本文字数： 6.4k 阅读时长 ≈ 6 分钟

大家好呀，我是猿java。

自动装配是 Spring的一大核心功能，那么，Spring的自动装配有哪些方式？它们又是如何装配的呢？这篇文章，我们一起来探索一道蚂蚁的面试题：Spring 自动装配的方式有哪些？

1. 什么是自动装配？

在传统的 Java 应用中，我们常常需要手动创建和管理对象的依赖关系。这不仅麻烦，还容易出错。Spring 的自动装配功能，旨在通过自动识别和注入依赖，简化开发流程，提高代码的可维护性。

简单来说，自动装配就是让 Spring 自动完成对象之间的依赖关系注入，减少手动配置的工作量。

2. 自动装配的几种方式

Spring 提供了多种自动装配的方式，每种方式都有其适用的场景。接下来，我们逐一介绍。

2.1 按类型装配（By Type）

按类型装配通过匹配属性的类型，自动为属性注入合适的 Bean。

特点：

  • 简单易用
  • 依赖类型必须唯一，避免冲突

示例：

假设我们有一个 UserService 接口及其实现 UserServiceImpl，以及一个 UserController 需要注入 UserService。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// UserService.java
public interface UserService {
    void registerUser();
}

// UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void registerUser() {
        System.out.println("用户注册成功！");
    }
}

// UserController.java
@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void createUser() {
        userService.registerUser();
    }
}

在这个例子中，UserController 通过 @Autowired 注解，按类型自动装配了 UserService 的实现类 UserServiceImpl。

2.2 按名称装配（By Name）

按名称装配则是通过属性名匹配 Bean 的名称来进行注入。

特点：

  • 需要 Bean 名称与属性名一致
  • 适用于有多个同类型 Bean 的情况

示例：

假设我们有两个 UserService 的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// EmailUserService.java
@Service("emailUserService")
public class EmailUserService implements UserService {
    @Override
    public void registerUser() {
        System.out.println("通过电子邮件注册用户！");
    }
}

// SmsUserService.java
@Service("smsUserService")
public class SmsUserService implements UserService {
    @Override
    public void registerUser() {
        System.out.println("通过短信注册用户！");
    }
}

// UserController.java
@Controller
public class UserController {
    // 这里的属性名需要与 Bean 名称匹配
    @Autowired
    @Qualifier("emailUserService")
    private UserService userService;

    public void createUser() {
        userService.registerUser();
    }
}

在这个例子中，通过 @Qualifier 注解指定了 emailUserService，确保了按名称装配。

2.3 构造器装配（Constructor）

构造器装配通过构造方法来注入依赖，适合于需要强制依赖的场景。

特点：

  • 适用于不可变对象
  • 有助于编写测试代码

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void registerUser() {
        System.out.println("用户注册成功！");
    }
}

// UserController.java
@Controller
public class UserController {
    private final UserService userService;

    // 构造方法注入
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void createUser() {
        userService.registerUser();
    }
}

通过构造器注入，确保 UserController 在创建时必定拥有一个 UserService 实例。

2.4 使用 @Autowired 注解

@Autowired 是 Spring 提供的注解，用于标注需要自动装配的属性、构造器或方法。

特点：

  • 灵活性高
  • 支持按类型、按名称及构造器注入

示例：

除了之前的示例，@Autowired 还可以用于方法注入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// UserController.java
@Controller
public class UserController {
    private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void createUser() {
        userService.registerUser();
    }
}

这种方式通过 setter 方法进行依赖注入，提高了代码的可测试性。

3. 自动装配的原理解析

理解了自动装配的各种方式，接下来我们来看看背后的原理。

Spring 的自动装配主要依赖于 依赖注入（Dependency Injection, DI） 的概念。容器在启动时，会扫描配置的 Bean，通过反射和代理机制，将需要的依赖注入到目标对象中。

具体来说，当 Spring 容器发现一个 Bean 被标注了 @Autowired，它会：

  1. 检索容器中所有符合类型或名称的 Bean。
  2. 根据装配策略（按类型、按名称或构造器）选择合适的 Bean。
  3. 将选中的 Bean 注入到目标对象的相应属性或构造器参数中。

如果容器中存在多个符合条件的 Bean，Spring 会尝试通过 @Qualifier 或默认的 Bean 名称来区分，否则会抛出异常。

4. 示例

让我们通过一个简单的项目，实战演练一下 Spring 的自动装配。

项目结构

1
2
3
4
5
6
7
8
9
10
11
12
src
├── main
│   ├── java
│   │   └── com.example.autowiring
│   │       ├── Application.java
│   │       ├── controller
│   │       │   └── UserController.java
│   │       ├── service
│   │       │   ├── UserService.java
│   │       │   └── UserServiceImpl.java
│   └── resources
│       └── applicationContext.xml

1. 定义服务接口和实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// UserService.java
package com.example.autowiring.service;

public interface UserService {
    void registerUser();
}

// UserServiceImpl.java
package com.example.autowiring.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Override
    public void registerUser() {
        System.out.println("用户注册成功！");
    }
}

2. 定义控制器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// UserController.java
package com.example.autowiring.controller;

import com.example.autowiring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    // 自动装配 UserService
    @Autowired
    private UserService userService;

    public void createUser() {
        userService.registerUser();
    }
}

3. 配置 Spring 容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- applicationContext.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans     
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context 
           https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 开启自动扫描 -->
    <context:component-scan base-package="com.example.autowiring"/>

</beans>

4. 启动应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Application.java
package com.example.autowiring;

import com.example.autowiring.controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Application {
    public static void main(String[] args) {
        // 加载 Spring 配置
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 获取 UserController Bean
        UserController userController = context.getBean(UserController.class);

        // 调用方法
        userController.createUser();
    }
}

5. 运行结果

执行 Application.main() 方法后，控制台会输出：

1
用户注册成功！

这说明 UserController 成功地从 Spring 容器中自动装配了 UserServiceImpl，并调用了其 registerUser 方法。

5. 常见问题与优化建议

5.1 多个 Bean 冲突

当容器中存在多个相同类型的 Bean 时，按类型装配会导致冲突。解决方法包括：

  • 使用 @Qualifier 指定具体的 Bean 名称。
  • 使用 @Primary 标注一个默认的 Bean。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Service
@Primary
public class PrimaryUserServiceImpl implements UserService {
    @Override
    public void registerUser() {
        System.out.println("主用户服务实现！");
    }
}

@Service
public class SecondaryUserServiceImpl implements UserService {
    @Override
    public void registerUser() {
        System.out.println("次级用户服务实现！");
    }
}

// UserController.java
@Autowired
private UserService userService; // 将注入 PrimaryUserServiceImpl

5.2 循环依赖

如果两个 Bean 互相依赖，Spring 默认会尝试解决循环依赖，但有时会失败。避免循环依赖的最佳实践是：

  • 重构代码，减少 Bean 之间的紧耦合。
  • 使用 @Lazy 注解延迟加载 Bean。

6. 总结

本文，我们分析了 Spring 的自动装配机制，并且通过例子展示了不同方式的自动装配，自动装配是 Spring的核心功能，建议大家掌握原理。

如果你对某种自动装配方式有更深入的兴趣，欢迎评论区留言讨论！

7. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing