public BeanPropertyHandler(PropertyDescriptor pd) { super(pd.getPropertyType(), pd.getReadMethod() != null, pd.getWriteMethod() != null); this.pd = pd; }
public static Method[] getPropertyMethods(PropertyDescriptor[] properties, boolean read, boolean write) { Set methods = new HashSet(); for (int i = 0; i < properties.length; i++) { PropertyDescriptor pd = properties[i]; if (read) { methods.add(pd.getReadMethod()); } if (write) { methods.add(pd.getWriteMethod()); } } methods.remove(null); return (Method[]) methods.toArray(new Method[methods.size()]); }
public SimplePropertyDescriptor(PropertyDescriptor original) throws IntrospectionException { this(original.getName(), original.getReadMethod(), original.getWriteMethod()); PropertyDescriptorUtils.copyNonMethodProperties(original, this); }
private static PropertyDescriptor[] getPropertiesHelper(Class type, boolean read, boolean write) { try { BeanInfo info = Introspector.getBeanInfo(type, Object.class); PropertyDescriptor[] all = info.getPropertyDescriptors(); if (read && write) { return all; } List properties = new ArrayList(all.length); for (int i = 0; i < all.length; i++) { PropertyDescriptor pd = all[i]; if ((read && pd.getReadMethod() != null) || (write && pd.getWriteMethod() != null)) { properties.add(pd); } } return (PropertyDescriptor[]) properties.toArray(new PropertyDescriptor[properties.size()]); } catch (IntrospectionException e) { throw new CodeGenerationException(e); } }
for (DynaProperty descriptor : descriptors) { final String name = descriptor.getName(); description.put(name, getProperty(bean, name)); getPropertyDescriptors(bean); for (PropertyDescriptor descriptor : descriptors) { final String name = descriptor.getName(); if (descriptor.getReadMethod() != null) { description.put(name, getProperty(bean, name));
names.put(getters[i].getName(), getters[i]); PropertyDescriptor getter = (PropertyDescriptor)names.get(setter.getName()); if (getter != null) { MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod()); MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod()); if (useConverter) { Type setterType = write.getSignature().getArgumentTypes()[0];
public static <T> void findBooleanIsMethods(Class<T> clazz, PropertyDescriptor descriptor) throws IntrospectionException { if (descriptor.getReadMethod() == null && descriptor.getPropertyType() == Boolean.class) { try { PropertyDescriptor pd = new PropertyDescriptor(descriptor.getName(), clazz); descriptor.setReadMethod(pd.getReadMethod()); } catch (IntrospectionException e) { } } }
private boolean hasReadMethodForProperty(BeanInfo beanInfo, String propertyName) { for (PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) { if (pd.getName().equals(propertyName)) { return pd.getReadMethod() != null; } } return false; }
BeanInfo info = Introspector.getBeanInfo(getMaxRateCode.getClass()); for ( PropertyDescriptor pd : info.getPropertyDescriptors() ) System.out.println(pd.getName()+": "+pd.getReadMethod().invoke(getMaxRateCode));
@Override public Object get(Object object) { try { property.getReadMethod().setAccessible(true);// issue 50 return property.getReadMethod().invoke(object); } catch (Exception e) { throw new YAMLException("Unable to find getter for property '" + property.getName() + "' on object " + object + ":" + e); } }
for(PropertyDescriptor propertyDescriptor : Introspector.getBeanInfo(yourClass).getPropertyDescriptors()){ // propertyEditor.getReadMethod() exposes the getter // btw, this may be null if you have a write-only property System.out.println(propertyDescriptor.getReadMethod()); }
public MethodProperty(PropertyDescriptor property) { super(property.getName(), property.getPropertyType(), MethodProperty.discoverGenericType(property)); this.property = property; this.readable = property.getReadMethod() != null; this.writable = property.getWriteMethod() != null; }
for (DynaProperty descriptor : descriptors) { final String name = descriptor.getName(); description.put(name, getProperty(bean, name)); getPropertyDescriptors(bean); for (PropertyDescriptor descriptor : descriptors) { final String name = descriptor.getName(); if (descriptor.getReadMethod() != null) { description.put(name, getProperty(bean, name));
names.put(getters[i].getName(), getters[i]); PropertyDescriptor getter = (PropertyDescriptor)names.get(setter.getName()); if (getter != null) { MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod()); MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod()); if (useConverter) { Type setterType = write.getSignature().getArgumentTypes()[0];
private static Map<String, ClassProperty> createProperty(Class type) { List<String> fieldNames = Arrays.stream(type.getDeclaredFields()) .map(Field::getName).collect(Collectors.toList()); return Stream.of(propertyUtils.getPropertyDescriptors(type)) .filter(property -> !property.getName().equals("class") && property.getReadMethod() != null && property.getWriteMethod() != null) .map(BeanClassProperty::new) //让字段有序 .sorted(Comparator.comparing(property -> fieldNames.indexOf(property.name))) .collect(Collectors.toMap(ClassProperty::getName, Function.identity(), (k, k2) -> k, LinkedHashMap::new)); }
private static Type discoverGenericType(PropertyDescriptor property) { Method readMethod = property.getReadMethod(); if (readMethod != null) { return readMethod.getGenericReturnType(); } Method writeMethod = property.getWriteMethod(); if (writeMethod != null) { Type[] paramTypes = writeMethod.getGenericParameterTypes(); if (paramTypes.length > 0) { return paramTypes[0]; } } /* * This actually may happen if PropertyDescriptor is of type * IndexedPropertyDescriptor and it has only IndexedGetter/Setter. ATM * we simply skip type discovery. */ return null; }
public BeanPropertyHandler(PropertyDescriptor pd) { super(pd.getPropertyType(), pd.getReadMethod() != null, pd.getWriteMethod() != null); this.pd = pd; }
if (d.getReadMethod() == null) { continue; if (d.getReadMethod().isAnnotationPresent(PersistentSequence.class)) { Object val = d.getReadMethod().invoke(root); if (!Collection.class.isAssignableFrom(val.getClass())) { continue; Collection<SettingsOwner> values = (Collection<SettingsOwner>) val; BeanModelNodeSeq<SimpleBeanModelNode> seq = new BeanModelNodeSeq<>(d.getName()); } else if (d.getReadMethod().isAnnotationPresent(PersistentProperty.class)) { node.addProperty(d.getName(), d.getReadMethod().invoke(root), d.getPropertyType());
private void internalCheckListeners(BeanInfo beanInfo) { PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors(); try { for ( PropertyDescriptor pd : pds ) { final Object listener = pd.getReadMethod().invoke( this, READER_METHOD_ARGS ); if ( listener == null ) { throw new HibernateException( "Listener [" + pd.getName() + "] was null" ); } if ( listener.getClass().isArray() ) { Object[] listenerArray = (Object[]) listener; for ( Object aListenerArray : listenerArray ) { if ( aListenerArray == null ) { throw new HibernateException( "Listener in [" + pd.getName() + "] was null" ); } } } } } catch (HibernateException e) { throw e; } catch (Throwable t) { throw new HibernateException( "Unable to validate listener config" ); } }
MyBean bean = new MyBean(); BeanInfo beanInfo = Introspector.getBeanInfo(MyBean.class); for (PropertyDescriptor propertyDesc : beanInfo.getPropertyDescriptors()) { String propertyName = propertyDesc.getName(); Object value = propertyDesc.getReadMethod().invoke(bean); }