Return propertys value.
@param bean
@param property
@return
557261
public static final Object getValue(Object bean, String property)
    {
        return doFor(bean, property, null, BeanHelper::getValue, BeanHelper::getValue, BeanHelper::getFieldValue, BeanHelper::getMethodValue);
    }
337773
public static <P> BasicProperty<P> of(Bean bean, MetaProperty<P> metaProperty) {
        return new BasicProperty<>(bean, metaProperty);
    }
318025
@Override
    @SuppressWarnings("unchecked")
    public P get(Bean bean) {
        if (style().isReadable() == false) {
            throw new UnsupportedOperationException("Property cannot be read: " + name());
        }
        try {
            return (P) getMethod.invoke(bean, (Object[]) null);
        } catch (IllegalArgumentException | IllegalAccessException ex) {
            throw new UnsupportedOperationException("Property cannot be read: " + name(), ex);
        } catch (InvocationTargetException ex) {
            if (ex.getCause() instanceof RuntimeException) {
                throw (RuntimeException) ex.getCause();
            }
            throw new RuntimeException(ex);
        }
    }
60447
@SuppressWarnings({ "unchecked", "rawtypes" })
	protected Object readBean(Object bean) {
		log.debug("readBean: {}", bean);
		storeReference(bean);
		Class theClass = bean.getClass();
		while (hasMoreProperties()) {
			String name = readPropertyName();
			Type type = getPropertyType(bean, name);
			log.debug("property: {} type: {}", name, type);
			Object property = Deserializer.deserialize(this, type);
			log.debug("val: {}", property);
			// log.debug("val: "+property.getClass().getName());
			if (property != null) {
				try {
					if (type instanceof Class) {
						Class t = (Class) type;
						if (!t.isAssignableFrom(property.getClass())) {
							property = ConversionUtils.convert(property, t);
						}
					}
					final Field field = theClass.getField(name);
					field.set(bean, property);
				} catch (Exception ex2) {
					try {
						BeanUtils.setProperty(bean, name, property);
					} catch (Exception ex) {
						log.error("Error mapping property: {} ({})", name,
								property);
					}
				}
			} else {
				log.debug("Skipping null property: {}", name);
			}
			if (hasMoreProperties()) {
				skipPropertySeparator();
			} else {
				break; // hasMoreProperties == false, position moved to +3
			}
		}
		return bean;
	}
591666
private static PropertyDescriptor[] getPropertyDescriptors(Object bean)
   {
       if(bean == null)
           throw new IllegalArgumentException("No bean specified");
       else
           return getPropertyDescriptors(bean.getClass());
   }
268175
public Object get(Object property) {
        if (property instanceof String)
            return getProperty((String)property);
        return null;
    }
38716
public static Object get(final Object bean, final String property) {

        try {
            if (property.indexOf(".") >= 0) {

                final Object subBean = ClassMockUtils.get(bean, property.substring(0, property.indexOf(".")));

                if (subBean == null) {

                    return null;
                }

                final String newProperty = property.substring(property.indexOf(".") + 1);

                return ClassMockUtils.get(subBean, newProperty);
            }

            Method method = null;

            try {
                method = bean.getClass().getMethod(ClassMockUtils.propertyToGetter(property), new Class[] {});
            } catch (final NoSuchMethodException e) {
                method = bean.getClass().getMethod(ClassMockUtils.propertyToGetter(property, true), new Class[] {});
            }

            return method.invoke(bean, new Object[] {});

        } catch (final Exception e) {

            throw new RuntimeException("Can't get property " + property + " in the class " + bean.getClass().getName(), e);
        }
    }
1313243
public static synchronized String getProperty(String base, String property,
			boolean required) {
		return getProperty(
				base + PropertyConstants.PROPERTY_DIVIDER + property, required);
	}
768226
public Object getProperty(Object object, String property) {
        return getProperty(theClass, object, property, false, false);
    }
102049
public static final boolean hasProperty(Object bean, String property)
    {
        try
        {
            return (boolean) doFor(
                bean, 
                property, 
                null,
                (Object a, int i)->{return true;},
                (List l, int i)->{return true;},
                (Object b, Class c, String p)->{getField(c, p);return true;}, 
                (Object b, Method m)->{return true;});
        }
        catch (BeanHelperException ex)
        {
            return false;
        }
    }
80688
public Multimap<String, String> getValuesByLanguage(String property) {
        Multimap<String, String> result = HashMultimap.create();
        if (properties.containsKey(property)) {
            Multimap<Optional<String>, String> values = properties.get(property);
            for (Entry<Optional<String>, String> entry : values.entries())
                if (entry.getKey().isPresent())
                    result.put(entry.getKey().get(), entry.getValue());
        }
        return result;
    }
1067538
public static Object handleGetProperty(Object o, String prop) throws JspCoreException {
        if (o == null) {
            throw new JspCoreException("jsp.error.beans.nullbean");
        }
        Object value = null;
        try {
            Method method = getReadMethod(o.getClass(), prop);
            value = method.invoke(o, null);
        }
        catch (Exception ex) {
            throw new JspCoreException(ex);
        }
        return value;
    }
459212
public final Class<?> getPropertyType(String property) {
    MethodInfo info = propertyWriteMethods.get(property);
    if (null == info) return null;
    else return info.parameterTypes[0];
  }
752900
public static final void setValue(Object bean, String property, Object v)
    {
        Object vv = BeanHelper.getValue(bean, property);
        if (v != null && v.getClass().isArray() &&  vv != null && (vv instanceof Collection))
        {   // array assignment to Collection
            Collection col = (Collection) vv;
            Class[] pt = BeanHelper.getParameterTypes(bean, property);
            col.clear();
            int len = Array.getLength(v);
            for (int ii=0;ii<len;ii++)
            {
                col.add(ConvertUtility.convert(pt[0], Array.get(v, ii)));
            }
        }
        else
        {
            if (v != null && v.getClass().isArray())
            {   // array with single menber
                if (Array.getLength(v) == 1)
                {
                    v = Array.get(v, 0);
                }
            }
            Class<?> type = BeanHelper.getType(bean, property);
            if (v != null)
            {
                v = ConvertUtility.convert(type, v);
            }
            Object value = v;
            doFor(
                bean, 
                property, 
                type,
                (Object a, int i)->{Array.set(a, i, value);return null;},
                (List l, int i)->{l.set(i, value);return null;},
                (Object b, Class c, String p)->{try
                {
                    c.getField(p).set(b, value);return null;
                }
                catch (IllegalArgumentException | IllegalAccessException ex)
                {
                    throw new IllegalArgumentException(ex);
                }
                }, 
                (Object b, Method m)->{try
                {
                    m.invoke(b, value);return null;
                }
                catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException ex)
                {
                    throw new IllegalArgumentException(ex);
                }
                });
        }
    }
880751
public <T> void setBeanProperty(final T bean, final Object property, final Object value) {
        if (bean != null) {
            @SuppressWarnings("unchecked")
            SetResolver<T> resolver = this.setters.unsafeGet(bean.getClass());
            if (resolver != null) {
                resolver.set(bean, property, value);
                return;
            }
        }
        this.resolverManager.set(bean, property, value);
    }
803985
public static Collection beanMap(String property, Object[] objs) {
        return beanMap(property, java.util.Arrays.asList(objs), false);
    }
518233
public static <Q> Object getPropertyValue(Q bean, String propertyName) {

        return ObjectUtils.getPropertyValue(bean, propertyName, Object.class);
    }