Spring读源码系列番外篇---01--PropertyValue相关类
引子
AbstractAutowireCapableBeanFactory类的doCreateBean方法里面的populateBean方法在对bean进行属性注入的时候用到了这个类
如果你想对增加自定义类型转换器,可能也需要去了解一下这方面的结构是怎么样的
/**
* Populate the bean instance in the given BeanWrapper with the property values
* from the bean definition.
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param bw the BeanWrapper with bean instance
*/
@SuppressWarnings("deprecation") // for postProcessPropertyValues
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
这里不是为了去讲bean的加载过程,因此这里不对上面的源码进行剖析，我这里只是将告诉大家，PropertyValue会在哪里被用到，那么下面就来进入PropertyValue的探索之路吧!!!
上面populateBean代码的解析参考: Spring读源码系列05----bean的加载—下
PropertyValue类继承图
AttributeAccessor–属性访问器—顶层接口
该类提供了统一的对BeanDefinition中属性的访问控制接口，通过观察其实现类，也可以发现这一点
public interface AttributeAccessor {
//设置某个属性
void setAttribute(String var1, @Nullable Object var2);
@Nullable
//获取某个属性
Object getAttribute(String var1);
//可以理解为对属性进行修改,不过可以将如何修改这个逻辑通过函数式接口的方式传入
default <T> T computeAttribute(String name, Function<String, T> computeFunction) {
Assert.notNull(name, "Name must not be null");
Assert.notNull(computeFunction, "Compute function must not be null");
Object value = this.getAttribute(name);
if (value == null) {
value = computeFunction.apply(name);
Assert.state(value != null, () -> {
return String.format("Compute function must not return null for attribute named '%s'", name);
});
this.setAttribute(name, value);
}
return value;
}
@Nullable
//移除某个属性
Object removeAttribute(String var1);
//是否具有某个属性
boolean hasAttribute(String var1);
//返回属性名集合
String[] attributeNames();
}
通过分析得知AttributeAccessor 主要提供对BeanDefinition里面属性的增删改查功能
AttributeAccessorSupport–属性访问器支持—实现了父类AttributeAccessor接口的功能
public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {
//存放属性的集合---这里value是object---猜猜value会存放啥子东西
private final Map<String, Object> attributes = new LinkedHashMap();
public AttributeAccessorSupport() {
}
public void setAttribute(String name, @Nullable Object value) {
Assert.notNull(name, "Name must not be null");
if (value != null) {
this.attributes.put(name, value);
} else {
this.removeAttribute(name);
}
}
@Nullable
public Object getAttribute(String name) {
Assert.notNull(name, "Name must not be null");
return this.attributes.get(name);
}
public <T> T computeAttribute(String name, Function<String, T> computeFunction) {
Assert.notNull(name, "Name must not be null");
Assert.notNull(computeFunction, "Compute function must not be null");
Object value = this.attributes.computeIfAbsent(name, computeFunction);
Assert.state(value != null, () -> {
return String.format("Compute function must not return null for attribute named '%s'", name);
});
return value;
}
@Nullable
public Object removeAttribute(String name) {
Assert.notNull(name, "Name must not be null");
return this.attributes.remove(name);
}
public boolean hasAttribute(String name) {
Assert.notNull(name, "Name must not be null");
return this.attributes.containsKey(name);
}
public String[] attributeNames() {
return StringUtils.toStringArray(this.attributes.keySet());
}
//拷贝属性这个是新增的
protected void copyAttributesFrom(AttributeAccessor source) {
Assert.notNull(source, "Source must not be null");
String[] attributeNames = source.attributeNames();
String[] var3 = attributeNames;
int var4 = attributeNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String attributeName = var3[var5];
this.setAttribute(attributeName, source.getAttribute(attributeName));
}
}
public boolean equals(@Nullable Object other) {
return this == other || other instanceof AttributeAccessorSupport && this.attributes.equals(((AttributeAccessorSupport)other).attributes);
}
public int hashCode() {
return this.attributes.hashCode();
}
}
可以看出AttributeAccessorSupport只是对父类AttributeAccessor功能的简单实现，但是存放属性的集合时放在了该子类中，还新增了一个复制属性的方法
BeanMetadataElement —Bean 元数据元素—顶层接口
/**
* Interface to be implemented by bean metadata elements
* that carry a configuration source object.
*/
public interface BeanMetadataElement {
/**
* Return the configuration source for this metadata element
* 如果是xml配置的话,返回的是当前bean对应的bean标签元素
*/
@Nullable
default Object getSource() {
return null;
}
}
如果是注解的话,这里我还没弄清楚,因此暂时无法给予解答,如果知道的小伙伴可以评论区留言
BeanMetadataAttributeAccessor—Bean 元数据属性访问器—实现了BeanMetadataElement 接口，继承了AttributeAccessorSupport
/**
AttributeAccessorSupport 的扩展，将属性保存为 BeanMetadataAttribute 对象以跟踪定义源。
*/
@SuppressWarnings("serial")
public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {
//保存当前bean的元数据---实现BeanMetadataElement接口的功能
@Nullable
private Object source;
/**
为此元数据元素设置配置源对象。对象的确切类型将取决于所使用的配置机制。
*/
public void setSource(@Nullable Object source) {
this.source = source;
}
@Override
@Nullable
public Object getSource() {
return this.source;
}
/上面都是关于元数据的配置///
下面对于属性的操作,都是关联到了AttributeAccessorSupport 的属性集合//
/**
将给定的 BeanMetadataAttribute 添加到此访问器的属性集中。参数：attribute——要注册的 BeanMetadataAttribute 对象
这里也说明了AttributeAccessorSupport 的属性集合的value存放的是BeanMetadataAttribute类型的数据
*/
public void addMetadataAttribute(BeanMetadataAttribute attribute) {
super.setAttribute(attribute.getName(), attribute);
}
//这里也说明了AttributeAccessorSupport 的属性集合的value存放的是BeanMetadataAttribute类型的数据
@Nullable
public BeanMetadataAttribute getMetadataAttribute(String name) {
return (BeanMetadataAttribute) super.getAttribute(name);
}
@Override
public void setAttribute(String name, @Nullable Object value) {
super.setAttribute(name, new BeanMetadataAttribute(name, value));
}
@Override
@Nullable
public Object getAttribute(String name) {
BeanMetadataAttribute attribute = (BeanMetadataAttribute) super.getAttribute(name);
return (attribute != null ? attribute.getValue() : null);
}
@Override
@Nullable
public Object removeAttribute(String name) {
BeanMetadataAttribute attribute = (BeanMetadataAttribute) super.removeAttribute(name);
return (attribute != null ? attribute.getValue() : null);
}
}
BeanMetadataAttributeAccessor主要增加了元数据的访问和存储配置,以及通过BeanMetadataAttribute 来包装属性名和属性值的，并存放入父类AttributeAccessorSupport 的集合中去
BeanMetadataAttribute----Bean 元数据属性
该类实现了BeanMetadataElement接口，说明也会对元数据进行存储和crud
public class BeanMetadataAttribute implements BeanMetadataElement {
//属性名
private final String name;
//属性值
@Nullable
private final Object value;
//元数据
@Nullable
private Object source;
public BeanMetadataAttribute(String name, @Nullable Object value) {
Assert.notNull(name, "Name must not be null");
this.name = name;
this.value = value;
}
public String getName() {
return this.name;
}
@Nullable
public Object getValue() {
return this.value;
}
public void setSource(@Nullable Object source) {
this.source = source;
}
@Override
@Nullable
public Object getSource() {
return this.source;
}
}
PropertyValue
/**
保存单个 bean 属性的信息和值的对象。在此处使用对象，而不是仅将所有属性存储在以属性名称为键的映射中，
可以提供更大的灵活性，并能够以优化的方式处理索引属性等。
请注意，该值不需要是最终所需的类型： BeanWrapper 实现应该处理任何必要的转换，因为该对象不知道将应用到的对象的任何信息。
*/
@SuppressWarnings("serial")
public class PropertyValue extends BeanMetadataAttributeAccessor implements Serializable {
private final String name;
@Nullable
private final Object value;
//每个beanDefinition都会持有多个PropertyValue
//每个PropertyValue对应于当前bean里面一条被封装的属性记录
//optional 判断的是: 如果当前属性再对bean进行属性注入时,如果对于属性在指定bean中不存在,是否要忽略
//显然: 默认是不进行忽略——-这里我还没验证是否是抛出异常,但是我猜是抛出异常,如果指定属性不存在的话
private boolean optional = false;
//因为可能存在类型转换的需求---该字段就是负责类型转换的控制
private boolean converted = false;
//封装转换后的值
@Nullable
private Object convertedValue;
/** 是否需要进行类型转换 */
@Nullable
volatile Boolean conversionNecessary;
/** Package-visible field for caching the resolved property path tokens. */
@Nullable
transient volatile Object resolvedTokens;
/**
* Create a new PropertyValue instance.
* @param name the name of the property (never {@code null})
* @param value the value of the property (possibly before type conversion)
*/
public PropertyValue(String name, @Nullable Object value) {
Assert.notNull(name, "Name must not be null");
this.name = name;
this.value = value;
}
/**
* Copy constructor.
* @param original the PropertyValue to copy (never {@code null})
*/
public PropertyValue(PropertyValue original) {
Assert.notNull(original, "Original must not be null");
this.name = original.getName();
this.value = original.getValue();
this.optional = original.isOptional();
this.converted = original.converted;
this.convertedValue = original.convertedValue;
this.conversionNecessary = original.conversionNecessary;
this.resolvedTokens = original.resolvedTokens;
setSource(original.getSource());
copyAttributesFrom(original);
}
/**
* Constructor that exposes a new value for an original value holder.
* The original holder will be exposed as source of the new holder.
* @param original the PropertyValue to link to (never {@code null})
* @param newValue the new value to apply
*/
public PropertyValue(PropertyValue original, @Nullable Object newValue) {
Assert.notNull(original, "Original must not be null");
this.name = original.getName();
this.value = newValue;
this.optional = original.isOptional();
this.conversionNecessary = original.conversionNecessary;
this.resolvedTokens = original.resolvedTokens;
setSource(original);
copyAttributesFrom(original);
}
/**
* Return the name of the property.
*/
public String getName() {
return this.name;
}
/**
* Return the value of the property.
* <p>Note that type conversion will <i>not</i> have occurred here.
* It is the responsibility of the BeanWrapper implementation to
* perform type conversion.
*/
@Nullable
public Object getValue() {
return this.value;
}
/**
* Return the original PropertyValue instance for this value holder.
* @return the original PropertyValue (either a source of this
* value holder or this value holder itself).
*/
public PropertyValue getOriginalPropertyValue() {
PropertyValue original = this;
Object source = getSource();
while (source instanceof PropertyValue && source != original) {
original = (PropertyValue) source;
source = original.getSource();
}
return original;
}
/**
设置是否为可选值，即在目标类上不存在对应属性时忽略。
*/
public void setOptional(boolean optional) {
this.optional = optional;
}
/**
* Return whether this is an optional value, that is, to be ignored
* when no corresponding property exists on the target class.
* @since 3.0
*/
public boolean isOptional() {
return this.optional;
}
/**
返回此持有者是否已包含转换后的值（true），或者该值是否仍需要转换（false）。
*/
public synchronized boolean isConverted() {
return this.converted;
}
/**
* Set the converted value of this property value,
* after processed type conversion.
*/
public synchronized void setConvertedValue(@Nullable Object value) {
this.converted = true;
this.convertedValue = value;
}
/**
* Return the converted value of this property value,
* after processed type conversion.
*/
@Nullable
public synchronized Object getConvertedValue() {
return this.convertedValue;
}
}
PropertyValue只是对BeanDefinition中一个属性进行的封装,并且提供了是否在自动注入时忽略不存在属性的功能和是否进行类型转换的控制
一个bean一般会有多个属性，那么BeanDefinition肯定是通过一个集合来封装一组PropertyValue来表示这些属性，那么具体是什么样的集合呢？----看下面:
存放PropertyValue的集合
这里列出的是常用的,PropertyValues还有一些子类没列举出来
PropertyValues ---- 封装多个PropertyValue–顶层接口
/**
包含一个或多个 PropertyValue 对象的持有者，通常包含针对特定目标 bean 的一次更新。
实现Iterable<PropertyValue>,表名可以用迭代器的方式进行遍历
*/
public interface PropertyValues extends Iterable<PropertyValue> {
/**
* Return an {@link Iterator} over the property values.
* @since 5.1
*/
@Override
default Iterator<PropertyValue> iterator() {
return Arrays.asList(getPropertyValues()).iterator();
}
/**
* Return a {@link Spliterator} over the property values.
* @since 5.1
*/
@Override
default Spliterator<PropertyValue> spliterator() {
return Spliterators.spliterator(getPropertyValues(), 0);
}
/**
* Return a sequential {@link Stream} containing the property values.
* @since 5.1
*/
default Stream<PropertyValue> stream() {
return StreamSupport.stream(spliterator(), false);
}
/**
* Return an array of the PropertyValue objects held in this object.
*/
PropertyValue[] getPropertyValues();
/**
* Return the property value with the given name, if any.
* @param propertyName the name to search for
* @return the property value, or {@code null} if none
*/
@Nullable
PropertyValue getPropertyValue(String propertyName);
/**
* Return the changes since the previous PropertyValues.
* Subclasses should also override {@code equals}.
* @param old the old property values
* @return the updated or new properties.
* Return empty PropertyValues if there are no changes.
* @see Object#equals
*/
PropertyValues changesSince(PropertyValues old);
/**
* Is there a property value (or other processing entry) for this property?
* @param propertyName the name of the property we're interested in
* @return whether there is a property value for this property
*/
boolean contains(String propertyName);
/**
* Does this holder not contain any PropertyValue objects at all?
*/
boolean isEmpty();
}
其实每个方法大概干啥的都可以猜出来,PropertyValues接口主要功能就是提供对PropertyValue集合的迭代器遍历方式
MutablePropertyValues----PropertyValues接口功能实现
/**
PropertyValues 接口的默认实现。允许对属性进行简单操作，并提供构造函数以支持从 Map 进行深度复制和构造。
*/
@SuppressWarnings("serial")
public class MutablePropertyValues implements PropertyValues, Serializable {
private final List<PropertyValue> propertyValueList;
@Nullable
private Set<String> processedProperties;
private volatile boolean converted;
/**
* Creates a new empty MutablePropertyValues object.
* <p>Property values can be added with the {@code add} method.
* @see #add(String, Object)
*/
public MutablePropertyValues() {
this.propertyValueList = new ArrayList<>(0);
}
/**
* Deep copy constructor. Guarantees PropertyValue references
* are independent, although it can't deep copy objects currently
* referenced by individual PropertyValue objects.
* @param original the PropertyValues to copy
* @see #addPropertyValues(PropertyValues)
*/
public MutablePropertyValues(@Nullable PropertyValues original) {
// We can optimize this because it's all new:
// There is no replacement of existing property values.
if (original != null) {
PropertyValue[] pvs = original.getPropertyValues();
this.propertyValueList = new ArrayList<>(pvs.length);
for (PropertyValue pv : pvs) {
this.propertyValueList.add(new PropertyValue(pv));
}
}
else {
this.propertyValueList = new ArrayList<>(0);
}
}
/**
* Construct a new MutablePropertyValues object from a Map.
* @param original a Map with property values keyed by property name Strings
* @see #addPropertyValues(Map)
*/
public MutablePropertyValues(@Nullable Map<?, ?> original) {
// We can optimize this because it's all new:
// There is no replacement of existing property values.
if (original != null) {
this.propertyValueList = new ArrayList<>(original.size());
original.forEach((attrName, attrValue) -> this.propertyValueList.add(
new PropertyValue(attrName.toString(), attrValue)));
}
else {
this.propertyValueList = new ArrayList<>(0);
}
}
/**
* Construct a new MutablePropertyValues object using the given List of
* PropertyValue objects as-is.
* <p>This is a constructor for advanced usage scenarios.
* It is not intended for typical programmatic use.
* @param propertyValueList a List of PropertyValue objects
*/
public MutablePropertyValues(@Nullable List<PropertyValue> propertyValueList) {
this.propertyValueList =
(propertyValueList != null ? propertyValueList : new ArrayList<>());
}
/**
* Return the underlying List of PropertyValue objects in its raw form.
* The returned List can be modified directly, although this is not recommended.
* <p>This is an accessor for optimized access to all PropertyValue objects.
* It is not intended for typical programmatic use.
*/
public List<PropertyValue> getPropertyValueList() {
return this.propertyValueList;
}
/**
* Return the number of PropertyValue entries in the list.
*/
public int size() {
return this.propertyValueList.size();
}
/**
* Copy all given PropertyValues into this object. Guarantees PropertyValue
* references are independent, although it can't deep copy objects currently
* referenced by individual PropertyValue objects.
* @param other the PropertyValues to copy
* @return this in order to allow for adding multiple property values in a chain
*/
public MutablePropertyValues addPropertyValues(@Nullable PropertyValues other) {
if (other != null) {
PropertyValue[] pvs = other.getPropertyValues();
for (PropertyValue pv : pvs) {
addPropertyValue(new PropertyValue(pv));
}
}
return this;
}
/**
* Add all property values from the given Map.
* @param other a Map with property values keyed by property name,
* which must be a String
* @return this in order to allow for adding multiple property values in a chain
*/
public MutablePropertyValues addPropertyValues(@Nullable Map<?, ?> other) {
if (other != null) {
other.forEach((attrName, attrValue) -> addPropertyValue(
new PropertyValue(attrName.toString(), attrValue)));
}
return this;
}
/**
* Add a PropertyValue object, replacing any existing one for the
* corresponding property or getting merged with it (if applicable).
* @param pv the PropertyValue object to add
* @return this in order to allow for adding multiple property values in a chain
*/
public MutablePropertyValues addPropertyValue(PropertyValue pv) {
for (int i = 0; i < this.propertyValueList.size(); i++) {
PropertyValue currentPv = this.propertyValueList.get(i);
if (currentPv.getName().equals(pv.getName())) {
pv = mergeIfRequired(pv, currentPv);
setPropertyValueAt(pv, i);
return this;
}
}
this.propertyValueList.add(pv);
return this;
}
/**
* Overloaded version of {@code addPropertyValue} that takes
* a property name and a property value.
* <p>Note: As of Spring 3.0, we recommend using the more concise
* and chaining-capable variant {@link #add}.
* @param propertyName name of the property
* @param propertyValue value of the property
* @see #addPropertyValue(PropertyValue)
*/
public void addPropertyValue(String propertyName, Object propertyValue) {
addPropertyValue(new PropertyValue(propertyName, propertyValue));
}
/**
* Add a PropertyValue object, replacing any existing one for the
* corresponding property or getting merged with it (if applicable).
* @param propertyName name of the property
* @param propertyValue value of the property
* @return this in order to allow for adding multiple property values in a chain
*/
public MutablePropertyValues add(String propertyName, @Nullable Object propertyValue) {
addPropertyValue(new PropertyValue(propertyName, propertyValue));
return this;
}
/**
* Modify a PropertyValue object held in this object.
* Indexed from 0.
*/
public void setPropertyValueAt(PropertyValue pv, int i) {
this.propertyValueList.set(i, pv);
}
/**
* Merges the value of the supplied 'new' {@link PropertyValue} with that of
* the current {@link PropertyValue} if merging is supported and enabled.
* @see Mergeable
*/
private PropertyValue mergeIfRequired(PropertyValue newPv, PropertyValue currentPv) {
Object value = newPv.getValue();
if (value instanceof Mergeable) {
Mergeable mergeable = (Mergeable) value;
if (mergeable.isMergeEnabled()) {
Object merged = mergeable.merge(currentPv.getValue());
return new PropertyValue(newPv.getName(), merged);
}
}
return newPv;
}
/**
* Remove the given PropertyValue, if contained.
* @param pv the PropertyValue to remove
*/
public void removePropertyValue(PropertyValue pv) {
this.propertyValueList.remove(pv);
}
/**
* Overloaded version of {@code removePropertyValue} that takes a property name.
* @param propertyName name of the property
* @see #removePropertyValue(PropertyValue)
*/
public void removePropertyValue(String propertyName) {
this.propertyValueList.remove(getPropertyValue(propertyName));
}
@Override
public Iterator<PropertyValue> iterator() {
return Collections.unmodifiableList(this.propertyValueList).iterator();
}
@Override
public Spliterator<PropertyValue> spliterator() {
return Spliterators.spliterator(this.propertyValueList, 0);
}
@Override
public Stream<PropertyValue> stream() {
return this.propertyValueList.stream();
}
@Override
public PropertyValue[] getPropertyValues() {
return this.propertyValueList.toArray(new PropertyValue[0]);
}
@Override
@Nullable
public PropertyValue getPropertyValue(String propertyName) {
for (PropertyValue pv : this.propertyValueList) {
if (pv.getName().equals(propertyName)) {
return pv;
}
}
return null;
}
/**
* Get the raw property value, if any.
* @param propertyName the name to search for
* @return the raw property value, or {@code null} if none found
* @since 4.0
* @see #getPropertyValue(String)
* @see PropertyValue#getValue()
*/
@Nullable
public Object get(String propertyName) {
PropertyValue pv = getPropertyValue(propertyName);
return (pv != null ? pv.getValue() : null);
}
@Override
public PropertyValues changesSince(PropertyValues old) {
MutablePropertyValues changes = new MutablePropertyValues();
if (old == this) {
return changes;
}
// for each property value in the new set
for (PropertyValue newPv : this.propertyValueList) {
// if there wasn't an old one, add it
PropertyValue pvOld = old.getPropertyValue(newPv.getName());
if (pvOld == null || !pvOld.equals(newPv)) {
changes.addPropertyValue(newPv);
}
}
return changes;
}
@Override
public boolean contains(String propertyName) {
return (getPropertyValue(propertyName) != null ||
(this.processedProperties != null && this.processedProperties.contains(propertyName)));
}
@Override
public boolean isEmpty() {
return this.propertyValueList.isEmpty();
}
/**
* Register the specified property as "processed" in the sense
* of some processor calling the corresponding setter method
* outside of the PropertyValue(s) mechanism.
* <p>This will lead to {@code true} being returned from
* a {@link #contains} call for the specified property.
* @param propertyName the name of the property.
*/
public void registerProcessedProperty(String propertyName) {
if (this.processedProperties == null) {
this.processedProperties = new HashSet<>(4);
}
this.processedProperties.add(propertyName);
}
/**
* Clear the "processed" registration of the given property, if any.
* @since 3.2.13
*/
public void clearProcessedProperty(String propertyName) {
if (this.processedProperties != null) {
this.processedProperties.remove(propertyName);
}
}
/**
* Mark this holder as containing converted values only
* (i.e. no runtime resolution needed anymore).
*/
public void setConverted() {
this.converted = true;
}
/**
* Return whether this holder contains converted values only ({@code true}),
* or whether the values still need to be converted ({@code false}).
*/
public boolean isConverted() {
return this.converted;
}
}
大体上就是提供了一个List集合用户保存PropertyValue，并且使用一个processedProperties集合记录当前正在处理的属性,然后还用一个convert变量，记录是否进行了类型转换
本篇文章只是简单介绍一下PropertyValue相关类是干啥的，但是这边并没有列出spring实际使用场景，一方面是因为水平有限,很多源码还没读过，另一方面也是篇幅原因，如果只是但拎出来讲的话,可能大部分人听不懂