Example usage for org.apache.commons.beanutils ConvertUtils convert

List of usage examples for org.apache.commons.beanutils ConvertUtils convert

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.beanutils.*
  5. ConvertUtils
  6. convert

Introduction

In this page you can find the example usage for org.apache.commons.beanutils ConvertUtils convert.

Prototype

public static Object convert(String values[], Class clazz)

Source Link

Document

Convert an array of specified values to an array of objects of the specified class (if possible).

For more details see ConvertUtilsBean.

Usage

From source file:wwutil.model.BuiltinFunc.java

private static void setupBuiltinValidationHandlers(AnnotationRegistry registry) {

    registry.register(Required.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
        }/*w  w w. jav a 2  s  .c om*/

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            if (field.get(object) == null)
                throw new ValidationException("@Required field cannot be null.  Field: " + field.getName());
        }
    });

    registry.register(MaxSize.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != Integer.class && field.getType() != int.class
                    && field.getType() != Long.class && field.getType() != long.class
                    && field.getType() != Short.class && field.getType() != short.class
                    && field.getType() != Float.class && field.getType() != float.class
                    && field.getType() != Double.class && field.getType() != double.class
                    && field.getType() != String.class)
                throw new ValidationException(
                        "The @MaxSize field must be number type or String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            Object annValueObj = ReflectUtil.getAnnoValue(fieldAnnotation, "value", (Object) null);
            double annValue = ((Double) ConvertUtils.convert(annValueObj, Double.class)).doubleValue();
            if (annValue != 0) {
                Object valueObj = field.get(object);
                double value;
                if (valueObj instanceof String)
                    value = ((String) valueObj).length();
                else
                    value = ((Double) ConvertUtils.convert(valueObj, Double.class)).doubleValue();
                if (value > annValue)
                    throw new ValidationException("Field value " + valueObj + " exceeds MaxSize " + annValueObj
                            + ".  Field: " + field.getName());
            }
        }
    });

    registry.register(MinSize.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != Integer.class && field.getType() != int.class
                    && field.getType() != Long.class && field.getType() != long.class
                    && field.getType() != Short.class && field.getType() != short.class
                    && field.getType() != Float.class && field.getType() != float.class
                    && field.getType() != Double.class && field.getType() != double.class
                    && field.getType() != String.class)
                throw new ValidationException(
                        "The @MinSize field must be number type or String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            Object annValueObj = ReflectUtil.getAnnoValue(fieldAnnotation, "value", (Object) null);
            double annValue = ((Double) ConvertUtils.convert(annValueObj, Double.class)).doubleValue();
            if (annValue != 0) {
                Object valueObj = field.get(object);
                double value;
                if (valueObj instanceof String)
                    value = ((String) valueObj).length();
                else
                    value = ((Double) ConvertUtils.convert(valueObj, Double.class)).doubleValue();
                if (value < annValue)
                    throw new ValidationException("Field value " + valueObj + " is less than MinSize "
                            + annValueObj + ".  Field: " + field.getName());
            }
        }
    });

    registry.register(StartsWith.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @StartsWith field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            String annValue = ReflectUtil.getAnnoValue(fieldAnnotation, "value", "");
            String value = (String) field.get(object);
            if (value != null && !value.startsWith(annValue))
                throw new ValidationException("Field value " + value + " does not start with " + annValue
                        + ".  Field: " + field.getName());
        }
    });

    registry.register(EndsWith.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @EndsWith field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            String annValue = ReflectUtil.getAnnoValue(fieldAnnotation, "value", "");
            String value = (String) field.get(object);
            if (value != null && !value.endsWith(annValue))
                throw new ValidationException("Field value " + value + " does not end with " + annValue
                        + ".  Field: " + field.getName());
        }
    });

    registry.register(Contains.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @Contains field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            String annValue = ReflectUtil.getAnnoValue(fieldAnnotation, "value", "");
            String value = (String) field.get(object);
            if (value != null && !value.contains(annValue))
                throw new ValidationException("Field value " + value + " does not contain " + annValue
                        + ".  Field: " + field.getName());
        }
    });

    registry.register(NotContains.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @NotContains field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            String annValue = ReflectUtil.getAnnoValue(fieldAnnotation, "value", "");
            String value = (String) field.get(object);
            if (value != null && value.contains(annValue))
                throw new ValidationException(
                        "Field value " + value + " contains " + annValue + ".  Field: " + field.getName());
        }
    });

    registry.register(RegexMatch.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @RegexMatch field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            String annValue = ReflectUtil.getAnnoValue(fieldAnnotation, "value", "");
            String value = (String) field.get(object);
            if (value != null && !Pattern.matches(annValue, value))
                throw new ValidationException("Field value " + value + " does not match the regex " + annValue
                        + ".  Field: " + field.getName());
        }
    });

    registry.register(EmailMatch.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @EmailMatch field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            String value = (String) field.get(object);
            if (value != null) {
                if (!sEmailPattern.matcher(value.toUpperCase()).matches())
                    throw new ValidationException(
                            "Field value " + value + " is not an email.  Field: " + field.getName());
            }
        }
    });

    registry.register(MaskMatch.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @MaskMatch field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            char digitMask = ReflectUtil.getAnnoValue(fieldAnnotation, "digitMask", '#');
            char letterMask = ReflectUtil.getAnnoValue(fieldAnnotation, "letterMask", '@');
            char anyMask = ReflectUtil.getAnnoValue(fieldAnnotation, "anyMask", '*');
            String pattern = ReflectUtil.getAnnoValue(fieldAnnotation, "pattern", "");
            String value = (String) field.get(object);
            if (value != null) {
                MaskMatcher matcher = new MaskMatcher(pattern, digitMask, letterMask, anyMask);
                if (!matcher.matches(value))
                    throw new ValidationException("Field value " + value + " does not match the mask pattern "
                            + pattern + ".  Field: " + field.getName());
            }
        }
    });

    registry.register(OneOf.class, new AnnotationFieldHandler() {
        public void checkModel(Annotation fieldAnnotation, Field field, Map<String, Field> allFieldMap)
                throws ValidationException {
            if (field.getType() != String.class)
                throw new ValidationException(
                        "The @OneOf field must be String type.  Field: " + field.getName());
        }

        public void handle(Annotation fieldAnnotation, Object object, Field field,
                Map<String, Field> allFieldMap) throws Exception {
            String[] annValue = (String[]) ReflectUtil.getAnnoValue(fieldAnnotation, "choices", new String[0]);
            String value = (String) field.get(object);
            if (value != null) {
                for (String choice : annValue) {
                    if (value.equals(choice))
                        return;
                }
                throw new ValidationException(
                        "Field value " + value + " is not one of the choices.  Field: " + field.getName());
            }
        }
    });

}

From source file:wwutil.sys.ReflectUtil.java

/** Convert str value to Object */
public static Object strToObj(String valueStr, Class valueType) {
    return ConvertUtils.convert(valueStr, valueType);
}

From source file:wwutil.sys.ReflectUtil.java

/** Initialize the fields of an object with the value object, converted from string.
 *  Use with MapUtil.toMap() for initializing an object.
 *//* w ww .  j  av a2  s .  c o m*/
public static <T> T initObjStrs(T obj, Map<String, String> fieldStrValues) throws Exception {
    if (obj != null && fieldStrValues != null) {
        for (Field field : getAllFields(obj.getClass())) {
            Object value = ConvertUtils.convert(fieldStrValues.get(field.getName()), field.getType());
            field.set(obj, value);
        }
    }
    return obj;
}