热门搜索：
The motivation for the existence of this BeanPostProcessor is to allow
* BeanPostProcessor存在的意义是允许
* developers to annotate the setter properties of their own classes with an
* arbitrary JDK 1.5 annotation to indicate that the container must check
* for the configuration of a dependency injected value. This neatly pushes
* 开发人员注释setter属性与一个他们自己的类任意的JDK 1.5注释表明容器必须检查依赖注入的配置值。
* responsibility for such checking onto the container (where it arguably belongs),
* 这样就巧妙的把check的责任给了Spring容器(它应该就属于的)
* and obviates the need (in part) for a developer to code a method that
* simply checks that all required properties have actually been set.
* 这样也就排除了开发人员需要编写一个简单的方法用来检测那么必须的properties是否已经设置了值
*
Please note that an 'init' method may still need to implemented (and may
* still be desirable), because all that this class does is enforce that a
* 请注意初始化方法还是必须要实现的(并且仍然是可取的)
* 'required' property has actually been configured with a value. It does
* 因为所有这个Class强制执行的是'required'属性是否已经被配置了值
* not check anything else... In particular, it does not check that a
* 它并不会check其实的事，特别的是，它不会check这个配置的值是不是null值
* configured value is not {@code null}.
*
*
Note: A default RequiredAnnotationBeanPostProcessor will be registered The default required annotation type is the Spring-provided This setter property exists so that developers can provide their own The default implementations check for the presence of the This implementation looks for the existence of a
* by the "context:annotation-config" and "context:component-scan" XML tags.
* 当你使用了"context:annotation-config"或者"context:component-scan"XML标签就会默认注册RequiredAnnotationBeanPostProcessor
* Remove or turn off the default annotation configuration there if you intend
* to specify a custom RequiredAnnotationBeanPostProcessor bean definition.
* 你如果打算指定一个自定义的RequiredAnnotationBeanPostProcessor的bean实现可以移除或者关闭默认的annotation配置
*
* @author Rob Harrop
* @author Juergen Hoeller
* @since 2.0
* @see #setRequiredAnnotationType
* @see Required
*/
public class RequiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
/**
* Bean definition attribute that may indicate whether a given bean is supposed
* to be skipped when performing this post-processor's required property check.
* 这个bean定义的属性表明当执行post-processor(后处理程序)这个check提供的bean的必须的属性
* @see #shouldSkip
*/
public static final String SKIP_REQUIRED_CHECK_ATTRIBUTE =
Conventions.getQualifiedAttributeName(RequiredAnnotationBeanPostProcessor.class, "skipRequiredCheck");
private Class requiredAnnotationType = Required.class;
private int order = Ordered.LOWEST_PRECEDENCE - 1;
private ConfigurableListableBeanFactory beanFactory;
/**
* Cache for validated bean names, skipping re-validation for the same bean
* 缓存已经确认过的bean名称，跳过后续同样的bean
*/
private final Set
Collections.newSetFromMap(new ConcurrentHashMap
/**
* Set the 'required' annotation type, to be used on bean property
* setter methods.
* 设置所需的注释类型,使用bean属性setter方法
*
* {@link Required} annotation.
* 这个默认的required annotation类型是Spring提供的annotation
*
* (non-Spring-specific) annotation type to indicate that a property value
* is required.
* 这里设置这个property是为了开发者能够提供自己定义的annotaion类型用来表明这个属性值是必须的
*/
public void setRequiredAnnotationType(Class requiredAnnotationType) {
Assert.notNull(requiredAnnotationType, "'requiredAnnotationType' must not be null");
this.requiredAnnotationType = requiredAnnotationType;
}
/**
* Return the 'required' annotation type.
*/
protected Class getRequiredAnnotationType() {
return this.requiredAnnotationType;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
}
public void setOrder(int order) {
this.order = order;
}
@Override
public int getOrder() {
return this.order;
}
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
}
@Override
public PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
// 利用缓存确定是否这个bean被validated
if (!this.validatedBeanNames.contains(beanName)) {
// 不跳过
if (!shouldSkip(this.beanFactory, beanName)) {
List
for (PropertyDescriptor pd : pds) {
// 如果被标记为了required 且 这个属性没有属性值(或其他处理条目)
if (isRequiredProperty(pd) && !pvs.contains(pd.getName())) {
// 增加这个属性
invalidProperties.add(pd.getName());
}
}
// 如果无效的properties不为空。抛出异常
if (!invalidProperties.isEmpty()) {
throw new BeanInitializationException(buildExceptionMessage(invalidProperties, beanName));
}
}
// 把需要验证的bean名称添加进去
this.validatedBeanNames.add(beanName);
}
return pvs;
}
/**
* Check whether the given bean definition is not subject to the annotation-based
* required property check as performed by this post-processor.
* 通过post-processor(后处理程序)检测这个被给予的定义的bean是否受注释为基础的check必须的property的管束
*
* {@link #SKIP_REQUIRED_CHECK_ATTRIBUTE} attribute in the bean definition, if any.
* 这个默认的实现check存在SKIP_REQUIRED_CHECK_ATTRIBUTE这个属性的定义的bean
* It also suggests skipping in case of a bean definition with a "factory-bean"
* reference set, assuming that instance-based factories pre-populate the bean.
* 它同样也建议跳过如果这个bean定义了"factory-bean"引用,假设那个基于实例的factories预先配置了bean
* @param beanFactory the BeanFactory to check against
* @param beanName the name of the bean to check against
* @return {@code true} to skip the bean; {@code false} to process it
* 如果返回 true跳过这个bean,返回false就处理它
*/
protected boolean shouldSkip(ConfigurableListableBeanFactory beanFactory, String beanName) {
// 如果这个beanFacotry为空或者这个bean工厂不包含一个给定名称的bean定义。返回false
if (beanFactory == null || !beanFactory.containsBeanDefinition(beanName)) {
return false;
}
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
// 判断这个bean的工厂beanName，如果不为null,返回true
if (beanDefinition.getFactoryBeanName() != null) {
return true;
}
Object value = beanDefinition.getAttribute(SKIP_REQUIRED_CHECK_ATTRIBUTE);
return (value != null && (Boolean.TRUE.equals(value) || Boolean.valueOf(value.toString())));
}
/**
* Is the supplied property required to have a value (that is, to be dependency-injected)?
* 是否这个提供的必须的propery是否有一个值(这个是被依赖注入)?
*
* {@link #setRequiredAnnotationType "required" annotation}
* on the supplied {@link PropertyDescriptor property}.
* 这个实现是为了找到提供的ProertyDescriptor是提供了"required"注解
* @param propertyDescriptor the target PropertyDescriptor (never {@code null})
* @return {@code true} if the supplied property has been marked as being required;
* 返回true，如果提供的property已经被标记为必须的
* {@code false} if not, or if the supplied property does not have a setter method
* 返回false，如果没有标记为必须的或者提供的property没有一个setter方法
*/
protected boolean isRequiredProperty(PropertyDescriptor propertyDescriptor) {
Method setter = propertyDescriptor.getWriteMethod();
return (setter != null && AnnotationUtils.getAnnotation(setter, getRequiredAnnotationType()) != null);
}
/**
* Build an exception message for the given list of invalid properties.
* 使用所给的异常properties来构建异常信息
* @param invalidProperties the list of names of invalid properties
* @param beanName the name of the bean
* @return the exception message
*/
private String buildExceptionMessage(List
int size = invalidProperties.size();
StringBuilder sb = new StringBuilder();
sb.append(size == 1 ? "Property" : "Properties");
for (int i = 0; i < size; i++) {
String propertyName = invalidProperties.get(i);
if (i > 0) {
if (i == (size - 1)) {
sb.append(" and");
}
else {
sb.append(",");
}
}
sb.append(" '").append(propertyName).append("'");
}
sb.append(size == 1 ? " is" : " are");
sb.append(" required for bean '").append(beanName).append("'");
return sb.toString();
}
}
在上面的代码中所示。我们可以得出以下结论:
上面已经把Spring对于 org.springframework.beans.factory.annotation.Required 这个标签的实现出来了。虽然只是一个小例子。但是我们可以根据Spring以下的的包结构看到这是Spring对于它自身Annotation的很common的实现:
从上面的例子中我可以看出Spring对它本身的Annotaion的一种实现。当前文中并没有讲述Exception Message是通过怎么传递的。但是这并不是本文讨论的范畴，有兴趣的朋友可以自己去看看。
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
QQ客服
公众号
手机版
帮助中心
