Spring 注解配置原理

声明

源码基于Spring 5.0.8

1. 简介

自从Spring Boot流行,基于注解的配置逐渐取代了XML配置。因为突然而来的兴趣从而阅读了Spring 对Configuration注解的解析流程。

2. 原理介绍

解析@Configuration的入口是ConfigurationClassPostProcessorConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor接口,使得Spring在初始过程中动态的向容器注册bean。Spring会在容器初始过程中执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法。

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    /*
     * 省略边角代码
     */
    // 核心处理逻辑
    processConfigBeanDefinitions(registry);
}

因为接下来的逻辑相当的复杂,因此在继续往下分析之前,先总体介绍下工作流程以及相关类。Spring将整个工作过程分为两个阶段。解析阶段以及注册阶段。解析阶段由ConfigurationClassParser这个类负责,然后将解析结果交给ConfigurationClassBeanDefinitionReader注册到容器中。其中在解析阶段会将解析的信息保存到ConfigurationClass这个类中。主要将解析以下内容

  • 首先判断这个配置类需不需要解析,对应条件注解@Conditional以及各种变体,如@ConditionalOnClass等。
  • 以同样逻辑解析配置类中的内部类,当然这些内部类得是一个配置类。
  • 解析配置类上的@PropertySource注解,将外部属性保存到全局环境Environment对象中。
  • 处理配置类上的@ComponentScan注解,相当于开启@Component注解扫描。
  • 解析配置类上的@Import注解。
  • 解析配置类上的@ImportResource注解,这个注解用于导入以前的XML方式配置的bean。
  • 解析配置类中的@Bean方法。
  • 以同样逻辑继续解析配置类的超类。
  • 解析完成后将该配置类加入到结果集合中。

@Import注解可用来导入外部的注解配置或者可以动态的注册bean。主要分为3大类

  1. 导入类实现了ImportSelector接口或者子接口DeferredImportSelectorselectImports方法将会返回一个字符串数组。值为类的完全限定名。ImportSelectorDeferredImportSelector主要区别在于selectImports执行顺序。一个在解析过程中执行,一个在配置类解析完成后执行。这样selectImports选择的类将会在配置类后面,注册bean的顺序也会按照这个顺序注册。Spring Boot中的自动配置类AutoConfigurationImportSelector就实现了DeferredImportSelector接口,再根据条件注解判断用户自己有没有配置,没有配置才去装配bean。
  2. 导入类实现了ImportBeanDefinitionRegistrar,用于动态注入bean。
  3. 配置类,相当于引入另外一个配置类。

Spring将单个配置类解析得到的信息全部保存在ConfigurationClass类中,最后得到一个LinkedHashMap,键和值都是ConfigurationClass。下面介绍ConfigurationClass这个类的结构。

final class ConfigurationClass {
    // 配置类的元数据
    private final AnnotationMetadata metadata;
    // 配置类的.class文件表示
    private final Resource resource;
    // bean的名字
    private String beanName;
    // 记录该配置类被哪些别的配置类导入过
    private final Set<ConfigurationClass> importedBy = new LinkedHashSet<>(1);
    // 配置类中所有被@Bean标记的方法
    private final Set<BeanMethod> beanMethods = new LinkedHashSet<>();
    // @ImportResource
    private final Map<String, Class<? extends BeanDefinitionReader>> importedResources =
            new LinkedHashMap<>();
    // @Import中的第二种
    private final Map<ImportBeanDefinitionRegistrar, AnnotationMetadata>                                              importBeanDefinitionRegistrars = new LinkedHashMap<>();
    // 用来存放哪些bean方法可以被跳过
    final Set<String> skippedBeanMethods = new HashSet<>();
}

接下来举一个例子,看下最后保存的结果。

public class User {

}

@Configuration
public class AnotherConfig {

}

public class SimpleRegistrars implements ImportBeanDefinitionRegistrar {

}

@Configuration
@Import({AnotherConfig.class, SimpleRegistrars.class})
public class AppConfig {

    @Bean
    public User user() {
        retur new User();
    }
}

AppConfig为解析起点将会得到以下结果。

3. 源码解析

继续看processConfigBeanDefinitions方法

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    // 从容器中拿到所有已经注册过的bean
    String[] candidateNames = registry.getBeanDefinitionNames();

    // 筛选出配置,不是所有的bean都是一个配置类的。
    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        // 已经解析过了, 跳过
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
            ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Bean definition has already been processed "
                            + "as a configuration class: " + beanDef);
            }
        }
        /*
         * 判断是不是一个配置类
         * 判断规则如下
         * 1. 类上有没有@Configuration
         * 2. 类上有没有@Component、@ComponentScan、@Import、@ImportResource
         * 3. 类中有没有定义@Bean 方法
         * 三个条件满足任意一个即可,可见Spring并没有强制要求配置类一定要有@Configuration
         * 值得注意的是@Bean方法注册的bean不能作为配置类,因为其注册的BeanDefinition
         * 没有beanClassName, 通过工厂方法生成。checkConfigurationClassCandidate方法开头存在
         * 以下判断
         * String className = beanDef.getBeanClassName();
         * if (className == null || beanDef.getFactoryMethodName() != null) {
         *  return false;
         * }
         */
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(
            beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    // Return immediately if no @Configuration classes were found
    if (configCandidates.isEmpty()) {
        return;
    }

    // Sort by previously determined @Order value, if applicable
    configCandidates.sort((bd1, bd2) -> {
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
    });

    // Detect any custom bean name generation strategy supplied through the enclosing application context
    SingletonBeanRegistry sbr = null;
    if (registry instanceof SingletonBeanRegistry) {
        sbr = (SingletonBeanRegistry) registry;
        if (!this.localBeanNameGeneratorSet) {
            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
            if (generator != null) {
                this.componentScanBeanNameGenerator = generator;
                this.importBeanNameGenerator = generator;
            }
        }
    }

    if (this.environment == null) {
        this.environment = new StandardEnvironment();
    }

    // 准备解析配置类
    ConfigurationClassParser parser = new ConfigurationClassParser(
        this.metadataReaderFactory, this.problemReporter, this.environment,
        this.resourceLoader, this.componentScanBeanNameGenerator, registry);
    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    do {
        // 解析目前所有的配置类,将结果保存到configurationClasses字段中
        parser.parse(candidates);
        // 校验,诸如配置类不能是final, bean 方法不能是private、final等。
        parser.validate();
        // 获取解析结果
        Set<ConfigurationClass> configClasses = new LinkedHashSet<>
            (parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);

        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                registry, this.sourceExtractor, this.resourceLoader, this.environment,
                this.importBeanNameGenerator, parser.getImportRegistry());
        }
        // 注册bean
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);

        candidates.clear();
        // 从新注册的bean里挑选新的配置类,开始一轮新的的解析、注册流程。
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames();
            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
            Set<String> alreadyParsedClasses = new HashSet<>();
            for (ConfigurationClass configurationClass : alreadyParsed) {
                alreadyParsedClasses.add(configurationClass
                                         .getMetadata().getClassName());
            }
            for (String candidateName : newCandidateNames) {
                if (!oldCandidateNames.contains(candidateName)) {
                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(
                            bd, this.metadataReaderFactory) &&
                        !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
                    }
                }
            }
            candidateNames = newCandidateNames;
        }
    }
    while (!candidates.isEmpty());

    // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
    if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
        sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
    }

    if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
        // Clear cache in externally provided MetadataReaderFactory; this is a no-op
        // for a shared cache since it'll be cleared by the ApplicationContext.
        ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
    }
}

接下将分析解析阶段以及注册阶段。

3.1 解析阶段

解析类: ConfigurationClassParser

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    // 用于记录Import注解引入的类, 这个类需要实现DeferredImportSelector接口
    this.deferredImportSelectors = new LinkedList<>();

    for (BeanDefinitionHolder holder : configCandidates) {
        BeanDefinition bd = holder.getBeanDefinition();
        try {
            if (bd instanceof AnnotatedBeanDefinition) {
                parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
            }
            else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
            }
            else {
                parse(bd.getBeanClassName(), holder.getBeanName());
            }
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(
                "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
        }
    }
    // 执行DeferredImportSelector接口的selectImports方法
    // 这里就体现了DeferredImportSelector 与 ImportSelector接口的执行顺序问题
    processDeferredImportSelectors();
}

/**
 * 上面所有的parse方法最终都会调用这个方法。
 * Spring 将条件注解分为两种类型
 * 1. ConfigurationPhase.PARSE_CONFIGURATION
 *    这个条件注解在解析阶段就生效,如果条件不满足将不再解析这个配置类,相当于作废
 * 2. ConfigurationPhase.REGISTER_BEAN
 *    如果条件不满足,不会影响Spring解析这个配置类,但是在向容器中注册bean的时候生效。
 *    如果条件不满足,那么自身,以及Import注解引入的类,以及bean 方法等都不会被注入到容器中。
 *    唯一不影响的只有@PropertySource注解引入的属性配置,依然会加入到全局环境中。
 *    所以其实解析后的只有@PropertySource有效,其他的解析内容到真正注册的时候其实都没用了。
 */
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    // 判断条件是否满足,只有ConfigurationPhase.PARSE_CONFIGURATION的条件才生效
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(),
                                           ConfigurationPhase.PARSE_CONFIGURATION)) {
        return;
    }

    // 判断这个类是否之前已经解析了
    // 因为可能有多个类导入了同一个类等特殊情况
    ConfigurationClass existingClass = this.configurationClasses.get(configClass);
    if (existingClass != null) {
        // 如果这个类是别的类导入进来的
        if (configClass.isImported()) {
            if (existingClass.isImported()) {
                // 将导入这个类的类加入到importedBy集合中
                existingClass.mergeImportedBy(configClass);
            }
            return;
        }
        else {
            // 删除掉,重新解析这个新的类
            this.configurationClasses.remove(configClass);
            this.knownSuperclasses.values().removeIf(configClass::equals);
        }
    }

    // Recursively process the configuration class and its superclass hierarchy.
    SourceClass sourceClass = asSourceClass(configClass);
    do {
        // 开始真正解析工作
        sourceClass = doProcessConfigurationClass(configClass, sourceClass);
    }
    while (sourceClass != null);
    // 解析完成,加入到结果集合中
    this.configurationClasses.put(configClass, configClass);
}
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
            throws IOException {

        // 处理成员类
        processMemberClasses(configClass, sourceClass);

        // 处理@PropertySource引入的外部属性配置, 加入到全局环境对象
        for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
                sourceClass.getMetadata(), PropertySources.class,
                org.springframework.context.annotation.PropertySource.class)) {
            if (this.environment instanceof ConfigurableEnvironment) {
                processPropertySource(propertySource);
            }
            else {
                logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                        "]. Reason: Environment must implement ConfigurableEnvironment");
            }
        }

        /*
         * 处理包扫描,将扫描的结果直接注册到容器中。主要借助ClassPathBeanDefinitionScanner
         * 来完成。可参考这篇文章[Spring包扫描机制详解]
         * 地址: https://www.cnblogs.com/wt20/p/10990697.html
         */
        Set<AnnotationAttributes> componentScans = AnnotationConfigUtils
            .attributesForRepeatable(sourceClass.getMetadata(),
            ComponentScans.class, ComponentScan.class);
        // 因为会直接注册了,所以检测条件注解用的是ConfigurationPhase.REGISTER_BEAN
        if (!componentScans.isEmpty() && !this.conditionEvaluator
            .shouldSkip(sourceClass.getMetadata(),
                    ConfigurationPhase.REGISTER_BEAN)) {
            for (AnnotationAttributes componentScan : componentScans) {
                // The config class is annotated with @ComponentScan -> perform the scan immediately
                Set<BeanDefinitionHolder> scannedBeanDefinitions =
                        this.componentScanParser.parse(
                    componentScan, sourceClass.getMetadata().getClassName());
                // Check the set of scanned definitions for any further config classes and parse recursively if needed
                for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    // 作为一个新的配置类解析
                    if (ConfigurationClassUtils.checkConfigurationClass
                        Candidate(bdCand, this.metadataReaderFactory)) {
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }

        // 处理@Import注解
        processImports(configClass, sourceClass, getImports(sourceClass), true);

        // 处理@ImportResource
        AnnotationAttributes importResource =
                AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
        if (importResource != null) {
            String[] resources = importResource.getStringArray("locations");
            Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
            for (String resource : resources) {
                String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
                configClass.addImportedResource(resolvedResource, readerClass);
            }
        }

        // 处理 @Bean 方法
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

        // Process default methods on interfaces
        processInterfaces(configClass, sourceClass);

        // 处理父类
        if (sourceClass.getMetadata().hasSuperClass()) {
            String superclass = sourceClass.getMetadata().getSuperClassName();
            if (superclass != null && !superclass.startsWith("java") &&
                    !this.knownSuperclasses.containsKey(superclass)) {
                this.knownSuperclasses.put(superclass, configClass);
                // Superclass found, return its annotation metadata and recurse
                return sourceClass.getSuperClass();
            }
        }
        // No superclass -> processing is complete
        return null;
    }

3.2 注册阶段

注册类: ConfigurationClassBeanDefinitionReader

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
    for (ConfigurationClass configClass : configurationModel) {
        loadBeanDefinitionsForConfigurationClass(configClass,
                                                 trackedConditionEvaluator);
    }
}

private void loadBeanDefinitionsForConfigurationClass(
            ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    // 判断条件注解, 接下面
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        // 如果不满足,将从容器中删除,如果存在的话
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return;
    }
    // 如果是被导入进来的,需要注册自己。
    // 如果不是被导入进来的,在解析前就已经在容器里了。
    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }
    // 注册 @Bean方法
    // 这里值得注意的是,如果两个@Bean方法注册的Bean的名字一样,并且不是在同一个配置类中
    // 将会进行覆盖。具体细节看这个方法吧
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }
    // 注册外部引入的XML文件定义的bean
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    // 处理@Import注解中的第二种情况, 即被导入类实现了ImportBeanDefinitionRegistrar接口
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
/**
 * 前面说过条件注解可以分阶段生效,如果配置类上面的条件是注册阶段才生效,即使不满足这个条件也会进行
 * 解析。而到了现在注册阶段,将会生效。使得不会被注册到容器中
 */
public boolean shouldSkip(ConfigurationClass configClass) {
            // 拿缓存
            Boolean skip = this.skipped.get(configClass);
            if (skip == null) {
                // 如果这个配置类是从别的配置类导入进来的,要先检查这些配置类的条件注解
                if (configClass.isImported()) {
                    boolean allSkipped = true;
                    // 遍历所有导入过这个配置类的其他类
                    for (ConfigurationClass importedBy : configClass.getImportedBy()) {
                        // 只要有一个导入过这个配置的其他类是有效的,那么前提条件通过,接下
                        // 来还要判断自己本身的条件
                        // 先将标记改为false
                        if (!shouldSkip(importedBy)) {
                            allSkipped = false;
                            break;
                        }
                    }
                    // 如果所有导入过这个配置的其他类都是无效的,那么这个类也无效
                    if (allSkipped) {
                        skip = true;
                    }
                }
                // 判断自身条件
                if (skip == null) {
                    skip = conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN);
                }
                this.skipped.put(configClass, skip);
            }
            return skip;
        }
    }

总结

本文对源码关键地方进行了分析,但是很多细节并没有深究。尽管如此,也是弄清楚了整个工作流程,方便以后碰到问题或者有疑惑时可以快速定位到代码查看具体的处理细节。不得不说整个逻辑真的太复杂了,Spring 考虑的太全面了。

原文地址:https://www.cnblogs.com/wt20/p/11823783.html

时间: 2024-10-31 19:53:29

Spring 注解配置原理的相关文章

spring注解配置quartz

常规配置quartz可以参考我的另外一篇博文:http://www.cnblogs.com/yangzhilong/p/3349116.html spring配置文件里增加: 命令空间: http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd 配置: <task:annotation-driven/> 当然这还需要扫描注解等常规配置. ja

spring注解配置quartz应用

项目中会经常用到定时器,因此,其quartz的使用,我们必须要掌握.下面就以例子来讲解如何在spring中整合quartz, 使用注解配置的方式来实现定时执行任务. 一.引入jar包 项目中需引入quartz的jar包,由于整合到spring中,肯定也引入了spring的相关jar包. 例子中引用的是quartz-2.1.1版本,使用maven管理项目,pom文件需引入quartz依赖 二.spring配置文件中配置 (applicationContext.xml) 1)      xmlns和

关于Spring注解配置的步骤

今天分享一下 关于Spring注解配置的流程 1 导包:如下图所示 2 书写User和Car类  代码如下 package cn.lijun.bean; public class Car { private String name; private String color; public String getName() { return name; } public void setName(String name) { this.name = name; } public String g

0808 Spring 注解配置

 summarize 注解配置将替换手动 Spring 注解配置 导包 配置约束 eclipse导入spring配置文件约束.可能你觉得这种配置文件网上一大堆,直接复制粘贴就搞定了,可是假如你去的是某些机密单位呢?所以多学点总归是好的!这篇文章是本人全部手工写出来的,没有盗用其他人的图片和文字信息等,转载请注明出处,谢谢! 点击window选择Preferences选项,搜索catalog 点击add 选中file System找自己下载好的spring的解压包下的schema文件夹,点进去选择

spring注解配置启动过程

最近看起spring源码,突然想知道没有web.xml的配置,spring是怎么通过一个继承于AbstractAnnotationConfigDispatcherServletInitializer的类来启动自己的.鉴于能力有限以及第一次看源码和发博客,不到之处请望谅~ 我用的IDE是IntelliJ IDEA,这个比myEclipse看源码方便一点,而且黑色背景挺喜欢.然后项目是在maven下的tomcat7插件运行.spring版本是4.3.2.RELEASE. 如果写过纯注解配置的spri

Spring -- 注解配置Bean

通过注解配置Bean 特定组件包括: @Component: 基本注解, 标识了一个受 Spring 管理的组件 @Respository: 标识持久层组件 @Service: 标识服务层(业务层)组件 @Controller: 标识表现层组件 上面的组件可以混用,因为IOC容器并无法区分当前类是否为业务.持久.还是表现层. 对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称 使用注解配置Bean前,我们

5.spring:注解配置 Bean

在classpath中扫描组件 组键扫描:能够从classpath下自动扫描,侦测和实例化具有特定注解的组件 特定的组件包括: ->@Componment:基于注解,标识一个受Spring管理的组键 ->@Respository:标识持久层组件 ->@Service:标识服务层 ->@controller:标识表现层组件 对于扫描到的组件,Spring有默认的命名策略,使用非限定类名,第一个字母小写,也可以通过注解中value属性值标识组建的名称 在classpath中扫描组键当在

Spring注解配置事务管理——问题

在上下文中配置: <!-- 配置注解驱动的Spring MVC控制器编程模型. --> <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /

Spring 注解配置(2)——@Autowired

版权声明:本文为博主原创文章,如需转载请标注转载地址. 博客地址:http://www.cnblogs.com/caoyc/p/5626365.html  @Autowired 注释,它可以对类成员变量.方法及构造函数进行标注,完成自动装配的工作. 通过 @Autowired的使用来消除 set ,get方法.在使用@Autowired之前,我们对一个bean配置起属性时,是这用用的 <property name="属性名" value=" 属性值"/>