目录

Autowire vs Resource 性能比较

先上结论：

@Resource查找Bean的时间复杂度为O(1)：

@Autowired查找Bean的时间复杂度为O(n)：

不能将所有的@Resource无脑替换成@Autowired

结合源码分析Autowire vs Resource 性能比较

@Autowire注解的处理地方：

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement#inject

org.springframework.beans.factory.support.DefaultListableBeanFactory#doGetBeanNamesForType：

org.springframework.beans.factory.support.AbstractBeanFactory#isFactoryBean(java.lang.String)

@Resource注解的处理地方：

org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.ResourceElement#getResourceToInject：

org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#autowireResource：

@Autowired和@Resource之间的区别？表格对比版

---

Autowire vs Resource 性能比较

先上结论：

@Resource性能比@Autowire好很多，尤其是在bean个数较多的场景下。简单的说，@Resource相当于O(1)，@Autowire相当于O(n) 。

@Resource查找Bean的时间复杂度为O(1)：

• @Resource注解是按照name属性进行查找的，如果没有指定name属性，那么默认是按照字段名进行查找。在Spring的DefaultListableBeanFactory类中，有一个beanDefinitionMap成员变量，这是一个HashMap，用于存储所有的Bean定义信息。当使用@Resource注解进行依赖注入时，Spring会直接根据Bean的名称在beanDefinitionMap中进行查找。由于HashMap的查找时间复杂度是O(1)，所以@Resource查找Bean的时间复杂度也是O(1)。
• 例如，如果我们有一个名为"myService"的Bean，那么我们可以使用@Resource(name = "myService")进行注入，Spring会直接在beanDefinitionMap中查找"myService"，这个操作的时间复杂度是O(1)。

@Autowired查找Bean的时间复杂度为O(n)：

• @Autowired注解是按照类型进行查找的，如果有多个同类型的Bean，那么还需要配合@Qualifier注解来指定Bean的名称。当使用@Autowired注解进行依赖注入时，Spring需要遍历beanDefinitionMap中的所有Bean，找出所有类型匹配的Bean，然后再根据@Qualifier指定的名称进行筛选。由于需要遍历所有的Bean，所以@Autowired查找Bean的时间复杂度是O(n)。
• 例如，如果我们有多个类型为MyService的Bean，那么我们可以使用@Autowired和@Qualifier("myService")进行注入，Spring会遍历所有的Bean，找出类型为MyService的Bean，然后再从中筛选出名为"myService"的Bean，这个操作的时间复杂度是O(n)。

不能将所有的@Resource无脑替换成@Autowired

@Resource注解的工作方式是首先按名称进行装配，如果没有找到对应的bean，那么再按类型进行装配。默认情况下，它在字段或者方法上，取字段名或者getter方法的属性名作为bean的名称。这种方式在大多数情况下都能正常工作，但在某些特殊情况下可能会导致查找失败。

以下是一些可能导致@Resource查找失败的情况：

• Bean的名称与字段名不匹配：
  • 如果你的Spring配置中的bean名称与@Resource注解的字段名不匹配，那么@Resource将无法找到正确的bean。例如，如果你的bean名称是“myService”，但你的字段名是“service”，那么@Resource将无法找到正确的bean。
• 存在多个类型相同的bean：
  • 如果你的Spring容器中存在多个类型相同的bean，那么@Resource将无法确定应该装配哪一个bean。例如，如果你有两个类型都是UserService的bean，那么@Resource将无法确定应该装配哪一个。
• 使用了自定义的Bean名称生成策略：
  • 如果你在Spring配置中使用了自定义的Bean名称生成策略，那么@Resource可能无法找到正确的bean。因为@Resource默认是按照字段名作为bean名称进行查找的，如果你的自定义策略生成的bean名称与字段名不匹配，那么@Resource将无法找到正确的bean。

因此，虽然@Resource在大多数情况下都能正常工作，但在某些特殊情况下可能会导致查找失败。在使用@Resource时，需要注意这些潜在的问题，并根据具体的情况进行适当的处理。

结合源码分析Autowire vs Resource 性能比较

@Autowire注解的处理地方：

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement#inject

• 代码的逻辑：
  • 这段代码是Spring框架中处理@Autowired注解的关键部分，它位于AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement类的inject方法中。这个方法的主要作用是将Spring容器中的bean注入到被@Autowired注解的方法的参数中。
  • 工作原理：
    • 检查是否跳过属性注入：
      • checkPropertySkipping(pvs)方法用于检查是否需要跳过当前属性的注入。如果返回true，则直接返回，不进行后续的注入操作。
    • 获取注入方法和参数：
      • 获取被@Autowired注解的方法和该方法的参数类型。
    • 解析注入参数：
      • 如果已经缓存了需要注入的参数（this.cached为true），则直接从缓存中获取参数。否则，需要解析方法的每一个参数，对于每一个参数，都会创建一个DependencyDescriptor对象，然后调用beanFactory.resolveDependency方法来解析参数对应的bean。
    • 处理解析结果：
      • 如果解析出的bean为null且该参数不是必需的（this.required为false），则将arguments设为null并跳出循环。否则，将解析出的bean添加到arguments数组中。
    • 缓存解析结果：
      • 如果arguments不为null，则将解析出的DependencyDescriptor对象和对应的bean缓存起来，以便下次直接使用。
    • 调用方法：
      • 如果arguments不为null，则使用反射调用被@Autowired注解的方法，将解析出的bean作为参数传入。
• 代码：

  		@Overrideprotected 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) {// Shortcut for avoiding synchronization...arguments = resolveCachedArguments(beanName);}else {Class<?>[] paramTypes = method.getParameterTypes();arguments = new Object[paramTypes.length];DependencyDescriptor[] descriptors = new DependencyDescriptor[paramTypes.length];Set<String> autowiredBeans = new LinkedHashSet<>(paramTypes.length);Assert.state(beanFactory != null, "No BeanFactory available");TypeConverter typeConverter = beanFactory.getTypeConverter();for (int i = 0; i < arguments.length; i++) {MethodParameter methodParam = new MethodParameter(method, i);DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);currDesc.setContainingClass(bean.getClass());descriptors[i] = currDesc;try {Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);if (arg == null && !this.required) {arguments = null;break;}arguments[i] = arg;}catch (BeansException ex) {throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);}}synchronized (this) {if (!this.cached) {if (arguments != null) {Object[] cachedMethodArguments = new Object[paramTypes.length];System.arraycopy(descriptors, 0, cachedMethodArguments, 0, arguments.length);registerDependentBeans(beanName, autowiredBeans);if (autowiredBeans.size() == paramTypes.length) {Iterator<String> it = autowiredBeans.iterator();for (int i = 0; i < paramTypes.length; i++) {String autowiredBeanName = it.next();if (beanFactory.containsBean(autowiredBeanName) &&beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {cachedMethodArguments[i] = new ShortcutDependencyDescriptor(descriptors[i], autowiredBeanName, paramTypes[i]);}}}this.cachedMethodArguments = cachedMethodArguments;}else {this.cachedMethodArguments = null;}this.cached = true;}}}if (arguments != null) {try {ReflectionUtils.makeAccessible(method);method.invoke(bean, arguments);}catch (InvocationTargetException ex) {throw ex.getTargetException();}}}

org.springframework.beans.factory.support.DefaultListableBeanFactory#doGetBeanNamesForType：

• 代码的逻辑：
  • 这段代码来自Spring框架的DefaultListableBeanFactory类中的doGetBeanNamesForType方法。这个方法的主要作用是获取Spring容器中所有指定类型的bean的名称。
  • 工作原理：
    • 创建结果列表：
      • 创建一个空的列表result，用于存储找到的bean的名称。
    • 检查所有bean定义：
      • 遍历所有的bean定义（this.beanDefinitionNames），对于每一个bean定义，首先检查它是否是别名（isAlias(beanName)），如果是，则跳过。然后获取bean的合并定义（getMergedLocalBeanDefinition(beanName)），并检查这个定义是否是完整的（不是抽象的，且允许提前初始化或者已经有bean类或者不是延迟初始化或者允许提前加载类）。如果满足条件，那么就检查这个bean是否是FactoryBean，如果是，那么就尝试匹配FactoryBean创建的对象。如果匹配成功，那么就将bean的名称添加到结果列表中。
    • 处理异常：
      • 在检查bean定义的过程中，可能会抛出CannotLoadBeanClassException或BeanDefinitionStoreException异常。如果允许提前初始化（allowEagerInit为true），那么就直接抛出这些异常。否则，就忽略这些异常，并记录一条跟踪日志。
    • 检查手动注册的单例：
      • 遍历所有手动注册的单例（this.manualSingletonNames），对于每一个单例，首先检查它是否是FactoryBean，如果是，那么就尝试匹配FactoryBean创建的对象。如果匹配成功，那么就将bean的名称添加到结果列表中。然后尝试匹配FactoryBean本身。如果匹配成功，那么也将bean的名称添加到结果列表中。
    • 返回结果：
      • 将结果列表转换为字符串数组，并返回。
  • 这段代码的主要作用就是获取Spring容器中所有指定类型的bean的名称。这是Spring实现依赖注入的关键部分。
• 代码：

  	private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {List<String> result = new ArrayList<>();// Check all bean definitions.for (String beanName : this.beanDefinitionNames) {// Only consider bean as eligible if the bean name// is not defined as alias for some other bean.if (!isAlias(beanName)) {try {RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);// Only check bean definition if it is complete.if (!mbd.isAbstract() && (allowEagerInit ||(mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&!requiresEagerInitForType(mbd.getFactoryBeanName()))) {// In case of FactoryBean, match object created by FactoryBean.boolean isFactoryBean = isFactoryBean(beanName, mbd);BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();boolean matchFound =(allowEagerInit || !isFactoryBean ||(dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&(includeNonSingletons ||(dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&isTypeMatch(beanName, type);if (!matchFound && isFactoryBean) {// In case of FactoryBean, try to match FactoryBean instance itself next.beanName = FACTORY_BEAN_PREFIX + beanName;matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);}if (matchFound) {result.add(beanName);}}}catch (CannotLoadBeanClassException ex) {if (allowEagerInit) {throw ex;}// Probably a class name with a placeholder: let's ignore it for type matching purposes.if (logger.isTraceEnabled()) {logger.trace("Ignoring bean class loading failure for bean '" + beanName + "'", ex);}onSuppressedException(ex);}catch (BeanDefinitionStoreException ex) {if (allowEagerInit) {throw ex;}// Probably some metadata with a placeholder: let's ignore it for type matching purposes.if (logger.isTraceEnabled()) {logger.trace("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex);}onSuppressedException(ex);}}}// Check manually registered singletons too.for (String beanName : this.manualSingletonNames) {try {// In case of FactoryBean, match object created by FactoryBean.if (isFactoryBean(beanName)) {if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {result.add(beanName);// Match found for this bean: do not match FactoryBean itself anymore.continue;}// In case of FactoryBean, try to match FactoryBean itself next.beanName = FACTORY_BEAN_PREFIX + beanName;}// Match raw bean instance (might be raw FactoryBean).if (isTypeMatch(beanName, type)) {result.add(beanName);}}catch (NoSuchBeanDefinitionException ex) {// Shouldn't happen - probably a result of circular reference resolution...if (logger.isTraceEnabled()) {logger.trace("Failed to check manually registered singleton with name '" + beanName + "'", ex);}}}return StringUtils.toStringArray(result);}

org.springframework.beans.factory.support.AbstractBeanFactory#isFactoryBean(java.lang.String)

• 代码的逻辑：
  • 这段代码来自Spring框架的AbstractBeanFactory类中的isFactoryBean方法。这个方法的主要作用是判断指定名称的bean是否是一个FactoryBean。
  • 工作原理：
    • 获取bean名称：
      • 首先，通过transformedBeanName(name)方法获取真正的bean名称。这个方法会去掉名称前面的&字符（如果有的话），因为在Spring中，&字符表示获取FactoryBean本身，而不是FactoryBean创建的对象。
    • 检查单例实例：
      • 然后，通过getSingleton(beanName, false)方法获取单例实例。如果找到了单例实例，那么就检查这个实例是否是一个FactoryBean（beanInstance instanceof FactoryBean）。如果是，那么就返回true。
    • 检查bean定义：
      • 如果没有找到单例实例，那么就检查bean定义。如果在当前的BeanFactory中没有找到bean定义，并且父BeanFactory是一个ConfigurableBeanFactory，那么就委托给父BeanFactory来判断是否是FactoryBean（((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name)）。
    • 检查合并的bean定义：
      • 如果在当前的BeanFactory中找到了bean定义，那么就通过getMergedLocalBeanDefinition(beanName)方法获取合并的bean定义，然后调用isFactoryBean(beanName, mbd)方法来判断是否是FactoryBean。
  • 这段代码的主要作用就是判断指定名称的bean是否是一个FactoryBean。这是Spring处理FactoryBean的关键部分。
• 代码：

  	@Overridepublic boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {String beanName = transformedBeanName(name);Object beanInstance = getSingleton(beanName, false);if (beanInstance != null) {return (beanInstance instanceof FactoryBean);}// No singleton instance found -> check bean definition.if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {// No bean definition found in this factory -> delegate to parent.return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);}return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));}

@Resource注解的处理地方：

org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.ResourceElement#getResourceToInject：

• 代码的逻辑：
  • 这段代码来自Spring框架的CommonAnnotationBeanPostProcessor.ResourceElement类中的getResourceToInject方法。这个方法的主要作用是获取需要注入的资源。
  • 工作原理：
    • 检查是否延迟查找：
      • 首先，检查this.lazyLookup是否为true。this.lazyLookup是一个布尔值，表示是否需要延迟查找资源。如果为true，那么就需要延迟查找资源。
    • 延迟查找资源：
      • 如果需要延迟查找资源，那么就调用buildLazyResourceProxy(this, requestingBeanName)方法来构建一个延迟资源代理。这个代理会在真正需要资源时才去查找资源，这样可以提高应用程序的启动性能。
    • 立即查找资源：
      • 如果不需要延迟查找资源，那么就调用getResource(this, requestingBeanName)方法来立即查找资源。这个方法会立即查找资源，并返回查找到的资源。
  • 这段代码的主要作用就是获取需要注入的资源。这是Spring处理@Resource注解的关键部分。
• 代码：

		@Overrideprotected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :getResource(this, requestingBeanName));}

org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#autowireResource：

• 代码的逻辑：
  • 这段代码来自Spring框架的CommonAnnotationBeanPostProcessor类中的autowireResource方法。这个方法的主要作用是自动装配资源，也就是找到需要注入的资源，并返回。
  • 工作原理：
    • 检查BeanFactory类型：
      • 首先，检查传入的BeanFactory是否是AutowireCapableBeanFactory的实例。AutowireCapableBeanFactory是一个特殊的BeanFactory，它支持自动装配和其他高级特性。
    • 处理AutowireCapableBeanFactory：
      • 如果BeanFactory是AutowireCapableBeanFactory的实例，那么就获取LookupElement的依赖描述符（DependencyDescriptor），并根据依赖描述符和bean的名称来解析需要注入的资源。如果fallbackToDefaultTypeMatch为true，element.isDefaultName为true，并且BeanFactory中不包含指定名称的bean，那么就通过resolveDependency方法来解析依赖。否则，就通过resolveBeanByName方法来解析依赖。
    • 处理其他BeanFactory：
      • 如果BeanFactory不是AutowireCapableBeanFactory的实例，那么就直接通过getBean方法来获取需要注入的资源。
    • 注册依赖关系：
      • 如果BeanFactory是ConfigurableBeanFactory的实例，那么就遍历所有解析出的bean的名称，对于每一个名称，如果BeanFactory中包含这个名称的bean，那么就通过registerDependentBean方法来注册依赖关系。这样，当一个bean被销毁时，所有依赖它的bean也会被销毁。
    • 返回资源：
      • 最后，返回解析出的资源。
  • 这段代码的主要作用就是自动装配资源，也就是找到需要注入的资源，并返回。这是Spring处理@Resource注解的关键部分。
• 代码：

	protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)throws NoSuchBeanDefinitionException {Object resource;Set<String> autowiredBeanNames;String name = element.name;if (factory instanceof AutowireCapableBeanFactory) {AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;DependencyDescriptor descriptor = element.getDependencyDescriptor();if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {autowiredBeanNames = new LinkedHashSet<>();resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);if (resource == null) {throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");}}else {resource = beanFactory.resolveBeanByName(name, descriptor);autowiredBeanNames = Collections.singleton(name);}}else {resource = factory.getBean(name, element.lookupType);autowiredBeanNames = Collections.singleton(name);}if (factory instanceof ConfigurableBeanFactory) {ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;for (String autowiredBeanName : autowiredBeanNames) {if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);}}}return resource;}

@Autowired和@Resource之间的区别？表格对比版

@Autowired可用于：构造函数、成员变量、Setter方法；