framework/Spring/Spring学习补充

Spring学习补充

CommonAnnotationBeanPostProcessor

这个是Spring默认自带的一个外部公共注解的处理器

它主要是用来处理jdk自带的一些

static {
		webServiceRefClass = loadAnnotationType("javax.xml.ws.WebServiceRef");
		ejbClass = loadAnnotationType("javax.ejb.EJB");

		resourceAnnotationTypes.add(Resource.class);
		if (webServiceRefClass != null) {
			resourceAnnotationTypes.add(webServiceRefClass);
		}
		if (ejbClass != null) {
			resourceAnnotationTypes.add(ejbClass);
		}
	}

	public CommonAnnotationBeanPostProcessor() {
		setOrder(Ordered.LOWEST_PRECEDENCE - 3);
		setInitAnnotationType(PostConstruct.class);
		setDestroyAnnotationType(PreDestroy.class);
		ignoreResourceType("javax.xml.ws.WebServiceContext");
	}



因为这个类实现MergedBeanDefinitionPostProcessor
    所以这个处理是在bean刚实例化好创建好的时候，但是属性值还什么都没有的时候
    
@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		LifecycleMetadata metadata = findLifecycleMetadata(beanType);
		metadata.checkConfigMembers(beanDefinition);
	}
    

private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
		if (this.lifecycleMetadataCache == null) {
			// Happens after deserialization, during destruction...
			return buildLifecycleMetadata(clazz);
		}
		// Quick check on the concurrent map first, with minimal locking.
		LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
		if (metadata == null) {
			synchronized (this.lifecycleMetadataCache) {
				metadata = this.lifecycleMetadataCache.get(clazz);
				if (metadata == null) {
					metadata = buildLifecycleMetadata(clazz);
					this.lifecycleMetadataCache.put(clazz, metadata);
				}
				return metadata;
			}
		}
		return metadata;
	}


private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
		if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
			return this.emptyLifecycleMetadata;
		}

		List<LifecycleElement> initMethods = new ArrayList<>();
		List<LifecycleElement> destroyMethods = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<LifecycleElement> currInitMethods = new ArrayList<>();
			final List<LifecycleElement> currDestroyMethods = new ArrayList<>();
//会把指定类的声明方法，不管私有还是公共的，拿出来看有没有initAnnotationType这个注解或者destroyAnnotationType注解，这两个注解在构造器就指定好了
			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                重点：
				if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
					LifecycleElement element = new LifecycleElement(method);
					currInitMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
					}
				}
                重点：
				if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
					currDestroyMethods.add(new LifecycleElement(method));
					if (logger.isTraceEnabled()) {
						logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
					}
				}
			});

			initMethods.addAll(0, currInitMethods);
			destroyMethods.addAll(currDestroyMethods);
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);

		return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
				new LifecycleMetadata(clazz, initMethods, destroyMethods));
	}


然后再bean填充完毕之后，执行beforeInint
    
    @Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
    //根据class找到metadata
		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
		try {
            //调用init方法
			metadata.invokeInitMethods(bean, beanName);
		}
		catch (InvocationTargetException ex) {
			throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
		}
		return bean;
	}

@PostConstruct

init

/*
<code>PostConstruct</code>注释用于需要在完成依赖注入以执行任何初始化之后执行的方法。必须在将类投入服务之前调用此方法。支持依赖注入的所有类都必须支持此注释。即使类不请求注入任何资源，也必须调用用<code>PostConstruct</code>注释的方法。给定类中只有一个方法可以用此注释进行注释。
 * 应用<code>PostConstruct</code>注释的方法必须满足以下所有条件：
方法不能有任何参数，除非是拦截器，在这种情况下，它接受拦截器规范定义的<code>InvocationContext</code>对象。

在侦听器类或侦听器类的超类上定义的方法必须具有以下签名之一：

 * <p>
 * void &#060;METHOD&#062;(InvocationContext)
 * <p>
 * Object &#060;METHOD&#062;(InvocationContext) throws Exception
 * <p>
 注意：构造后拦截器方法不能抛出应用程序异常，但可以声明它抛出检查的异常，包括java.lang.Exception如果除了生命周期事件之外，同一个拦截器方法还插入了业务或超时方法。如果PostConstruct拦截器方法返回值，则容器将忽略该值。
在非拦截类上定义的方法必须具有以下签名：
 * void &#060;METHOD&#062;()
 
 应用<code>PostConstruct</code>注释的方法可以是公共的，受保护的，私有的或私有的。
 
 <li>除应用程序客户端外，该方法不得是静态的。</li>
 * <li>该方法不应该是最终的。
 如果该方法丢弃未检查的异常，则除非由截距器处理异常，否则不得将类投入服务。


*/

@preDestroy

//毁掉之前调用的方法

@Resource

//注入

QualifierAnnotationAutowireCandidateResolver

/*

*/
@SuppressWarnings("unchecked")
	public QualifierAnnotationAutowireCandidateResolver() {
		this.qualifierTypes.add(Qualifier.class);
		try {
			this.qualifierTypes.add((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Qualifier",
							QualifierAnnotationAutowireCandidateResolver.class.getClassLoader()));
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}

再spring解析依赖时，取找候选条件的bean集合
    
protected Map<String, Object> findAutowireCandidates(
			@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

		String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
				this, requiredType, true, descriptor.isEager());
		Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
		for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
			Class<?> autowiringType = classObjectEntry.getKey();
			if (autowiringType.isAssignableFrom(requiredType)) {
				Object autowiringValue = classObjectEntry.getValue();
				autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
				if (requiredType.isInstance(autowiringValue)) {
					result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
					break;
				}
			}
		}
		for (String candidate : candidateNames) {
			if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
				addCandidateEntry(result, candidate, descriptor, requiredType);
			}
		}
		if (result.isEmpty()) {
			boolean multiple = indicatesMultipleBeans(requiredType);
			// Consider fallback matches if the first pass failed to find anything...
			DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
			for (String candidate : candidateNames) {
				if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
						(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
                    //这里符合才能进行添加
					addCandidateEntry(result, candidate, descriptor, requiredType);
				}
			}
			if (result.isEmpty() && !multiple) {
				// Consider self references as a final pass...
				// but in the case of a dependency collection, not the very same bean itself.
				for (String candidate : candidateNames) {
					if (isSelfReference(beanName, candidate) &&
							(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
							isAutowireCandidate(candidate, fallbackDescriptor)) {
						addCandidateEntry(result, candidate, descriptor, requiredType);
					}
				}
			}
		}
		return result;
	}

@Qualifier

/*
自动接线时，此注释可以在字段或参数上用作候选beans的限定符。它也可以用来注释其他自定义注释，然后可以用作限定符。

*/


public @interface Qualifier {   
    String value() default "";
}


@Qualifier
通过使用 @Qualifier 注解，我们可以消除需要注入哪个 bean 的问题。让我们重新回顾一下前面的例子，看看我们如何通过包含 @Qualifier 注释来指出我们想要使用哪个 bean 来解决问题：
    
    @Component
    public class FooService {
        @Autowired
        @Qualifier("fooFormatter")
        private Formatter formatter;
        
        //todo 
    }

通过将 @Qualifier 注解与我们想要使用的特定 Spring bean 的名称一起进行装配，Spring 框架就能从多个相同类型并满足装配要求的 bean 中找到我们想要的，避免让Spring脑裂。我们需要做的是@Component或者@Bean注解中声明的value属性以确定名称。其实我们也可以在 Formatter 实现类上使用 @Qualifier 注释，而不是在 @Component 或者 @Bean 中指定名称，也能达到相同的效果：

     @Component
     @Qualifier("fooFormatter")
     public class FooFormatter implements Formatter {
         public String format() {
             return "foo";
         }
     }
 
     @Component
     @Qualifier("barFormatter")
     public class BarFormatter implements Formatter {
         public String format() {
             return "bar";
         }
     }


这个是通过value一样来判断具体注入那个，或者 要注入到哪里

扩展

@Primary


还有另一个名为 @Primary 的注解，我们也可以用来发生依赖注入的歧义时决定要注入哪个 bean。当存在多个相同类型的 bean 时，此注解定义了首选项。除非另有说明，否则将使用与 @Primary 注释关联的 bean 。
我们来看一个例子：





    @Bean
    public Employee tomEmployee() {
        return new Employee("Tom");
    }

    @Bean
    @Primary
    public Employee johnEmployee() {
        return new Employee("john");
    }




在此示例中，两个方法都返回相同的 Employee类型。Spring 将注入的 bean 是方法 johnEmployee 返回的 bean。这是因为它包含 @Primary 注解。当我们想要指定默认情况下应该注入特定类型的 bean 时，此注解很有用。如果我们在某个注入点需要另一个 bean，我们需要专门指出它。我们可以通过 @Qualifier 注解来做到这一点。例如，我们可以通过使用 @Qualifier 注释来指定我们想要使用 tomEmployee 方法返回的 bean 。值得注意的是，如果 @Qualifier 和 @Primary 注释都存在，那么 @Qualifier 注释将具有优先权。基本上，@Primary 是定义了默认值，而 @Qualifier 则非常具体。当然 @Component 也可以使用 @Primary 注解，这次使用的还是上面3的示例：



     @Component
     @Primary
     public class FooFormatter implements Formatter {
         public String format() {
             return "foo";
         }
     }
 
     @Component
     public class BarFormatter implements Formatter {
         public String format() {
             return "bar";
         }
     }


在这种情况下，@Primary 注解指定了默认注入的是 FooFormatter，消除了场景中的注入歧义。





5. 通过名称来自动注入


在使用 @Autowired 进行自动装配时，如果 Spring 没有其他提示，将会按照需要注入的变量名称来寻找合适的 bean。也可以解决依赖注入歧义的问题。让我们看一些基于我们最初的例子的代码：





    @Component
    public class FooService {
        @Autowired
        private Formatter fooFormatter;
        
        //todo 
    }


在这种情况下，Spring 将确定要注入的 bean 是 FooFormatter，因为字段名称与我们在该 bean 的 @Component或者 @Bean 注解中使用的值(默认 @Bean 使用方法名)相匹配。



6. 总结


通过对 @Qualifier 的探讨，我们知道该注解是用来消除依赖注入冲突的。这种在日常开发，比如 Rabbtimq 的队列声明中很常见。小胖哥也通过该注解和其他上述注解的组合使用和对比中展示了一些常用的用法。这将有助于你对 Spring 的依赖注入机制的了解。

@Role注解

1. 标识Bean的类别
2. 种类：
   1. ROLE_APPLICATION = 0
      • bean的默认角色
      • 标识应用的主要的主要角色
      • 通常对应于用户定义的bean
   2. ROLE_SUPPORT = 1
      • 标识较大配置的一部分
      • 通常是仔细观察特定的ComponentDefinition时重要的提示，而不是体现在应用中
   3. ROLE_INFRASTRUCTURE = 2
      • 标识后台角色，与最终用户无关
      • 通常供是内部工作的bean使用
3. 作用 ： 目前不晓得

赏

谢谢你请我吃糖果

支付宝

微信

• 本文作者： 忘忧症
• 本文链接： https://NepenthesZGW.github.io/2020/08/09/framework/Spring/Spring学习补充/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！