Example usage for org.springframework.beans BeanUtils getPropertyDescriptor

List of usage examples for org.springframework.beans BeanUtils getPropertyDescriptor

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.*
  5. BeanUtils
  6. getPropertyDescriptor

Introduction

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

Prototype

@Nullable
public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String propertyName)
        throws BeansException

Source Link

Document

Retrieve the JavaBeans PropertyDescriptors for the given property.

Usage

From source file:de.escalon.hypermedia.spring.SpringActionDescriptor.java

/**
 * Recursively navigate to return a BeanWrapper for the nested property path.
 *
 * @param propertyPath/* w  w  w  .  j a v  a 2s . c om*/
 *         property property path, which may be nested
 * @return a BeanWrapper for the target bean
 */
PropertyDescriptor getPropertyDescriptorForPropertyPath(String propertyPath, Class<?> propertyType) {
    int pos = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(propertyPath);
    // Handle nested properties recursively.
    if (pos > -1) {
        String nestedProperty = propertyPath.substring(0, pos);
        String nestedPath = propertyPath.substring(pos + 1);
        PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(propertyType, nestedProperty);
        //            BeanWrapperImpl nestedBw = getNestedBeanWrapper(nestedProperty);
        return getPropertyDescriptorForPropertyPath(nestedPath, propertyDescriptor.getPropertyType());
    } else {
        return BeanUtils.getPropertyDescriptor(propertyType, propertyPath);
    }
}

From source file:com.github.hateoas.forms.spring.SpringActionDescriptor.java

/**
 * Recursively navigate to return a BeanWrapper for the nested property path.
 *
 * @param propertyPath property property path, which may be nested
 * @return a BeanWrapper for the target bean
 *///from   w  w  w  .  jav a 2s  .  co  m
PropertyDescriptor getPropertyDescriptorForPropertyPath(final String propertyPath,
        final Class<?> propertyType) {
    int pos = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(propertyPath);
    // Handle nested properties recursively.
    if (pos > -1) {
        String nestedProperty = propertyPath.substring(0, pos);
        String nestedPath = propertyPath.substring(pos + 1);
        PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(propertyType, nestedProperty);
        // BeanWrapperImpl nestedBw = getNestedBeanWrapper(nestedProperty);
        return getPropertyDescriptorForPropertyPath(nestedPath, propertyDescriptor.getPropertyType());
    } else {
        return BeanUtils.getPropertyDescriptor(propertyType, propertyPath);
    }
}

From source file:org.springmodules.validation.bean.conf.loader.annotation.AnnotationBeanValidationConfigurationLoader.java

/**
 * Handles all the property level annotations of the given class and manipulates the given validation configuration
 * accordingly. The property level annotations can either be placed on the <code>setter</code> methods of the
 * properties or on the appropriate class fields.
 *
 * @param clazz The annotated class./*w  w  w . j a  v  a  2 s .  co  m*/
 * @param configuration The bean validation configuration to mainpulate.
 */
protected void handlePropertyAnnotations(Class clazz, MutableBeanValidationConfiguration configuration) {
    // extracting & handling all property annotation placed on property fields
    List<Field> fields = extractFieldFromClassHierarchy(clazz);
    for (Field field : fields) {
        String fieldName = field.getName();
        PropertyDescriptor descriptor = BeanUtils.getPropertyDescriptor(clazz, fieldName);
        if (descriptor != null) {
            Annotation[] annotations = field.getAnnotations();
            handleProprtyAnnotations(annotations, clazz, descriptor, configuration);
        }
    }

    // extracting & handling all property annotations placed on property setters
    PropertyDescriptor[] descriptors = BeanUtils.getPropertyDescriptors(clazz);
    for (PropertyDescriptor descriptor : descriptors) {
        Method writeMethod = descriptor.getWriteMethod();
        if (writeMethod == null) {
            continue;
        }
        Annotation[] annotations = writeMethod.getAnnotations();
        handleProprtyAnnotations(annotations, clazz, descriptor, configuration);
    }
}

From source file:com.expressui.core.view.field.DisplayField.java

private String getLabelTextFromAnnotation() {
    Class propertyContainerType = beanPropertyType.getContainerType();
    String propertyIdRelativeToContainerType = beanPropertyType.getId();
    PropertyDescriptor descriptor = BeanUtils.getPropertyDescriptor(propertyContainerType,
            propertyIdRelativeToContainerType);
    Method method = descriptor.getReadMethod();
    Label labelAnnotation = method.getAnnotation(Label.class);
    if (labelAnnotation == null) {
        return null;
    } else {//from www .j av a 2  s. c om
        return labelAnnotation.value();
    }
}

From source file:org.springmodules.validation.bean.conf.loader.annotation.handler.AbstractMethodValidationAnnotationHandler.java

/**
 * Validates that the given class has a property with the given propertyName. Throws {@link BeansException} if
 * the property was not found./*from   www.  j ava2  s  . c  o  m*/
 *
 * @param clazz The class to check
 * @param property The name of the property
 */
protected void validatedPropertyExists(Class clazz, String property) {
    BeanUtils.getPropertyDescriptor(clazz, property);
}

From source file:com.eclecticlogic.pedal.dialect.postgresql.CopyCommand.java

/**
 * Note: This method is now "ugly" and needs serious refactoring.
 * @param clz//from   ww w  .  j a v  a 2 s.com
 * @param fieldMethods
 * @return Create a class to generate the copy row strings.
 */
@SuppressWarnings({ "unchecked" })
private <E extends Serializable> CopyExtractor<E> getExtractor(Class<E> clz, List<Method> fieldMethods) {
    ClassPool pool = ClassPool.getDefault();
    pool.insertClassPath(new ClassClassPath(clz));
    CtClass cc = pool.makeClass("com.eclecticlogic.pedal.dialect.postgresql." + clz.getSimpleName()
            + "$CopyExtractor_" + extractorNameSuffix.incrementAndGet());

    StringBuilder methodBody = new StringBuilder();
    try {
        cc.addInterface(pool.getCtClass(CopyExtractor.class.getName()));

        methodBody.append("public String getValueList(Object entity) {\n");
        methodBody.append("try {\n");
        methodBody.append("StringBuilder builder = new StringBuilder();\n");
        methodBody.append(clz.getName() + " typed = (" + clz.getName() + ")entity;\n");
        for (int i = 0; i < fieldMethods.size(); i++) {
            Method method = fieldMethods.get(i);
            if (method.isAnnotationPresent(CopyConverter.class)) {
                try {
                    Class<?> helper = method.getAnnotation(CopyConverter.class).value();
                    methodBody.append(helper.getName() + " c" + i + " = (" + helper.getName() + ")"
                            + helper.getName() + ".class.newInstance();\n");
                    methodBody
                            .append("builder.append(c" + i + ".convert(typed." + method.getName() + "()));\n");
                } catch (Exception e) {
                    throw new RuntimeException(e.getMessage(), e);
                }
            } else if (method.getReturnType().isPrimitive()) {
                methodBody.append("builder.append(typed." + method.getName() + "());\n");
            } else {
                methodBody.append(
                        method.getReturnType().getName() + " v" + i + " = typed." + method.getName() + "();\n");
                if (method.isAnnotationPresent(EmbeddedId.class)) {
                    // Embedded id
                    if (method.isAnnotationPresent(AttributeOverrides.class)) {
                        AttributeOverrides overrides = method.getAnnotation(AttributeOverrides.class);
                        for (int j = 0; j < overrides.value().length; j++) {
                            AttributeOverride override = overrides.value()[j];
                            methodBody.append("if (v" + i + " == null) {builder.append(\"\\\\N\");}\n");
                            methodBody.append("else {\n");
                            Method idMethod = BeanUtils
                                    .getPropertyDescriptor(method.getReturnType(), override.name())
                                    .getReadMethod();
                            methodBody.append("builder.append(v" + i + "." + idMethod.getName() + "());\n");
                            methodBody.append("}\n");
                            if (j != overrides.value().length - 1) {
                                methodBody.append("builder.append(\"\\t\");\n");
                            }
                        }
                    }
                } else if (method.getReturnType().isAnnotationPresent(Embeddable.class)) {
                    // Embeddable. If attribute overrides is present, we get the columns in the order of the 
                    // override annotations. Otherwise use method names.
                    if (method.isAnnotationPresent(AttributeOverrides.class)) {
                        AttributeOverrides overrides = method.getAnnotation(AttributeOverrides.class);
                        for (int j = 0; j < overrides.value().length; j++) {
                            AttributeOverride override = overrides.value()[j];
                            Method embedded = BeanUtils
                                    .getPropertyDescriptor(method.getReturnType(), override.name())
                                    .getReadMethod();
                            if (embedded.getReturnType().isPrimitive()) {
                                methodBody.append("builder.append(v" + i + "." + embedded.getName() + "());");
                            } else {
                                methodBody.append("if (v" + i + "." + embedded.getName()
                                        + "() == null) {builder.append(\"\\\\N\");}");
                                methodBody.append(
                                        "else {builder.append(v" + i + "." + embedded.getName() + "());}");
                            }
                            if (j != overrides.value().length - 1) {
                                methodBody.append("builder.append(\"\\t\");\n");
                            }
                        } // end loop over override values.
                    } else {
                        // Get columns as discovered by method traversal. Its assumed that @Column annotation exists
                        // on getter methods of interest.
                        List<Method> embeddedColumnMethods = new ArrayList<>();
                        for (Method embedded : method.getReturnType().getMethods()) {
                            if (embedded.isAnnotationPresent(Column.class)) {
                                embeddedColumnMethods.add(embedded);
                            }
                        }

                        for (int j = 0; j < embeddedColumnMethods.size(); j++) {
                            Method embedded = embeddedColumnMethods.get(j);
                            if (embedded.getReturnType().isPrimitive()) {
                                methodBody.append("builder.append(v" + i + "." + embedded.getName() + "());");
                            } else {
                                methodBody.append("if (v" + i + "." + embedded.getName()
                                        + "() == null) {builder.append(\"\\\\N\");}");
                                methodBody.append(
                                        "else {builder.append(v" + i + "." + embedded.getName() + "());}");
                            }
                            if (j != embeddedColumnMethods.size() - 1) {
                                methodBody.append("builder.append(\"\\t\");\n");
                            }
                        } // end loop over override values.

                    }
                } else {
                    methodBody.append("if (v" + i + " == null) {builder.append(\"\\\\N\");}\n");
                    methodBody.append("else {\n");

                    if (method.isAnnotationPresent(CopyAsBitString.class)) {
                        // Get number of bits from @Column annotation.
                        int bitCount = method.getAnnotation(Column.class).length();
                        methodBody.append("java.util.BitSet bs" + i + " = typed." + method.getName() + "();\n");
                        methodBody.append("for (int i = 0; i < " + bitCount + "; i++) {\n");
                        methodBody.append("builder.append(bs" + i + ".get(i) ? \"0\" : \"1\");\n");
                        methodBody.append("}\n");
                    } else if (Collection.class.isAssignableFrom(method.getReturnType())
                            && method.isAnnotationPresent(Convert.class) == false) {
                        // Postgreql array type.
                        if (method.isAnnotationPresent(CopyEmptyAsNull.class)) {
                            methodBody.append("if (typed." + method.getName() + "().isEmpty()) {\n");
                            methodBody.append("builder.append(\"\\\\N\");\n");
                            methodBody.append("} else {\n");
                            collectionExtractor(methodBody, i, method);
                            methodBody.append("}\n");
                        } else {
                            collectionExtractor(methodBody, i, method);
                        }
                    } else if (method.isAnnotationPresent(Convert.class)) {
                        Class<?> converterClass = method.getAnnotation(Convert.class).converter();
                        methodBody
                                .append(converterClass.getName() + " c" + i + " = (" + converterClass.getName()
                                        + ")" + converterClass.getName() + ".class.newInstance();\n");
                        methodBody.append("builder.append(c" + i + ".convertToDatabaseColumn(v" + i + "));\n");
                    } else if (method.isAnnotationPresent(JoinColumn.class)) {
                        // We need to get the id of the joined object.
                        for (Method method2 : method.getReturnType().getMethods()) {
                            if (method2.isAnnotationPresent(Id.class)) {
                                methodBody.append("builder.append(v" + i + "." + method2.getName() + "());\n");
                            }
                        }
                    } else {
                        methodBody.append("builder.append(v" + i + ");\n");
                    }
                    methodBody.append("}\n");
                }
            }
            if (i != fieldMethods.size() - 1) {
                methodBody.append("builder.append(\"\\t\");\n");
            }
        }
        methodBody.append("return builder.toString();\n");
        methodBody.append("} catch (Exception e) { throw new RuntimeException(e); } \n");
        methodBody.append("}\n");
        logger.trace(methodBody.toString());
        cc.addMethod(CtNewMethod.make(methodBody.toString(), cc));
    } catch (NotFoundException | CannotCompileException e) {
        logger.error(e.getMessage(), "Compiled body is:\n" + methodBody.toString());
        throw new RuntimeException(e.getMessage(), e);
    }

    try {
        return (CopyExtractor<E>) cc.toClass().newInstance();
    } catch (InstantiationException | IllegalAccessException | CannotCompileException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}

From source file:org.carewebframework.shell.designer.PropertyEditorCustomTree.java

/**
 * Returns true if the class has a writable label property.
 * //from w ww.  ja  v  a 2s.c o m
 * @param clazz The class to check.
 * @return True if a writable label property exists.
 */
private boolean hasLabelProperty(Class<?> clazz) {
    try {
        PropertyDescriptor pd = labelProperty == null ? null
                : BeanUtils.getPropertyDescriptor(clazz, labelProperty);
        return pd != null && pd.getWriteMethod() != null;
    } catch (Exception e) {
        return false;
    }
}

From source file:com.expressui.core.util.BeanPropertyType.java

/**
 * Asks if this property is validatable recursively because it has a @Valid annotation.
 *
 * @return true if this property is validatable recursively because it has a @Valid annotation
 *///from  ww w  .  j a v  a 2  s  .co  m
public boolean isValidatable() {
    BeanPropertyType beanPropertyType = parent;
    while (beanPropertyType != null) {
        Class containingType = beanPropertyType.getContainerType();
        String id = beanPropertyType.getId();

        PropertyDescriptor descriptor = BeanUtils.getPropertyDescriptor(containingType, id);
        Method readMethod = descriptor.getReadMethod();
        Valid validAnnotation = null;
        if (readMethod != null) {
            validAnnotation = readMethod.getAnnotation(Valid.class);
        }
        if (validAnnotation == null) {
            Field field = ReflectionUtil.getField(containingType, id);
            Assert.PROGRAMMING.notNull(field, "Cannot find field: " + containingType.getName() + "." + id);

            validAnnotation = field.getAnnotation(Valid.class);
        }

        if (validAnnotation == null) {
            return false;
        } else {
            beanPropertyType = beanPropertyType.getParent();
        }
    }

    return true;
}

From source file:com.bstek.dorado.view.output.ClientOutputHelper.java

protected Map<String, PropertyConfig> doGetPropertyConfigs(Class<?> beanType) throws Exception {
    beanType = ProxyBeanUtils.getProxyTargetType(beanType);
    Map<String, PropertyConfig> propertyConfigs = new HashMap<String, PropertyConfig>();

    ClientObjectInfo clientObjectInfo = getClientObjectInfo(beanType);
    if (clientObjectInfo != null) {
        for (Map.Entry<String, ClientProperty> entry : clientObjectInfo.getPropertyConfigs().entrySet()) {
            String property = entry.getKey();
            ClientProperty clientProperty = entry.getValue();

            PropertyConfig propertyConfig = new PropertyConfig();
            if (clientProperty.ignored()) {
                propertyConfig.setIgnored(true);
            } else {
                if (StringUtils.isNotEmpty(clientProperty.outputter())) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(clientProperty.outputter(),
                            Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                }//from  w w  w . java 2s  .co m

                if (clientProperty.alwaysOutput()) {
                    propertyConfig.setEscapeValue(FAKE_ESCAPE_VALUE);
                } else if (StringUtils.isNotEmpty(clientProperty.escapeValue())) {
                    propertyConfig.setEscapeValue(clientProperty.escapeValue());
                }
            }
            propertyConfigs.put(property, propertyConfig);
        }
    }

    boolean isAssembledComponent = (AssembledComponent.class.isAssignableFrom(beanType));
    Class<?> superComponentType = null;
    if (isAssembledComponent) {
        superComponentType = beanType;
        while (superComponentType != null && AssembledComponent.class.isAssignableFrom(superComponentType)) {
            superComponentType = superComponentType.getSuperclass();
            Assert.notNull(superComponentType);
        }
    }

    for (PropertyDescriptor propertyDescriptor : PropertyUtils.getPropertyDescriptors(beanType)) {
        String property = propertyDescriptor.getName();
        Method readMethod = propertyDescriptor.getReadMethod();
        if (readMethod.getDeclaringClass() != beanType) {
            try {
                readMethod = beanType.getMethod(readMethod.getName(), readMethod.getParameterTypes());
            } catch (NoSuchMethodException e) {
                // do nothing
            }
        }

        TypeInfo typeInfo;
        Class<?> propertyType = propertyDescriptor.getPropertyType();
        if (Collection.class.isAssignableFrom(propertyType)) {
            typeInfo = TypeInfo.parse((ParameterizedType) readMethod.getGenericReturnType(), true);
            if (typeInfo != null) {
                propertyType = typeInfo.getType();
            }
        } else if (propertyType.isArray()) {
            typeInfo = new TypeInfo(propertyType.getComponentType(), true);
        } else {
            typeInfo = new TypeInfo(propertyType, false);
        }

        PropertyConfig propertyConfig = null;
        ClientProperty clientProperty = readMethod.getAnnotation(ClientProperty.class);
        if (clientProperty != null) {
            propertyConfig = new PropertyConfig();
            if (clientProperty.ignored()) {
                propertyConfig.setIgnored(true);
            } else {
                if (StringUtils.isNotEmpty(clientProperty.outputter())) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(clientProperty.outputter(),
                            Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (Component.class.isAssignableFrom(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(COMPONENT_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (DataControl.class.isAssignableFrom(propertyType)
                        || FloatControl.class.isAssignableFrom(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(COMPONENT_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (DataType.class.isAssignableFrom(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(DATA_TYPE_PROPERTY_OUTPUTTER,
                            Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (Object.class.equals(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(DATA_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (!EntityUtils.isSimpleType(propertyType) && !propertyType.isArray()) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(OBJECT_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                }

                if (!clientProperty.evaluateExpression()) {
                    propertyConfig.setEvaluateExpression(false);
                }

                if (clientProperty.alwaysOutput()) {
                    propertyConfig.setEscapeValue(FAKE_ESCAPE_VALUE);
                } else if (StringUtils.isNotEmpty(clientProperty.escapeValue())) {
                    propertyConfig.setEscapeValue(clientProperty.escapeValue());
                }
            }
        } else if (isAssembledComponent && readMethod.getDeclaringClass() == beanType
                && EntityUtils.isSimpleType(propertyType)) {
            if (BeanUtils.getPropertyDescriptor(superComponentType, property) == null) {
                propertyConfig = new PropertyConfig();
                propertyConfig.setIgnored(true);
            }
        }

        ComponentReference componentReference = readMethod.getAnnotation(ComponentReference.class);
        if (componentReference != null && String.class.equals(propertyType)) {
            if (propertyConfig == null) {
                propertyConfig = new PropertyConfig();
            }
            if (propertyConfig.getOutputter() == null) {
                BeanWrapper beanWrapper = BeanFactoryUtils.getBean(COMPONENT_REFERENCE_OUTPUTTER,
                        Scope.instant);
                propertyConfig.setOutputter(beanWrapper.getBean());
            }
        }

        if (!propertyType.isPrimitive() && (Number.class.isAssignableFrom(propertyType)
                || Boolean.class.isAssignableFrom(propertyType))) {
            if (propertyConfig == null) {
                propertyConfig = new PropertyConfig();
            }
            if (propertyConfig.getEscapeValue() == PropertyConfig.NONE_VALUE) {
                propertyConfig.setEscapeValue(null);
            }
        }

        if (propertyConfig != null) {
            propertyConfigs.put(property, propertyConfig);
        }
    }
    return (propertyConfigs.isEmpty()) ? null : propertyConfigs;
}