Java BeanUtil.setPropertyValue方法代码示例

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
@SuppressWarnings({ "rawtypes" })
  @Override
  public boolean execute(BeneratorContext context) {
// invoke constructor
      Object bean = constructionExpression.evaluate(context);
      // post construction steps
      super.execute(context);
      if (!StringUtil.isEmpty(id)) {
      	PropertyDescriptor descriptor = BeanUtil.getPropertyDescriptor(bean.getClass(), "id");
      	if (descriptor != null && descriptor.getWriteMethod() != null)
      		BeanUtil.setPropertyValue(bean, "id", id, false);
      }
      if (bean instanceof ContextAware)
	((ContextAware) bean).setContext(context);
if (bean instanceof DescriptorProvider)
	context.getDataModel().addDescriptorProvider((DescriptorProvider) bean);
if (bean instanceof Closeable && resourceManager != null)
	resourceManager.addResource((Closeable) bean);
if (bean instanceof Generator && constructionExpression instanceof BeanConstruction)
	((Generator) bean).init(context);
context.setGlobal(id, bean);
  	return true;
  }
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
private static Object convertEntity(Entity entity) {
	Object result = BeanUtil.newInstance(entity.type());
       for (Map.Entry<String, Object> entry : entity.getComponents().entrySet()) {
           Object value = convertAny(entry.getValue());
		BeanUtil.setPropertyValue(result, entry.getKey(), value, false);
       }
       return result;
}
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
private void parseRestrictionChildren(Element restriction,
		SimpleTypeDescriptor descriptor) {
	Element[] children = XMLUtil.getChildElements(restriction);
       for (Element child : children) {
           String nodeName = localName(child);
           String value = child.getAttribute(VALUE);
           if (ENUMERATION.equals(nodeName)) {
           	if (PrimitiveType.STRING.equals(descriptor.getPrimitiveType()))
           		descriptor.addValue("'" + value + "'");
           	else
           		descriptor.addValue(value);
           } else if (MIN_INCLUSIVE.equals(nodeName)) {
               descriptor.setMin(value);
               descriptor.setMinInclusive(true);
           } else if (MIN_EXCLUSIVE.equals(nodeName)) {
               descriptor.setMin(value);
               descriptor.setMinInclusive(false);
           } else if (MAX_INCLUSIVE.equals(nodeName)) {
               descriptor.setMax(value);
               descriptor.setMaxInclusive(true);
           } else if (MAX_EXCLUSIVE.equals(nodeName)) {
               descriptor.setMax(value);
               descriptor.setMaxInclusive(false);
           } else if (LENGTH.equals(nodeName)) {
               int length = Integer.parseInt(value);
               descriptor.setMinLength(length);
               descriptor.setMaxLength(length);
           } else if (BeanUtil.hasProperty(descriptor.getClass(), nodeName)) {
               BeanUtil.setPropertyValue(descriptor, nodeName, value, false);
           } else
               LOGGER.warn("Ignoring restriction " + nodeName + ": " + value);
       }
}
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
protected void mapAttributesTo(BeneratorContext context) {
	for (Entry<String, String> attribute : attributes.entrySet()) {
   		String key = attribute.getKey();
		String value = attribute.getValue();
		Object result;
		if ("generatorFactory".equals(key))
   			result = DatabeneScriptParser.parseBeanSpec(value).evaluate(context);
		else 
			result = value;
		BeanUtil.setPropertyValue(context, key, result, true, true);
   	}
}
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Generator<?> createConvertingGenerator(TypeDescriptor descriptor,
           Generator<?> generator, BeneratorContext context) {
       Converter<?, ?> converter = DescriptorUtil.getConverter(descriptor.getConverter(), context);
       if (converter != null) {
           if (descriptor.getPattern() != null && BeanUtil.hasProperty(converter.getClass(), PATTERN))
               BeanUtil.setPropertyValue(converter, PATTERN, descriptor.getPattern(), false);
           return WrapperFactory.applyConverter((Generator) generator, converter);
       }
       return generator;
   }
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Generator<?> createConvertingGenerator(TypeDescriptor descriptor, Generator generator, BeneratorContext context) {
    Converter<?,?> converter = DescriptorUtil.getConverter(descriptor.getConverter(), context);
    if (converter != null) {
        if (descriptor.getPattern() != null && BeanUtil.hasProperty(converter.getClass(), PATTERN)) {
            BeanUtil.setPropertyValue(converter, PATTERN, descriptor.getPattern(), false);
        }
        generator = WrapperFactory.applyConverter(generator, converter);
    }
    return generator;
}
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
public static void setBeanProperty(Object bean, String detailName, Object detailValue, Context context) {
    if (detailValue != null && BeanUtil.hasProperty(bean.getClass(), detailName)) {
        try {
            PropertyDescriptor propertyDescriptor = BeanUtil.getPropertyDescriptor(bean.getClass(), detailName);
            Class<?> propertyType = propertyDescriptor.getPropertyType();
            Object propertyValue = detailValue;
            if (detailValue instanceof String && StorageSystem.class.isAssignableFrom(propertyType))
                propertyValue = context.get(propertyValue.toString());
            BeanUtil.setPropertyValue(bean, detailName, propertyValue, false);
        } catch (RuntimeException e) {
            throw new RuntimeException("Error setting '" + detailName + "' of class " + bean.getClass().getName(), e); 
        }
    }
}
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
public static Generator<?> createConvertingGenerator(TypeDescriptor descriptor, Generator<?> generator, BeneratorContext context) {
    Converter<?,?> converter = DescriptorUtil.getConverter(descriptor.getConverter(), context);
    if (converter != null) {
        if (descriptor.getPattern() != null && BeanUtil.hasProperty(converter.getClass(), PATTERN)) {
            BeanUtil.setPropertyValue(converter, PATTERN, descriptor.getPattern(), false);
        }
        generator = DescriptorUtil.createConvertingGenerator(descriptor, generator, context);
    }
    return generator;
}
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
private static void applyProperties(Property[] properties, Object bean, BeneratorContext context) {
for (Property property : properties) {
	Object value = resolveProperty(property, bean, context);
	BeanUtil.setPropertyValue(bean, property.name(), value, true, true);
}
  }
 

import org.databene.commons.BeanUtil; //导入方法依赖的package包/类
private void mapProperty(String propertyName, Entity source, State target, boolean required) {
	String propertyValue = String.valueOf(source.get(propertyName));
	if (required)
		Assert.notNull(propertyValue, propertyName);
	BeanUtil.setPropertyValue(target, propertyName, propertyValue);
}