Java Code Examples for java.beans.PropertyDescriptor#getWriteMethod()

public static void loadBean(HierarchicalConfiguration context, Object beanObject, ConvertUtilsBean converter)   
{
	PropertyUtilsBean beanUtils = new PropertyUtilsBean(); 
	
	PropertyDescriptor[] descriptors = beanUtils.getPropertyDescriptors(beanObject);

	try
	{
		for ( PropertyDescriptor descr : descriptors )
		{
			//check that setter exists
			if ( descr.getWriteMethod() != null )
			{
				String value = context.getString(descr.getName());

                   if(converter.lookup(descr.getPropertyType()) != null) {
                       BeanUtils.setProperty(beanObject, descr.getName(), converter.convert(value, descr.getPropertyType()));
                   }
			}
		}
	}
	catch ( Exception e )
	{
		throw new EPSCommonException(e);
	}
}
 

/**
 * 将对象中的属性按属性名/属性值的方式存入到Map中。
 * 
 * @param bean
 * @param map
 * @param ignore
 */
public static void addBeanProperties2Map(Object bean, Map<String, Object> map, String...ignore){
    List<String> list = Arrays.asList(ignore);
    PropertyDescriptor[] descr = PropertyUtils.getPropertyDescriptors(bean);
    for (int i = 0; i < descr.length; i++) {
        PropertyDescriptor d = descr[i];
        String propertyName = d.getName();
        
        // 既有get又有set方法的属性的值才被读取 
        if ( d.getWriteMethod() == null || d.getReadMethod() == null) continue;
        
        if (list.contains(propertyName)) continue;
        
        try { // put value into Map
            map.put(propertyName, PropertyUtils.getProperty(bean, propertyName));
        } catch (Exception e) {
            log.info("获取属性名为：" + propertyName + " 的值时出错", e);
        }
    }
}
 

@Override
public boolean isGetterVisible(Method m)
{
  if (m == null || !Modifier.isPublic(m.getModifiers())) {
    return false;
  }
  try {
    PropertyDescriptor[] pds = Introspector.getBeanInfo(m.getDeclaringClass()).getPropertyDescriptors();
    for (PropertyDescriptor pd : pds) {
      if (pd.getReadMethod() != null && pd.getReadMethod().equals(m)) {
        Method setter = pd.getWriteMethod();
        if (setter == null || !Modifier.isPublic(setter.getModifiers())) {
          return false;
        } else {
          return true;
        }
      }
    }
  } catch (IntrospectionException e) {
    return false;
  }
  return false;
}
 

/**
 * Initialize the mapping meta-data for the given class.
 * @param mappedClass the mapped class
 */
protected void initialize(Class<T> mappedClass) {
	this.mappedClass = mappedClass;
	this.mappedFields = new HashMap<>();
	this.mappedProperties = new HashSet<>();
	PropertyDescriptor[] pds = BeanUtils.getPropertyDescriptors(mappedClass);
	for (PropertyDescriptor pd : pds) {
		if (pd.getWriteMethod() != null) {
			this.mappedFields.put(lowerCaseName(pd.getName()), pd);
			String underscoredName = underscoreName(pd.getName());
			if (!lowerCaseName(pd.getName()).equals(underscoredName)) {
				this.mappedFields.put(underscoredName, pd);
			}
			this.mappedProperties.add(pd.getName());
		}
	}
}
 

public void run() {
    for (String name : this.names) {
        Object bean;
        try {
            bean = this.loader.loadClass(name).newInstance();
        } catch (Exception exception) {
            throw new Error("could not instantiate bean: " + name, exception);
        }
        if (this.loader != bean.getClass().getClassLoader()) {
            throw new Error("bean class loader is not equal to default one");
        }
        PropertyDescriptor[] pds = getPropertyDescriptors(bean);
        for (PropertyDescriptor pd : pds) {
            Class type = pd.getPropertyType();
            Method setter = pd.getWriteMethod();
            Method getter = pd.getReadMethod();

            if (type.equals(String.class)) {
                executeMethod(setter, bean, "Foo");
            } else if (type.equals(int.class)) {
                executeMethod(setter, bean, Integer.valueOf(1));
            }
            executeMethod(getter, bean);
        }
    }
}
 

public static boolean hasPD(PropertyDescriptor pd) {
    if (null == pd.getPropertyType()) {
        return false;
    }
    return (null != pd.getReadMethod())
        || (null != pd.getWriteMethod());
}
 

public static boolean hasPD(PropertyDescriptor pd) {
    if (null == pd.getPropertyType()) {
        return false;
    }
    return (null != pd.getReadMethod())
        || (null != pd.getWriteMethod());
}
 

/**
 * Locates a serializable property.
 * 
 * @param cls
 * @param name
 * @deprecated As of 1.3.1, use {@link #propertyDescriptor(Class, String)} instead
 */
public BeanProperty property(Class cls, String name) {
    BeanProperty beanProperty = null;
    PropertyDescriptor descriptor = propertyDescriptorOrNull(cls, name);
    if (descriptor == null) {
        throw new MissingFieldException(cls.getName(), name);
    }
    if (descriptor.getReadMethod() != null && descriptor.getWriteMethod() != null) {
        beanProperty = new BeanProperty(
            cls, descriptor.getName(), descriptor.getPropertyType());
    }
    return beanProperty;
}
 

/**
 * Return an array of non-simple bean properties that are unsatisfied.
 * These are probably unsatisfied references to other beans in the
 * factory. Does not include simple properties like primitives or Strings.
 * @param mbd the merged bean definition the bean was created with
 * @param bw the BeanWrapper the bean was created with
 * @return an array of bean property names
 * @see org.springframework.beans.BeanUtils#isSimpleProperty
 */
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
	Set<String> result = new TreeSet<>();
	PropertyValues pvs = mbd.getPropertyValues();
	PropertyDescriptor[] pds = bw.getPropertyDescriptors();
	for (PropertyDescriptor pd : pds) {
		if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
				!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
			result.add(pd.getName());
		}
	}
	return StringUtils.toStringArray(result);
}
 

public boolean isWritableProperty(String propertyName){
    PropertyDescriptor descriptor = getPropertyDescriptor(propertyName);
    if(descriptor == null){
        return false;
    }
    return descriptor.getWriteMethod() != null;
}
 

/** Validates that setters don't have the given annotation. */
private static void validateSettersDoNotHaveAnnotation(
    SortedSetMultimap<Method, Method> methodNameToAllMethodMap,
    List<PropertyDescriptor> descriptors,
    AnnotationPredicates annotationPredicates) {
  List<AnnotatedSetter> annotatedSetters = new ArrayList<>();
  for (PropertyDescriptor descriptor : descriptors) {
    if (descriptor.getWriteMethod() == null
        || IGNORED_METHODS.contains(descriptor.getWriteMethod())) {
      continue;
    }
    SortedSet<Method> settersWithTheAnnotation =
        Sets.filter(
            methodNameToAllMethodMap.get(descriptor.getWriteMethod()),
            annotationPredicates.forMethod);

    Iterable<String> settersWithTheAnnotationClassNames =
        FluentIterable.from(settersWithTheAnnotation)
            .transform(MethodToDeclaringClassFunction.INSTANCE)
            .transform(ReflectHelpers.CLASS_NAME);

    if (!settersWithTheAnnotation.isEmpty()) {
      AnnotatedSetter annotated = new AnnotatedSetter();
      annotated.descriptor = descriptor;
      annotated.settersWithTheAnnotationClassNames = settersWithTheAnnotationClassNames;
      annotatedSetters.add(annotated);
    }
  }
  throwForSettersWithTheAnnotation(annotatedSetters, annotationPredicates.annotationClass);
}
 

private static void test(Class type) {
    PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(type, "prop");
    if (pd instanceof IndexedPropertyDescriptor) {
        error(pd, type.getSimpleName() + ".prop should not be an indexed property");
    }
    if (!pd.getPropertyType().equals(Color.class)) {
        error(pd, type.getSimpleName() + ".prop type should be a Color");
    }
    if (null == pd.getReadMethod()) {
        error(pd, type.getSimpleName() + ".prop should have classic read method");
    }
    if (null == pd.getWriteMethod()) {
        error(pd, type.getSimpleName() + ".prop should have classic write method");
    }
}
 

private void initialise() {
    if(getBean() == null) return;

    Class  beanClass = getBean().getClass();
    try {
        //BeanInfo beanInfo = Introspector.getBeanInfo( bean, null );
        BeanInfo beanInfo = Introspector.getBeanInfo( beanClass );
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        if ( propertyDescriptors != null ) {
            for ( int i = 0; i < propertyDescriptors.length; i++ ) {
                PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
                if ( propertyDescriptor != null ) {
                    String name = propertyDescriptor.getName();
                    Method readMethod = propertyDescriptor.getReadMethod();
                    Method writeMethod = propertyDescriptor.getWriteMethod();
                    Class aType = propertyDescriptor.getPropertyType();

                    if ( readMethod != null ) {
                        readMethods.put( name, readMethod );
                    }
                    if ( writeMethods != null ) {
                        writeMethods.put( name, writeMethod );
                    }
                    types.put( name, aType );
                }
            }
        }
    }
    catch ( IntrospectionException e ) {
        logWarn(  e );
    }
}
 

public static boolean hasPD(PropertyDescriptor pd) {
    if (null == pd.getPropertyType()) {
        return false;
    }
    return (null != pd.getReadMethod())
        || (null != pd.getWriteMethod());
}
 

private boolean needDeserialisation(PropertyDescriptor desc) {
    return (desc.getPropertyType() != null) && (desc.getWriteMethod() != null) && (desc.getReadMethod() != null)
            && (desc.getReadMethod().getAnnotation(NoAutoSerialisation.class) == null)
            && (desc.getWriteMethod().getAnnotation(NoAutoSerialisation.class) == null);
}
 

/**
 * refresh bean with xxl conf (fieldNames)
 */
public static void refreshBeanField(final BeanRefreshXxlConfListener.BeanField beanField, final String value, Object bean){
	if (bean == null) {
		bean = XxlConfFactory.beanFactory.getBean(beanField.getBeanName());		// 已优化：启动时禁止实用，getBean 会导致Bean提前初始化，风险较大；
	}
	if (bean == null) {
		return;
	}

	BeanWrapper beanWrapper = new BeanWrapperImpl(bean);

	// property descriptor
	PropertyDescriptor propertyDescriptor = null;
	PropertyDescriptor[] propertyDescriptors = beanWrapper.getPropertyDescriptors();
	if (propertyDescriptors!=null && propertyDescriptors.length>0) {
		for (PropertyDescriptor item: propertyDescriptors) {
			if (beanField.getProperty().equals(item.getName())) {
				propertyDescriptor = item;
			}
		}
	}

	// refresh field: set or field
	if (propertyDescriptor!=null && propertyDescriptor.getWriteMethod() != null) {
		beanWrapper.setPropertyValue(beanField.getProperty(), value);	// support mult data types
		logger.info(">>>>>>>>>>> xxl-conf, refreshBeanField[set] success, {}#{}:{}",
				beanField.getBeanName(), beanField.getProperty(), value);
	} else {

		final Object finalBean = bean;
		ReflectionUtils.doWithFields(bean.getClass(), new ReflectionUtils.FieldCallback() {
			@Override
			public void doWith(Field fieldItem) throws IllegalArgumentException, IllegalAccessException {
				if (beanField.getProperty().equals(fieldItem.getName())) {
					try {
						Object valueObj = FieldReflectionUtil.parseValue(fieldItem.getType(), value);

						fieldItem.setAccessible(true);
						fieldItem.set(finalBean, valueObj);		// support mult data types

						logger.info(">>>>>>>>>>> xxl-conf, refreshBeanField[field] success, {}#{}:{}",
								beanField.getBeanName(), beanField.getProperty(), value);
					} catch (IllegalAccessException e) {
						throw new XxlConfException(e);
					}
				}
			}
		});

		/*Field[] beanFields = bean.getClass().getDeclaredFields();
		if (beanFields!=null && beanFields.length>0) {
			for (Field fieldItem: beanFields) {
				if (beanField.getProperty().equals(fieldItem.getName())) {
					try {
						Object valueObj = FieldReflectionUtil.parseValue(fieldItem.getType(), value);

						fieldItem.setAccessible(true);
						fieldItem.set(bean, valueObj);		// support mult data types

						logger.info(">>>>>>>>>>> xxl-conf, refreshBeanField[field] success, {}#{}:{}",
								beanField.getBeanName(), beanField.getProperty(), value);
					} catch (IllegalAccessException e) {
						throw new XxlConfException(e);
					}
				}
			}
		}*/
	}

}
 

private List<Parameter> extractParametersFromModelAttributeAnnotation(Type type, Map<Class<?>, Annotation> annotations) {
    ModelAttribute modelAttribute = (ModelAttribute)annotations.get(ModelAttribute.class);
    if ((modelAttribute == null || !hasClassStartingWith(annotations.keySet(), "org.springframework.web.bind.annotation"))&& BeanUtils.isSimpleProperty(TypeUtils.getRawType(type, null))) {
        return Collections.emptyList();
    }

    List<Parameter> parameters = new ArrayList<Parameter>();
    Class<?> clazz = TypeUtils.getRawType(type, type);
    for (PropertyDescriptor propertyDescriptor : BeanUtils.getPropertyDescriptors(clazz)) {
        // Get all the valid setter methods inside the bean
        Method propertyDescriptorSetter = propertyDescriptor.getWriteMethod();
        if (propertyDescriptorSetter != null) {
            ApiParam propertySetterApiParam = AnnotationUtils.findAnnotation(propertyDescriptorSetter, ApiParam.class);
            if (propertySetterApiParam == null) {
                // If we find a setter that doesn't have @ApiParam annotation, then skip it
                continue;
            }

            // Here we have a bean setter method that is annotted with @ApiParam, but we still
            // need to know what type of parameter to create. In order to do this, we look for
            // any annotation attached to the first method parameter of the setter fucntion.
            Annotation[][] parameterAnnotations = propertyDescriptorSetter.getParameterAnnotations();
            if (parameterAnnotations == null || parameterAnnotations.length == 0) {
                continue;
            }

            Class parameterClass = propertyDescriptor.getPropertyType();
            List<Parameter> propertySetterExtractedParameters = this.extractParametersFromAnnotation(
                    parameterClass, toMap(Arrays.asList(parameterAnnotations[0])));

            for (Parameter parameter : propertySetterExtractedParameters) {
                if (Strings.isNullOrEmpty(parameter.getName())) {
                    parameter.setName(propertyDescriptor.getDisplayName());
                }
                ParameterProcessor.applyAnnotations(new Swagger(), parameter, type, Lists.newArrayList(propertySetterApiParam));
            }
            parameters.addAll(propertySetterExtractedParameters);
        }
    }

    return parameters;
}
 

Updatability updatability(Class<?> clazz, Field field) {

		PropertyDescriptor descriptor = org.springframework.beans.BeanUtils.getPropertyDescriptor(clazz, field.getName());
		return (descriptor.getWriteMethod() != null) ? Updatability.READWRITE : Updatability.READONLY;
	}
 

@Override
protected BeanInfo instantiate(Class<?> type, String prefix, String name) {
    if (DEFAULT.equals(prefix)) {
        prefix = DEFAULT_NEW;
    }
    // this optimization will only use the BeanInfo search path
    // if is has changed from the original
    // or trying to get the ComponentBeanInfo
    BeanInfo info = !DEFAULT_NEW.equals(prefix) || "ComponentBeanInfo".equals(name)
            ? super.instantiate(type, prefix, name)
            : null;

    if (info != null) {
        // make sure that the returned BeanInfo matches the class
        BeanDescriptor bd = info.getBeanDescriptor();
        if (bd != null) {
            if (type.equals(bd.getBeanClass())) {
                return info;
            }
        }
        else {
            PropertyDescriptor[] pds = info.getPropertyDescriptors();
            if (pds != null) {
                for (PropertyDescriptor pd : pds) {
                    Method method = pd.getReadMethod();
                    if (method == null) {
                        method = pd.getWriteMethod();
                    }
                    if (isValid(type, method)) {
                        return info;
                    }
                }
            }
            else {
                MethodDescriptor[] mds = info.getMethodDescriptors();
                if (mds != null) {
                    for (MethodDescriptor md : mds) {
                        if (isValid(type, md.getMethod())) {
                            return info;
                        }
                    }
                }
            }
        }
    }
    return null;
}
 

/**
 * 获取 类属性信息
 * @param propertyType 类型
 * @param propertyDescriptor PropertyDescriptor
 * @param propertyName 属性名
 * @return {Property}
 */
public static TypeDescriptor getTypeDescriptor(Class<?> propertyType, PropertyDescriptor propertyDescriptor, String propertyName) {
	Method readMethod = propertyDescriptor.getReadMethod();
	Method writeMethod = propertyDescriptor.getWriteMethod();
	Property property = new Property(propertyType, readMethod, writeMethod, propertyName);
	return new TypeDescriptor(property);
}