Spring ④ Autowired 注解依赖注入详解

已于 2024-07-19 08:58:23 修改
阅读量36 收藏
点赞数
文章标签： spring java 后端 spring boot 开发语言
于 2023-01-28 20:31:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45839894/article/details/128788190
版权

spring-logo.png

Spring ④ Autowired 注解依赖注入详解 | 看不懂你打我

Spring 源码系列文章会遵循由浅入深,由易到难,由宏观到微观的原则,目标是尽量降低学习难度,而不是一上来就迷失在源码当中. 文章会从一个场景作为出发点，针对性的目的性极强的针对该场景对 Spring 的实现原理，源码进行探究学习。该系列文章会让你收获什么? 从对 Spring 的使用者成为 Spring 专家。该文章会同步在微信公众号 【DevXJava】, 方便在微信客户端阅读。

本章的内容是对 bean 创建过程中依赖项注入的探究，为了不扩散问题域本章只针对 @Autowired 注解进行讲解分析。本章会讲解 构造器注入 、 属性注入 、 方法注入 、 Optional 、 ObjectFactory 、 ObjectProvider 、 JSR330 类型的属性注入。方式遵循前几期，会通过最简单的案例场景带入去叫讲解 spring 的实现原理。

在开始今天的内容之前先回顾一下上期的内容, bean 的创建过程大致经历了三步, createBeanInstance 创建 bean 的实例对象。 populateBean 填充bean，依赖注入发生在这个阶段（大部分场景是，但一些特殊场景的依赖注入并不在这个阶段进行比如构造器注入）。 initializeBean 进行 bean 的一些初始化过程。了解了这个 bean 创建的大致过程会对读者理解本期的内容起帮助作用。

image.png

构造器注入

构造器注入过程发生在 bean 对象的实例化阶段，是和对象的实例化同时进行的，因为是通过构造器注入 bean 的实例化过程也是通过构造器。

构造器注入场景
public class AutowiredConstructorInjectionExp {

    public static void main(String[] args) {
        // 构造器注入

        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        processor.setBeanFactory(factory);
        factory.addBeanPostProcessor(processor);

        factory.registerBeanDefinition("bean1" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean1.class)
                .getBeanDefinition());

        factory.registerBeanDefinition("bean2" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean2.class)
                .getBeanDefinition());

        Bean1 bean1 = factory.getBean(Bean1.class);
        System.out.println("bean1 -> " + bean1);
    }

    @Data
    static class Bean1 {

        Bean2 bean2;

        public Bean1(Bean2 bean2) {
            this.bean2 = bean2;
            System.out.println("======================== bean1 实例化");
        }
    }

    static class Bean2 {

        public Bean2() {
            System.out.println("++++++++++++++++++++++++++ bean2 实例化");
        }
    }
}
构造器注入 autowireConstructor

构造器注入的关键点在 determineConstructorsFromBeanPostProcessors 和 autowireConstructor . 接下来会着重探讨这两个方法。

image.png

determineConstructorsFromBeanPostProcessors
/**
 * Determine candidate constructors to use for the given bean, checking all registered
 * {@link SmartInstantiationAwareBeanPostProcessor SmartInstantiationAwareBeanPostProcessors}.
 * @param beanClass the raw class of the bean
 * @param beanName the name of the bean
 * @return the candidate constructors, or {@code null} if none specified
 * @throws org.springframework.beans.BeansException in case of errors
 * @see org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors
 */
@Nullable
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
      throws BeansException {

   if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
      for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
         Constructor<?>[] ctors = bp.determineCandidateConstructors(beanClass, beanName);
         if (ctors != null) {
            return ctors;
         }
      }
   }
   return null;
}

在 determineConstructorsFromBeanPostProcessors 中调用了 SmartInstantiationAwareBeanPostProcessor 的 determineCandidateConstructors 方法。在场景代码中我们创建了 AutowiredAnnotationBeanPostProcessor 实例，并把它注册到 AbstractBeanFactory 中。这样就可以由它来起到探测构造器的功能。

image.png

determineConstructorsFromBeanPostProcessors 会得到多个构造器， autowireConstructor 会对这些构造器进行筛选找到一个合适匹配的构造器。

autowireConstructor
/**
 * "autowire constructor" (with constructor arguments by type) behavior.
 * Also applied if explicit constructor argument values are specified,
 * matching all remaining arguments with beans from the bean factory.
 * <p>This corresponds to constructor injection: In this mode, a Spring
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param ctors the chosen candidate constructors
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (implying the use of constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 */
protected BeanWrapper autowireConstructor(
                String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {

    return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

由于 ConstructorResolver 方法 autowireConstructor 源码较为繁琐就不进行逐一讲解，有兴趣的读者可以自己阅读源码。这里列出几个关键方法 ConstructorResolver#createArgumentArray , ConstructorResolver.resolveAutowiredArgument , AutowireCapableBeanFactory#resolveDependency , ConstructorResolver#instantiate 和说明简图方便读者阅读源码时有针对性的查看。

image.png

AutowiredAnnotationBeanPostProcessor

在讲解 属性注入 和 方法注入 前我们先认识一下 AutowiredAnnotationBeanPostProcessor bean 后置处理器 , @Autowired 注解之所以可以起作用就是因为它在背后提供支持。 AutowiredAnnotationBeanPostProcessor 实现了很多的 bean 后置处理器接口，其中有一个方法 InstantiationAwareBeanPostProcessor#postProcessProperties 我们会着重进行讲解，它是和依赖注入密不可分的。

通过 AutowiredAnnotationBeanPostProcessor 完成依赖注入的都是发生在 populateBean 阶段（也就是 bean 的填充阶段）。

image.png

属性注入和方法注入

属性注入和方法注入十分的类似可以放在一起讲解。

属性注入场景

public class AutowiredFieldInjectionExp {

    public static void main(String[] args) {

        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        processor.setBeanFactory(factory);
        factory.addBeanPostProcessor(processor);

        factory.registerBeanDefinition("bean1" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean1.class)
                .getBeanDefinition());

        factory.registerBeanDefinition("bean2" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean2.class)
                .getBeanDefinition());

        Bean1 bean1 = factory.getBean(Bean1.class);
        System.out.println("bean1 -> " + bean1);

    }

    @Data
    static class Bean1 {

        @Autowired
        Bean2 bean2;

        public Bean1() {
            System.out.println("======================== bean1 实例化");
        }
    }

    static class Bean2 {

        public Bean2() {
            System.out.println("++++++++++++++++++++++++++ bean2 实例化");
        }
    }

}

方法注入场景

public class AutowiredMethodInjectionExp {

    public static void main(String[] args) {

        // 方法注入
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        processor.setBeanFactory(factory);
        factory.addBeanPostProcessor(processor);

        factory.registerBeanDefinition("bean1" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean1.class)
                .getBeanDefinition());

        factory.registerBeanDefinition("bean2" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean2.class)
                .getBeanDefinition());

        Bean1 bean1 = factory.getBean(Bean1.class);
        System.out.println("bean1 -> " + bean1);
    }

    @ToString
    static class Bean1 {

        Bean2 bean2;

        @Autowired
        public void setBean2(Bean2 bean2) {
            this.bean2 = bean2;
        }
    }

    static class Bean2 {

        public Bean2() {
            System.out.println("++++++++++++++++++++++++++ bean2 实例化");
        }
    }
}

对源码 debug 我们可以发现在执行 AutowiredAnnotationBeanPostProcessor#postProcessProperties 之前 Bean1 中的 bean2 属性为 null . 并且 instantiationAware 中只有一个元素 AutowiredAnnotationBeanPostProcessor 对象. 我们已经尽可能的排除了干扰.

image.png

在执行了 AutowiredAnnotationBeanPostProcessor#postProcessProperties 之后 bean2 属性已经有值了. 接下来我们会重点看 postProcessProperties 方法中都做了什么。

image.png

AutowiredAnnotationBeanPostProcessor#postProcessProperties

image.png

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
   InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
   try {
      metadata.inject(bean, beanName, pvs);
   }
   catch (BeanCreationException ex) {
      throw ex;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
   }
   return pvs;
}
findAutowiringMetadata
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
   // Fall back to class name as cache key, for backwards compatibility with custom callers.
   String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
   // Quick check on the concurrent map first, with minimal locking.
   InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
   if (InjectionMetadata.needsRefresh(metadata, clazz)) {
      synchronized (this.injectionMetadataCache) {
         metadata = this.injectionMetadataCache.get(cacheKey);
         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            if (metadata != null) {
               metadata.clear(pvs);
            }
            metadata = buildAutowiringMetadata(clazz);
            this.injectionMetadataCache.put(cacheKey, metadata);
         }
      }
   }
   return metadata;
}
buildAutowiringMetadata
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
   if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
      return InjectionMetadata.EMPTY;
   }

   List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
   Class<?> targetClass = clazz;

   do {
      final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

      ReflectionUtils.doWithLocalFields(targetClass, field -> {
         MergedAnnotation<?> ann = findAutowiredAnnotation(field);
         if (ann != null) {
            if (Modifier.isStatic(field.getModifiers())) {
               if (logger.isInfoEnabled()) {
                  logger.info("Autowired annotation is not supported on static fields: " + field);
               }
               return;
            }
            boolean required = determineRequiredStatus(ann);
            currElements.add(new AutowiredFieldElement(field, required));
         }
      });

      ReflectionUtils.doWithLocalMethods(targetClass, method -> {
         Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
         if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
            return;
         }
         MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
         if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
            if (Modifier.isStatic(method.getModifiers())) {
               if (logger.isInfoEnabled()) {
                  logger.info("Autowired annotation is not supported on static methods: " + method);
               }
               return;
            }
            if (method.getParameterCount() == 0) {
               if (logger.isInfoEnabled()) {
                  logger.info("Autowired annotation should only be used on methods with parameters: " +
                        method);
               }
            }
            boolean required = determineRequiredStatus(ann);
            PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
            currElements.add(new AutowiredMethodElement(method, required, pd));
         }
      });

      elements.addAll(0, currElements);
      targetClass = targetClass.getSuperclass();
   }
   while (targetClass != null && targetClass != Object.class);

   return InjectionMetadata.forElements(elements, clazz);
}
InjectionMetadata#inject

不同的注入元素有不同的注入方式实现, 属性注入 为 AutowiredFieldElement , 方法注入 为 AutowiredMethodElement .

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
   Collection<InjectedElement> checkedElements = this.checkedElements;
   Collection<InjectedElement> elementsToIterate =
         (checkedElements != null ? checkedElements : this.injectedElements);
   if (!elementsToIterate.isEmpty()) {
      for (InjectedElement element : elementsToIterate) {
         element.inject(target, beanName, pvs);
      }
   }
}
AutowiredFieldElement#inject
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
   Field field = (Field) this.member;
   Object value;
   if (this.cached) {
      try {
         value = resolvedCachedArgument(beanName, this.cachedFieldValue);
      }
      catch (NoSuchBeanDefinitionException ex) {
         // Unexpected removal of target bean for cached argument -> re-resolve
         value = resolveFieldValue(field, bean, beanName);
      }
   }
   else {
      value = resolveFieldValue(field, bean, beanName);
   }
   if (value != null) {
      ReflectionUtils.makeAccessible(field);
      field.set(bean, value);
   }
}
AutowiredMethodElement#inject
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
   if (checkPropertySkipping(pvs)) {
      return;
   }
   Method method = (Method) this.member;
   Object[] arguments;
   if (this.cached) {
      try {
         arguments = resolveCachedArguments(beanName);
      }
      catch (NoSuchBeanDefinitionException ex) {
         // Unexpected removal of target bean for cached argument -> re-resolve
         arguments = resolveMethodArguments(method, bean, beanName);
      }
   }
   else {
      arguments = resolveMethodArguments(method, bean, beanName);
   }
   if (arguments != null) {
      try {
         ReflectionUtils.makeAccessible(method);
         method.invoke(bean, arguments);
      }
      catch (InvocationTargetException ex) {
         throw ex.getTargetException();
      }
   }
}

Optional 、 ObjectFactory 、 ObjectProvider 、 JSR330 类型的注入

由于这部分较为简单容易理解就只做简单介绍。其中 ObjectFactory 、 ObjectProvider 、 JSR330 这三类其实是起到了延迟加载的作用。核心代码在 org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency 方法。

场景

public class AutowiredOtherTypeInjectionExp {

    public static void main(String[] args) {
        // `Optional` 、`ObjectFactory` 、`ObjectProvider` 、`JSR330` 类型的注入

        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        processor.setBeanFactory(factory);
        factory.addBeanPostProcessor(processor);

        factory.registerBeanDefinition("bean1" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean1.class)
                .getBeanDefinition());

        factory.registerBeanDefinition("bean2" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean2.class)
                .getBeanDefinition());

        factory.registerBeanDefinition("bean3" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean3.class)
                .getBeanDefinition());

        factory.registerBeanDefinition("bean4" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean4.class)
                .getBeanDefinition());

        factory.registerBeanDefinition("bean5" , BeanDefinitionBuilder
                .genericBeanDefinition(Bean5.class)
                .getBeanDefinition());

        Bean1 bean1 = factory.getBean(Bean1.class);
        System.out.println("bean1 -> " + bean1);
    }

    @Data
    static class Bean1 {

        @Autowired
        Optional<Bean2> bean2;

        @Autowired
        ObjectFactory<Bean3> bean3;

        @Autowired
        ObjectProvider<Bean4> bean4;

        @Autowired
        Provider<Bean5> bean5;

        public Bean1() {
            System.out.println("======================== bean1 实例化");
        }
    }

    static class Bean2 {

        public Bean2() {
            System.out.println("++++++++++++++++++++++++++ bean2 实例化");
        }
    }

    static class Bean3 {
        public Bean3() {
            System.out.println("++++++++++++++++++++++++++ Bean3 实例化");
        }
    }

    static class Bean4 {
        public Bean4() {
            System.out.println("++++++++++++++++++++++++++ Bean4 实例化");
        }
    }

    static class Bean5 {
        public Bean5() {
            System.out.println("++++++++++++++++++++++++++ Bean5 实例化");
        }
    }
}

DefaultListableBeanFactory#resolveDependency

@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

   descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
   if (Optional.class == descriptor.getDependencyType()) {
      return createOptionalDependency(descriptor, requestingBeanName);
   }
   else if (ObjectFactory.class == descriptor.getDependencyType() ||
         ObjectProvider.class == descriptor.getDependencyType()) {
      return new DependencyObjectProvider(descriptor, requestingBeanName);
   }
   else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
      return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
   }
   else {
      Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
            descriptor, requestingBeanName);
      if (result == null) {
         result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
      }
      return result;
   }
}

DevXTalk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring中@Autowired注解的工作原理
m0_67393157的博客
08-02 396
Autowired注解大家再熟悉不过了，在项目中使用@Autowired注解的比例非常高，可以说基本用过Spring的同学都接触过这个注解，因此，我们有必要详细了解一下其工作原理。@Autowired注解的作用是帮我们注入我们需要的对象，Spring会自动按照类型注入，只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功。在分析这个注解的实现原理之前，我们不妨先来回顾一下@Autowired注解的用法。找出需要自动装配的元素httpshttpshttps。...
详解Java Spring各种依赖注入注解的区别
09-02
在Spring中，有多种注解用于实现依赖注入，如@Autowired、@Resource、@Qualifier、@Service、@Controller、@Repository和@Component。下面将详细阐述这些注解的区别和用法。 1. @Autowired：Spring 自带的注解，...
一文搞懂Spring @Autowired注解的使用及其原理
MarkusZhang的博客
02-12 1万+
依赖注入（DI）是Spring核心特性之一，而@Autowired也是我们日常高频使用的Spring依赖注入方式之一，因此有必要对它的使用以及原理做一个全面的掌握。本文从@Autowired使用、原理入手记录，并扩展延伸Spring中其他具备注入功能的注解。
spring-@Autowired注入与构造函数注入使用
smile
07-30 2万+
前言 因为业务关系也看了些同事写的代码，因为公司没有明确规定，有一部分人在注入依赖的时候使用了用Spring推荐的构造器注入的方式，一部分人使用了@Autowired的注解进行注入。 因此，接下来我试着总结归纳一下相关的情况，做一次回顾。 用自己的话去说出来才算是真的掌握。 使用介绍 1.@Autowired注入 @RestController @RequestMapping("/test") public class TestController { @Autowired .
[spring] 注解@Autowired是如何实现的
热门推荐
topdeveloperr的博客
03-19 4万+
Table of Contents 前言 @Autowired注解用法 @Autowired注解的作用到底是什么 @Autowired注解是如何实现的 例子注解@Override 自己实现一个注解 @Autowired注解实现逻辑分析 问题 注解的有效周期是什么？ 注入的bean和用它的bean的关系是如何维护的？ 前言 使用spring开发时，进行配置主要有两种方式，一是...
【Spring】依赖注入(DI)时常用的注解@Autowired和@Value
m0_65277261的博客
04-15 1453
如果是非SpringBoot配置文件，需要额外通过@PropertySource去指定属性文件的类路径，如果是SpringBoot配置文件(application.properties)，就无需额外配置@PropertySource。
在spring-boot中使用构造注入和@autowire有什么区别？
最新发布
weixin_40914952的博客
04-19 449
构造注入强制依赖项在对象创建时就被提供，支持不可变性和依赖项的非空性，有助于提高代码的可测试性。@Autowired字段注入简洁易懂，但不支持不可变性，可能导致依赖项在对象创建后被修改。总的来说，虽然@Autowired字段注入在某些情况下可以提供便利，但从长远来看，构造注入提供了更好的安全性、稳定性和可测试性。因此，Spring团队和许多开发最佳实践推荐使用构造注入作为依赖注入的首选方式。
详解Spring @Autowired 注入小技巧
08-27
在 Spring 框架中，@Autowired 注解是用来实现自动依赖注入的。它可以根据类型（Type）进行自动注入，并且默认注入的 bean 为单例（SingleTon）的。下面我们来详解一些 @Autowired 注解的小技巧。 一、同一类型注入...
详解Spring依赖注入：@Autowired，@Resource和@Inject区别与实现原理
08-25
@Autowired 是 Spring 框架提供的依赖注入注解，主要支持在 set 方法、field 和构造函数中完成 bean 注入。其注入方式是通过类型查找 bean，即 byType 的，如果存在多个同一类型的 bean，则使用 @Qualifier 来指定...
Spring bean的实例化和IOC依赖注入详解
08-26
Spring Bean的实例化和IOC依赖注入详解 Spring Bean的实例化是Spring框架的核心组件之一，它负责管理和实例化Bean对象。在本文中，我们将深入探讨Spring Bean的实例化和IOC依赖注入机制。 一、IOC依赖注入机制 ...
Spring Ioc 注解 依赖注入
05-26
### Spring IoC与注解依赖注入详解 #### 一、Spring框架简介 Spring框架是由Rod Johnson创建的一个开源项目，最初是为了解决企业级应用开发中的复杂性问题而诞生的。Spring框架的核心特性包括IoC（Inversion of ...
面试官：Spring中的注解@Autowired是如何实现的
xmt1139057136的专栏
07-05 558
现在面试，基本上都是面试造火箭????，工作拧螺丝????。而且是喜欢问一些 Spring 相关的知识点，比如 @Autowired 和@Resource之间的区别。魔高一丈，道高一尺...
【Spring】三大依赖注入(@Autowired，Setter，构造方法)
qq_63218110的博客
04-22 9350
本篇文章注意介绍Spring中的三大注入，属性注入（@Autowired），Setter注入，构造方法注入的优缺点分析，其中还涉及了关于属性注入可能涉及违背单一涉及原则的实例，存在循环依赖的可能，及解决方案，还对JDK中的@Resourece注解与其中的@Autowired进行了比较。
Spring Boot——@Autowired属性注入问题
Wen先森的博客
04-27 4023
例如，使用 Setter Injection 的类可能会存在不完整的状态，如果必需的依赖项没有被设置，可能会导致运行时错误。相比于 Field Injection，Setter Injection 的主要优势是可以避免直接访问类的属性，而是通过 setter 方法来设置依赖项，从而实现更好的封装性。但是，当依赖项过多时，类的属性列表可能会变得很长，降低代码的可读性和可维护性。但是，使用 Setter Injection 的类可能会存在不完整的状态，如果必需的依赖项没有被设置，可能会导致运行时错误。
详解Spring@AutoWired多种方式的依赖注入——List，Map类型
qq_43842093的博客
12-13 1668
在Spring框架进行bean对象依赖注入时，@Autowired利用可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作。@Autowired可标注在成员变量，也可以标注在成员变量的set方法上，以及类得构造函数上。对于标注在成员变量上的方式，通常的做法是标注在单个类型的变量上，Spring框架提供了强大的DI能力能够实现对Collection类型的自动注入。
Spring系列第21篇：注解实现依赖注入（@Autowired、@Resource、@Primary、@Qulifier）
路人甲Java
03-27 4万+
先来看几个问题通过注解的方式注入依赖对象，介绍一下你知道的几种方式@Autowired和@Resource有何区别说一下@Autowired查找候选者的...
@Autowired依赖注入
m0_46192140的博客
03-31 1502
依赖注入的三种方式： 基于字段注入 基于构造器注入 基于set方法注入
Spring系列之注解实现依赖注入（@Autowired、@Resource、@Primary、@Qulifier）
azhou的代码园
05-05 4885
先来看几个问题 通过注解的方式注入依赖对象，介绍一下你知道的几种方式 @Autowired和@Resource有何区别 说一下@Autowired查找候选者的过程 说一下@Resource查找候选者的过程 @Qulifier有哪些用法？ @Qulifier加在类上面是干什么用的？ @Primary是做什么的？ 泛型注入用过么？ 这些问题如果你都ok，那么恭喜你，很厉害。 本文内容 介绍spring中通过注解实现依赖注入的
Spring中在静态方法中调用@Autowired注入的实例对象
奔波儿东
05-31 1755
Spring加载类对象的时机？ spring启动时资源的加载顺序：类的属性->静态方法–>无参构造–>注入@Autowired修饰的依赖–>执行@postConstruct修饰的init()方法。 Spring中在静态方法中调用@Autowired注入的实例对象 了解完spring加载资源的顺序后，可知如下编码是不能顺利使用的，虽然能编译过，但在执行的时候会报空指针异常 @Component public class Application { @Autowired
Spring框架@Autowired注解详解
“Spring注解详细介绍，通过@Autowired实现...Spring的@Autowired注解以及相关的@Service和其他组件注解，使得依赖注入更加方便快捷，提高了代码的可读性和可维护性，降低了XML配置的复杂度，是Spring框架的一大亮点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值