当前位置： 首页 > article >正文

Spring 源码解读：手动实现自动装配与@Qualifier

article 2025/2/2 7:55:36

引言

自动装配（Autowiring）是Spring框架中用于简化依赖注入的一种机制，通过自动匹配类型或名称，将依赖注入到所需的Bean中。Spring提供了@Autowired和@Qualifier注解来支持自动装配。本文将通过手动实现自动装配机制，支持按类型和按名称注入，并与Spring中的@Autowired和@Qualifier注解进行对比，帮助你掌握自动装配的基本原理和使用方法。

自动装配的基本概念

在Spring中，自动装配是通过类型或名称将依赖Bean注入到目标Bean中的过程。通过自动装配，可以减少显式配置的工作量，提高代码的简洁性和可维护性。

自动装配的两种方式

  1. 按类型自动装配：

    • Spring容器根据依赖的类型查找与之匹配的Bean。
    • 如果有多个同类型的Bean，可能需要结合@Qualifier按名称进行区分。

  2. 按名称自动装配：

    • Spring容器根据Bean的名称查找与之匹配的Bean。
    • 通常与@Qualifier注解结合使用，指定注入的具体Bean。

手动实现自动装配机制

为了实现自动装配机制，我们需要：

  1. 定义一个注解@Autowired，用于标记自动装配的字段或方法。
  2. 实现一个支持自动装配的Bean工厂，负责按类型和按名称注入依赖。
  3. 实现一个注解@Qualifier，用于指定按名称自动装配的具体Bean。

定义@Autowired注解

@Autowired注解用于标记需要自动装配的字段、构造函数或方法。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Autowired注解，用于标记需要自动装配的字段、构造函数或方法
 */
@Target({ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Autowired {
}

定义@Qualifier注解

@Qualifier注解用于指定按名称自动装配的具体Bean。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Qualifier注解，用于指定按名称自动装配的具体Bean
 */
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Qualifier {
    String value();
}

实现支持自动装配的Bean工厂

AutowireCapableBeanFactory类扩展了通用的Bean工厂，增加了按类型和按名称自动装配的支持。

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

/**
 * 支持自动装配的Bean工厂
 */
public class AutowireCapableBeanFactory extends GenericBeanFactory {
    private Map<Class<?>, Object> typeMap = new HashMap<>(); // 按类型存储的Bean实例

    /**
     * 注册单例Bean
     * @param name Bean的名称
     * @param bean Bean实例
     */
    @Override
    public void registerSingleton(String name, Object bean) {
        super.registerSingleton(name, bean);
        typeMap.put(bean.getClass(), bean);
    }

    /**
     * 获取Bean实例并进行自动装配
     * @param name Bean的名称
     * @return 自动装配后的Bean实例
     */
    @Override
    public Object getBean(String name) {
        Object bean = super.getBean(name);
        if (bean != null) {
            autowireBean(bean);
        }
        return bean;
    }

    /**
     * 对Bean进行自动装配
     * @param bean 需要自动装配的Bean实例
     */
    private void autowireBean(Object bean) {
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Autowired.class)) {
                Object dependency = resolveDependency(field);
                if (dependency != null) {
                    field.setAccessible(true);
                    try {
                        field.set(bean, dependency);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException("Failed to autowire field: " + field.getName(), e);
                    }
                }
            }
        }
    }

    /**
     * 解析依赖项
     * @param field 被自动装配的字段
     * @return 依赖项的实例
     */
    private Object resolveDependency(Field field) {
        // 按类型查找依赖项
        Class<?> fieldType = field.getType();
        Object dependency = typeMap.get(fieldType);
        
        // 如果存在@Qualifier注解，则按名称查找
        if (field.isAnnotationPresent(Qualifier.class)) {
            String qualifierName = field.getAnnotation(Qualifier.class).value();
            dependency = getBean(qualifierName);
        }
        return dependency;
    }
}

创建测试类

我们通过一个简单的测试类来验证自动装配机制的实现。

/**
 * 服务接口
 */
interface Service {
    void serve();
}

/**
 * 服务实现A
 */
class ServiceA implements Service {
    @Override
    public void serve() {
        System.out.println("ServiceA is serving...");
    }
}

/**
 * 服务实现B
 */
class ServiceB implements Service {
    @Override
    public void serve() {
        System.out.println("ServiceB is serving...");
    }
}

/**
 * 客户端类，依赖于Service
 */
class Client {
    @Autowired
    @Qualifier("serviceB")
    private Service service;

    public void doSomething() {
        service.serve();
    }
}

/**
 * 配置类，用于测试自动装配
 */
public class AppConfig {
    public static void main(String[] args) {
        AutowireCapableBeanFactory beanFactory = new AutowireCapableBeanFactory();

        // 注册服务实现
        beanFactory.registerSingleton("serviceA", new ServiceA());
        beanFactory.registerSingleton("serviceB", new ServiceB());

        // 注册客户端Bean
        Client client = new Client();
        beanFactory.registerSingleton("client", client);

        // 获取并使用客户端Bean
        Client autowiredClient = (Client) beanFactory.getBean("client");
        autowiredClient.doSomething();
    }
}

测试结果：

  • 输出 ServiceB is serving... 表明通过@Autowired和@Qualifier成功实现了按类型和按名称的自动装配。

类图和流程图

为了更好地理解整个流程，我们提供了类图和流程图。

类图
BeanFactory
+Object getBean(String name)
GenericBeanFactory
+Object getBean(String name)
+void registerSingleton(String name, Object bean)
+void registerPrototype(String name, Supplier<Object> supplier)
AutowireCapableBeanFactory
+Object getBean(String name)
+void registerSingleton(String name, Object bean)
-void autowireBean(Object bean)
-Object resolveDependency(Field field)
«interface»
Service
+void serve()
ServiceA
+void serve()
ServiceB
+void serve()
Client
-Service service
+void doSomething()

解释：

  • BeanFactory是一个通用接口，定义了获取Bean实例的方法。
  • GenericBeanFactory实现了通用的Bean管理。
  • AutowireCapableBeanFactory扩展了GenericBeanFactory，增加了自动装配的功能。
  • Service是一个接口，ServiceA和ServiceB分别是其实现类。
  • Client类依赖于Service，通过自动装配注入具体的实现类。
流程图
否
是
是
否
AutowireCapableBeanFactory
根据名称获取Bean实例
对Bean进行自动装配
扫描Bean的字段
字段是否标注了 Autowired注解?
跳过自动装配
字段是否标注了 Qualifier注解?
按名称获取依赖项
按类型获取依赖项
注入依赖项
返回自动装配后的Bean实例

解释

：

  • 流程图展示了AutowireCapableBeanFactory如何通过扫描字段并按类型或名称自动装配依赖项的过程。

Spring中的@Autowired和@Qualifier注解

@Autowired注解的基本实现

在Spring中，@Autowired注解用于按类型自动装配Bean。Spring的AutowiredAnnotationBeanPostProcessor类负责处理@Autowired注解。

public class AutowiredAnnotationBeanPostProcessor implements BeanPostProcessor {
    // 处理@Autowired注解的方法
    @Override
    public Object postProcessPropertyValues(PropertyValues pvs, Object bean, String beanName) {
        // 通过反射获取Bean的字段并注入依赖
        for (Field field : bean.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(Autowired.class)) {
                // 注入依赖
            }
        }
        return bean;
    }
}

详细解读：

  • AutowiredAnnotationBeanPostProcessor类通过反射获取Bean的字段，检查是否标注了@Autowired注解，并按类型或名称注入依赖。

@Qualifier注解的基本实现

@Qualifier注解用于指定Bean的名称，当存在多个相同类型的Bean时，Spring通过@Qualifier区分具体的Bean。

@Component
public class MyService {
    @Autowired
    @Qualifier("specificBean")
    private AnotherService anotherService;
}

详细解读：

  • @Qualifier注解结合@Autowired使用，用于指定要注入的具体Bean的名称。

总结

通过手动实现自动装配机制，并深入解读Spring中的@Autowired和@Qualifier注解的基本实现，你应该对自动装配的概念和使用方法有了更深入的理解。在实际项目中，自动装配能够极大地简化Bean的依赖注入过程，使代码更加简洁和可维护，希望这些内容能帮助你更好地掌握Spring框架的相关知识。

互动与思考

在实际项目中，你是否经常使用@Autowired进行自动装配？在什么场景下你会使用@Qualifier来指定具体的Bean？欢迎在评论区分享你的看法和经验！

如果你觉得这篇文章对你有帮助，请别忘了：

  • 点赞 ⭐
  • 收藏 📁
  • 关注 👀

让我们一起深入学习Spring框架，成为更优秀的开发者！


http://www.kler.cn/a/286182.html

相关文章：

  • SARIMA介绍
  • Java小白入门教程：三种注释+快捷方式
  • 抽象类与抽象方法详解
  • 机器学习2 （笔记）（朴素贝叶斯，集成学习，KNN和matlab运用）
  • NVIDIA GPU介绍：概念、序列、核心、A100、H100
  • Sqoop源码修改：增加落地HDFS文件数与MapTask数量一致性检查
  • 低代码技术助力移动端开发：简化开发流程，实现快速创新
  • 算法设计与分析：实验五 图论——桥问题
  • 每日错题（2024年9月1日）
  • 经验笔记：Apache Kafka
  • python3.10安装
  • 【C++ Primer Plus习题】8.4
  • 六、vue进阶知识点
  • VastBase——VPatch版本控制
  • 使用docker file创建镜像（thirty-seven day）
  • 存储系统总结
  • MATLAB中save_system的用法
  • 【CSS】border-image 样式不生效 - 和谷歌浏览器版本有关系 - 谷歌 80 版本边框图片样式失效问题
  • 人该怎样活着呢？48
  • zdppy+vue3+onlyoffice文档管理系统实战 20240901 上课笔记 基于验证码登录功能基本完成
  • Excel 导入和导出--前后端整合
  • 【AI绘画教程】StableDiffusion真实系模型推荐，搭配ADetailer人脸修复插件，轻松生成真实故事大场景AI人像，让你的SD好用100倍！
  • 力扣9.1
  • 金风科技巴西风电装备制造基地正式投运
  • 大语言模型诞生、探索和爆发阶段
  • 借鉴腾讯系统架构从小到大的过程 - 如何做好一个系统设计？不限于(慧哥)慧知开源充电桩平台