Example usage for org.springframework.beans BeanUtils getWriteMethodParameter

Introduction

In this page you can find the example usage for org.springframework.beans BeanUtils getWriteMethodParameter.

Prototype

public static MethodParameter getWriteMethodParameter(PropertyDescriptor pd) 

Source Link

Document

Obtain a new MethodParameter object for the write method of the specified property.

Usage

From source file:com.alibaba.citrus.service.form.impl.GroupImpl.java

/**
 * group//from   w  w w  .j a v a2 s.c  om
 * <p>
 * <code>isValidated()</code><code>false</code>group
 * </p>
 */
public void setProperties(Object object) {
    if (!isValidated() || object == null) {
        return;
    }

    if (isValid()) {
        if (log.isDebugEnabled()) {
            log.debug("Set validated properties of group \"" + getName() + "\" to object "
                    + ObjectUtil.identityToString(object));
        }

        BeanWrapper bean = new BeanWrapperImpl(object);
        getForm().getFormConfig().getPropertyEditorRegistrar().registerCustomEditors(bean);

        for (Field field : getFields()) {
            String propertyName = field.getFieldConfig().getPropertyName();

            if (bean.isWritableProperty(propertyName)) {
                PropertyDescriptor pd = bean.getPropertyDescriptor(propertyName);
                MethodParameter mp = BeanUtils.getWriteMethodParameter(pd);
                Object value = field.getValueOfType(pd.getPropertyType(), mp, null);

                bean.setPropertyValue(propertyName, value);
            } else {
                log.debug("No writable property \"{}\" found in type {}", propertyName,
                        object.getClass().getName());
            }
        }
    } else {
        throw new InvalidGroupStateException("Attempted to call setProperties from an invalid input");
    }
}

---

From source file:org.beangle.spring.bind.AutoConfigProcessor.java

protected void autowire(String beanName, BeanDefinition mbd) {
    Map<String, PropertyDescriptor> properties = unsatisfiedNonSimpleProperties(mbd);
    for (Map.Entry<String, PropertyDescriptor> entry : properties.entrySet()) {
        String propertyName = entry.getKey();
        PropertyDescriptor pd = entry.getValue();
        if (Object.class.equals(pd.getPropertyType()))
            continue;
        MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
        List<String> beanNames = bindRegistry.getBeanNames(methodParam.getParameterType());
        boolean binded = false;
        if (beanNames.size() == 1) {
            mbd.getPropertyValues().add(propertyName, new RuntimeBeanReference(beanNames.get(0)));
            binded = true;/*  w ww  .  j a  v a  2  s.c  o m*/
        } else if (beanNames.size() > 1) {
            for (String name : beanNames) {
                if (name.equals(propertyName)) {
                    mbd.getPropertyValues().add(propertyName, new RuntimeBeanReference(propertyName));
                    binded = true;
                    break;
                }
            }
        }
        if (!binded) {
            if (beanNames.isEmpty()) {
                logger.debug(beanName + "'s " + propertyName + "  cannot  found candidate bean");
            } else {
                logger.warn(beanName + "'s " + propertyName + " expected single bean but found {} : {}",
                        beanNames.size(), beanNames);
            }
        }
    }
}

---

From source file:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java

/**
 * Abstract method defining "autowire by type" (bean properties by type) behavior.
 * <p>This is like PicoContainer default, in which there must be exactly one bean
 * of the property type in the bean factory. This makes bean factories simple to
 * configure for small namespaces, but doesn't work as well as standard Spring
 * behavior for bigger applications.//from  w  w  w .j  a v a  2s .c  om
 * @param beanName the name of the bean to autowire by type
 * @param mbd the merged bean definition to update through autowiring
 * @param bw the BeanWrapper from which we can obtain information about the bean
 * @param pvs the PropertyValues to register wired objects with
 */
protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw,
        MutablePropertyValues pvs) {

    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        try {
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            // Don't try autowiring by type for type Object: never makes sense,
            // even if it technically is a unsatisfied, non-simple property.
            if (Object.class != pd.getPropertyType()) {
                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                // Do not allow eager init for type matching in case of a prioritized post-processor.
                boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                for (String autowiredBeanName : autowiredBeanNames) {
                    registerDependentBean(autowiredBeanName, beanName);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Autowiring by type from bean name '" + beanName + "' via property '"
                                + propertyName + "' to bean named '" + autowiredBeanName + "'");
                    }
                }
                autowiredBeanNames.clear();
            }
        } catch (BeansException ex) {
            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
        }
    }
}

---

From source file:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java

/**
 * Convert the given value for the specified target property.
 *//*  w  ww . j a  va2  s  .c  o m*/
@Nullable
private Object convertForProperty(@Nullable Object value, String propertyName, BeanWrapper bw,
        TypeConverter converter) {

    if (converter instanceof BeanWrapperImpl) {
        return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
    } else {
        PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
        MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
        return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
    }
}

---

From source file:org.tinygroup.beanwrapper.TypeConverterDelegate.java

/**
 * Convert the value to the required type for the specified property.
 * @param oldValue the previous value, if available (may be <code>null</code>)
 * @param newValue the proposed new value
 * @param descriptor the JavaBeans descriptor for the property
 * @return the new value, possibly the result of type conversion
 * @throws IllegalArgumentException if type conversion failed
 *//*  www .  j  a v  a  2s.c  om*/
public Object convertIfNecessary(Object oldValue, Object newValue, PropertyDescriptor descriptor)
        throws IllegalArgumentException {

    return convertIfNecessary(descriptor.getName(), oldValue, newValue, descriptor.getPropertyType(),
            descriptor, BeanUtils.getWriteMethodParameter(descriptor));
}

---