Java 类org.springframework.beans.ConfigurablePropertyAccessor 实例源码

public void mapToObject(Object obj) {
    Assert.notEmpty(config);
    boolean hasPrefix = StringUtils.isNotBlank(prefix);

    ConfigurablePropertyAccessor bw = beanAccessors.createAccessor(obj);
    Enumeration<?> names = config.propertyNames();
    while(names.hasMoreElements()){
        String propertyName = names.nextElement().toString();
        String value = config.getProperty(propertyName);
        if(value==null){
            continue;
        }
        if(StringUtils.isBlank(value) && ignoreBlankString){
            continue;
        }
        if(hasPrefix){
            if(propertyName.startsWith(prefix)){
                propertyName = propertyName.substring(prefix.length());
                setPropertyValue(obj, bw, propertyName, value);
            }
        }else{
            setPropertyValue(obj, bw, propertyName, value);
        }
    }
}

/**
 * 判断对象属性是否有格式可以应用。调用format()前必须先调用canFormat()
 * 
 * @param obj
 * @param prop
 * @return
 */
public static boolean canFormat(ConfigurablePropertyAccessor bw,
        Object obj, String prop) {
    String key = obj.getClass().getName() + "_" + prop;

    if (!cache.containsKey(key)) {
        cache.put(key, false);

        TypeDescriptor td = bw.getPropertyTypeDescriptor(prop);
        if (td != null) {
            WinletDefaultFormattingConversionService wcs = get();
            if (wcs != null
                    && wcs.hasFmtAnnotation(td)
                    && wcs.canConvert(td,
                            TypeDescriptor.valueOf(String.class)))
                cache.put(key, true);
        }
    }

    return cache.get(key);
}

/**
 * 如果有格式可应用则应用
 * 
 * @param bw
 * @param obj
 * @param prop
 * @return
 */
public static String format(ConfigurablePropertyAccessor bw, Object obj,
        String prop) {
    String key = obj.getClass().getName() + "_" + prop;

    if (!cache.containsKey(key))
        canFormat(bw, obj, prop);

    Object val = bw.getPropertyValue(prop);

    if (val == null)
        return null;
    if (val.getClass().isArray())
        return null;

    if (!cache.get(key))
        return val.toString();

    TypeDescriptor td = bw.getPropertyTypeDescriptor(prop);
    val = get().convert(val, td, TypeDescriptor.valueOf(String.class));

    return val == null ? null : val.toString();
}

/**
 * Returns the DirectFieldAccessor that this instance uses.
 * Creates a new one if none existed before.
 * @see #createDirectFieldAccessor()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.directFieldAccessor == null) {
        this.directFieldAccessor = createDirectFieldAccessor();
        this.directFieldAccessor.setExtractOldValueForEditor(true);
    }
    return this.directFieldAccessor;
}

/**
 * Returns the {@link BeanWrapper} that this instance uses.
 * Creates a new one if none existed before.
 * @see #createBeanWrapper()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.beanWrapper == null) {
        this.beanWrapper = createBeanWrapper();
        this.beanWrapper.setExtractOldValueForEditor(true);
        this.beanWrapper.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
        this.beanWrapper.setAutoGrowCollectionLimit(this.autoGrowCollectionLimit);
    }
    return this.beanWrapper;
}

/**
 * Returns the DirectFieldAccessor that this instance uses.
 * Creates a new one if none existed before.
 * @see #createDirectFieldAccessor()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.directFieldAccessor == null) {
        this.directFieldAccessor = createDirectFieldAccessor();
        this.directFieldAccessor.setExtractOldValueForEditor(true);
        this.directFieldAccessor.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
    }
    return this.directFieldAccessor;
}

/**
 * Returns the {@link BeanWrapper} that this instance uses.
 * Creates a new one if none existed before.
 * @see #createBeanWrapper()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.beanWrapper == null) {
        this.beanWrapper = createBeanWrapper();
        this.beanWrapper.setExtractOldValueForEditor(true);
        this.beanWrapper.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
        this.beanWrapper.setAutoGrowCollectionLimit(this.autoGrowCollectionLimit);
    }
    return this.beanWrapper;
}

/**
 * Returns the DirectFieldAccessor that this instance uses.
 * Creates a new one if none existed before.
 * @see #createDirectFieldAccessor()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.directFieldAccessor == null) {
        this.directFieldAccessor = createDirectFieldAccessor();
        this.directFieldAccessor.setExtractOldValueForEditor(true);
    }
    return this.directFieldAccessor;
}

/**
 * Returns the {@link BeanWrapper} that this instance uses.
 * Creates a new one if none existed before.
 * @see #createBeanWrapper()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.beanWrapper == null) {
        this.beanWrapper = createBeanWrapper();
        this.beanWrapper.setExtractOldValueForEditor(true);
        this.beanWrapper.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
        this.beanWrapper.setAutoGrowCollectionLimit(this.autoGrowCollectionLimit);
    }
    return this.beanWrapper;
}

/**
 * Returns the DirectFieldAccessor that this instance uses.
 * Creates a new one if none existed before.
 * @see #createDirectFieldAccessor()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.directFieldAccessor == null) {
        this.directFieldAccessor = createDirectFieldAccessor();
        this.directFieldAccessor.setExtractOldValueForEditor(true);
        this.directFieldAccessor.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
    }
    return this.directFieldAccessor;
}

/**
 * Returns the {@link BeanWrapper} that this instance uses.
 * Creates a new one if none existed before.
 * @see #createBeanWrapper()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.beanWrapper == null) {
        this.beanWrapper = createBeanWrapper();
        this.beanWrapper.setExtractOldValueForEditor(true);
        this.beanWrapper.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
        this.beanWrapper.setAutoGrowCollectionLimit(this.autoGrowCollectionLimit);
    }
    return this.beanWrapper;
}

private List<PropertyChange<?>> handleModification(DescriptorEvent event)
{
    final Class<?> objectClass = event.getSource().getClass();

    final WriteObjectQuery writeObjectQuery = (WriteObjectQuery)event.getQuery();
    final ObjectChangeSet changeset = writeObjectQuery.getObjectChangeSet();
    final ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forDirectFieldAccess(event.getObject());

    final List<ChangeRecord> changes = changeset != null ? changeset.getChanges() : extractManually(writeObjectQuery, fieldFilter);
    final List<PropertyChange<?>> propChanges = new ArrayList<PropertyChange<?>>();
    for (ChangeRecord change : changes)
    {
        final String attrName = change.getAttribute();
        final Object newValue = accessor.getPropertyValue(attrName);
        final Object oldValue = change.getOldValue();
        final Class<?> attrType = accessor.getPropertyType(attrName);

        final Field field = ReflectionUtils.findField(objectClass, change.getAttribute());
        if (fieldFilter != null && !fieldFilter.test(field))
        {
            continue;
        }

        entityUtil.extractSingle(field, attrName, attrType, oldValue, newValue, propChanges);
    }
    return propChanges;
}

protected void setPropertyValue(Object obj, ConfigurablePropertyAccessor bw, String propertyName, Object value){
    if(!bw.isWritableProperty(propertyName)){
        if(!ignoreNotFoundProperty){
            throw new NoSuchElementException("no setter found for property: " + propertyName+", target: " + obj);
        }
        logger.debug("ignore property: {}={} ", propertyName, value);
        return ;
    }
    bw.setPropertyValue(propertyName, value);
    if(logger.isDebugEnabled()){
        logger.debug("set property: {}={} ", propertyName, value);
    }
}

/**
 * Returns the DirectFieldAccessor that this instance uses.
 * Creates a new one if none existed before.
 * @see #createDirectFieldAccessor()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.directFieldAccessor == null) {
        this.directFieldAccessor = createDirectFieldAccessor();
        this.directFieldAccessor.setExtractOldValueForEditor(true);
    }
    return this.directFieldAccessor;
}

/**
 * Returns the {@link BeanWrapper} that this instance uses.
 * Creates a new one if none existed before.
 * @see #createBeanWrapper()
 */
@Override
public final ConfigurablePropertyAccessor getPropertyAccessor() {
    if (this.beanWrapper == null) {
        this.beanWrapper = createBeanWrapper();
        this.beanWrapper.setExtractOldValueForEditor(true);
        this.beanWrapper.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
        this.beanWrapper.setAutoGrowCollectionLimit(this.autoGrowCollectionLimit);
    }
    return this.beanWrapper;
}

protected Object getBean(String beanName, Map<String, Object> model) {
    Object bean;
    if (model != null) {
        bean = model.get(beanName);
    } else {
        ConfigurablePropertyAccessor bw = PropertyAccessorFactory.forDirectFieldAccess(getRequestContext());
        HttpServletRequest request = (HttpServletRequest) bw.getPropertyValue("request");
        bean = request.getAttribute(beanName);
    }
    return bean;
}

/**
 * Create a new DirectFieldAccessor for the underlying target object.
 * @see #getTarget()
 */
protected ConfigurablePropertyAccessor createDirectFieldAccessor() {
    Assert.state(this.target != null, "Cannot access fields on null target instance '" + getObjectName() + "'!");
    return PropertyAccessorFactory.forDirectFieldAccess(this.target);
}

/**
 * Return the underlying PropertyAccessor of this binder's BindingResult.
 */
protected ConfigurablePropertyAccessor getPropertyAccessor() {
    return getInternalBindingResult().getPropertyAccessor();
}

/**
 * Create a new DirectFieldAccessor for the underlying target object.
 * @see #getTarget()
 */
protected ConfigurablePropertyAccessor createDirectFieldAccessor() {
    Assert.state(this.target != null, "Cannot access fields on null target instance '" + getObjectName() + "'!");
    return PropertyAccessorFactory.forDirectFieldAccess(this.target);
}

/**
 * Return the underlying PropertyAccessor of this binder's BindingResult.
 */
protected ConfigurablePropertyAccessor getPropertyAccessor() {
    return getInternalBindingResult().getPropertyAccessor();
}

/**
 * Create a new DirectFieldAccessor for the underlying target object.
 * @see #getTarget()
 */
protected ConfigurablePropertyAccessor createDirectFieldAccessor() {
    Assert.state(this.target != null, "Cannot access fields on null target instance '" + getObjectName() + "'!");
    return PropertyAccessorFactory.forDirectFieldAccess(this.target);
}

/**
 * Return the underlying PropertyAccessor of this binder's BindingResult.
 */
protected ConfigurablePropertyAccessor getPropertyAccessor() {
    return getInternalBindingResult().getPropertyAccessor();
}

/**
 * Create a new DirectFieldAccessor for the underlying target object.
 * @see #getTarget()
 */
protected ConfigurablePropertyAccessor createDirectFieldAccessor() {
    Assert.state(this.target != null, "Cannot access fields on null target instance '" + getObjectName() + "'!");
    return PropertyAccessorFactory.forDirectFieldAccess(this.target);
}

/**
 * Return the underlying PropertyAccessor of this binder's BindingResult.
 */
protected ConfigurablePropertyAccessor getPropertyAccessor() {
    return getInternalBindingResult().getPropertyAccessor();
}

private List<ChangeRecord> extractManually(WriteObjectQuery writeObjectQuery, Predicate<Field> filter)
{
    final Object oldObj = writeObjectQuery.getBackupClone();
    final Object newObj = writeObjectQuery.getObject();

    final ConfigurablePropertyAccessor accessorOld = PropertyAccessorFactory.forDirectFieldAccess(oldObj);
    final ConfigurablePropertyAccessor accessorNew = PropertyAccessorFactory.forDirectFieldAccess(newObj);
    final BeanWrapper beanAccessor = PropertyAccessorFactory.forBeanPropertyAccess(newObj);

    final List<ChangeRecord> retVal = new LinkedList<>();
    for (PropertyDescriptor desc : beanAccessor.getPropertyDescriptors())
    {
        final String propName = desc.getName();
        if (accessorNew.isReadableProperty(propName))
        {
            final Field field = ReflectionUtils.findField(oldObj.getClass(), propName);
            if (filter == null || filter.test(field))
            {
                final Object newPropValue = accessorNew.getPropertyValue(propName);
                final Object oldPropValue = accessorOld.getPropertyValue(propName);
                if (! Objects.equals(newPropValue, oldPropValue))
                {
                    final ChangeRecord c = new ChangeRecord()
                    {
                        @Override
                        public ObjectChangeSet getOwner()
                        {
                            return null;
                        }

                        @Override
                        public Object getOldValue()
                        {
                            return oldPropValue;
                        }

                        @Override
                        public String getAttribute()
                        {
                            return propName;
                        }
                    };
                    retVal.add(c);
                }
            }
        }
    }
    return retVal;
}

@Override
public ConfigurablePropertyAccessor createAccessor(Object obj) {
    ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forBeanPropertyAccess(obj);
    accessor.setAutoGrowNestedPaths(true);
    return accessor;
}

@Override
public ConfigurablePropertyAccessor createAccessor(Object obj) {
    ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forDirectFieldAccess(obj);
    accessor.setAutoGrowNestedPaths(true);
    return accessor;
}

public static ConfigurablePropertyAccessor newPropertyAccessor(Object obj, boolean directFieldAccess){
    ConfigurablePropertyAccessor bw = directFieldAccess?PropertyAccessorFactory.forDirectFieldAccess(obj):PropertyAccessorFactory.forBeanPropertyAccess(obj);
    bw.setAutoGrowNestedPaths(true);
    return bw;
}

private boolean isNullAndWritableProperty(ConfigurablePropertyAccessor accessor, String propertyName) {
    return accessor.isWritableProperty(propertyName) && (accessor.isReadableProperty(propertyName) && accessor.getPropertyValue(propertyName) == null);
}

/**
 * Create a new DirectFieldAccessor for the underlying target object.
 * @see #getTarget()
 */
protected ConfigurablePropertyAccessor createDirectFieldAccessor() {
    Assert.state(this.target != null, "Cannot access fields on null target instance '" + getObjectName() + "'!");
    return PropertyAccessorFactory.forDirectFieldAccess(this.target);
}

/**
 * Return the underlying PropertyAccessor of this binder's BindingResult.
 */
protected ConfigurablePropertyAccessor getPropertyAccessor() {
    return getInternalBindingResult().getPropertyAccessor();
}

/**
 * Provide the PropertyAccessor to work with, according to the
 * concrete strategy of access.
 * <p>Note that a PropertyAccessor used by a BindingResult should
 * always have its "extractOldValueForEditor" flag set to "true"
 * by default, since this is typically possible without side effects
 * for model objects that serve as data binding target.
 * @see ConfigurablePropertyAccessor#setExtractOldValueForEditor
 */
public abstract ConfigurablePropertyAccessor getPropertyAccessor();

/**
 * Provide the PropertyAccessor to work with, according to the
 * concrete strategy of access.
 * <p>Note that a PropertyAccessor used by a BindingResult should
 * always have its "extractOldValueForEditor" flag set to "true"
 * by default, since this is typically possible without side effects
 * for model objects that serve as data binding target.
 * @see ConfigurablePropertyAccessor#setExtractOldValueForEditor
 */
public abstract ConfigurablePropertyAccessor getPropertyAccessor();

/**
 * Provide the PropertyAccessor to work with, according to the
 * concrete strategy of access.
 * <p>Note that a PropertyAccessor used by a BindingResult should
 * always have its "extractOldValueForEditor" flag set to "true"
 * by default, since this is typically possible without side effects
 * for model objects that serve as data binding target.
 * @see ConfigurablePropertyAccessor#setExtractOldValueForEditor
 */
public abstract ConfigurablePropertyAccessor getPropertyAccessor();

/**
 * Provide the PropertyAccessor to work with, according to the
 * concrete strategy of access.
 * <p>Note that a PropertyAccessor used by a BindingResult should
 * always have its "extractOldValueForEditor" flag set to "true"
 * by default, since this is typically possible without side effects
 * for model objects that serve as data binding target.
 * @see ConfigurablePropertyAccessor#setExtractOldValueForEditor
 */
public abstract ConfigurablePropertyAccessor getPropertyAccessor();

/**
 * Provide the PropertyAccessor to work with, according to the
 * concrete strategy of access.
 * <p>Note that a PropertyAccessor used by a BindingResult should
 * always have its "extractOldValueForEditor" flag set to "true"
 * by default, since this is typically possible without side effects
 * for model objects that serve as data binding target.
 * @see ConfigurablePropertyAccessor#setExtractOldValueForEditor
 */
public abstract ConfigurablePropertyAccessor getPropertyAccessor();

abstract public ConfigurablePropertyAccessor createAccessor(Object obj);