Java ReflectionUtils类代码示例

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
protected void discover() {
    for (final Field field : ReflectionUtils.getDeclaredAndInheritedFields(getClazz(), true)) {
        field.setAccessible(true);
        final int fieldMods = field.getModifiers();
        if (field.isAnnotationPresent(Transient.class)
            || field.isSynthetic() && (fieldMods & Modifier.TRANSIENT) == Modifier.TRANSIENT
            || getMapper().getOptions().isActLikeSerializer() && ((fieldMods & Modifier.TRANSIENT) == Modifier.TRANSIENT)
            || getMapper().getOptions().isIgnoreFinals() && ((fieldMods & Modifier.FINAL) == Modifier.FINAL)) {
            // ignore these
        } else {
            getPersistenceFields().add(mapField(field));
        }

    }
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
private void checkRecursivelyHasNoIdAnnotationPresent(final Set<Class<?>> classesToInspect,
                                                      final HashSet<Class<?>> alreadyInspectedClasses, final MappedClass mc,
                                                      final Set<ConstraintViolation> ve) {
    for (final Class<?> clazz : classesToInspect) {
        if (alreadyInspectedClasses.contains(clazz)) {
            continue;
        }
        if (hasTypeFieldAnnotation(clazz, Id.class)) {
            ve.add(new ConstraintViolation(Level.FATAL,
                                           mc,
                                           getClass(),
                                           "You cannot use @Id on any field of an Embedded/Property object"));
        }
        alreadyInspectedClasses.add(clazz);
        final Set<Class<?>> extraClassesToInspect = new HashSet<Class<?>>();
        for (final Field field : ReflectionUtils.getDeclaredAndInheritedFields(clazz, true)) {
            if (isFieldToInspect(field)) {
                extraClassesToInspect.add(field.getType());
            }
        }
        checkRecursivelyHasNoIdAnnotationPresent(extraClassesToInspect, alreadyInspectedClasses, mc, ve);
    }
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
protected void check(final Mapper mapper, final MappedClass mc, final MappedField mf, final Set<ConstraintViolation> ve) {
    if (mf.isMap()) {
        if (mf.hasAnnotation(Serialized.class)) {
            final Class<?> keyClass = ReflectionUtils.getParameterizedClass(mf.getField(), 0);
            final Class<?> valueClass = ReflectionUtils.getParameterizedClass(mf.getField(), 1);
            if (keyClass != null) {
                if (!Serializable.class.isAssignableFrom(keyClass)) {
                    ve.add(new ConstraintViolation(Level.FATAL, mc, mf, getClass(),
                                                   "Key class (" + keyClass.getName() + ") is not Serializable"));
                }
            }
            if (valueClass != null) {
                if (!Serializable.class.isAssignableFrom(valueClass)) {
                    ve.add(new ConstraintViolation(Level.FATAL, mc, mf, getClass(),
                                                   "Value class (" + valueClass.getName() + ") is not Serializable"));
                }
            }
        }
    }
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
protected void check(final Mapper mapper, final MappedClass mc, final MappedField mf, final Set<ConstraintViolation> ve) {
    if (mf.isMap() && (!mf.hasAnnotation(Serialized.class))) {
        final Class<?> aClass = ReflectionUtils.getParameterizedClass(mf.getField(), 0);
        // WARN if not parameterized : null or Object...
        if (aClass == null || Object.class.equals(aClass)) {
            ve.add(new ConstraintViolation(Level.WARNING, mc, mf, getClass(),
                                           "Maps cannot be keyed by Object (Map<Object,?>); Use a parametrized type that is supported "
                                           + SUPPORTED));
        } else if (!aClass.equals(String.class) && !aClass.equals(ObjectId.class) && !ReflectionUtils.isPrimitiveLike(
                                                                                                                         aClass)) {
            ve.add(new ConstraintViolation(Level.FATAL, mc, mf, getClass(),
                                           "Maps must be keyed by a simple type " + SUPPORTED + "; " + aClass
                                           + " is not supported as a map key type."));
        }
    }
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
/**
 * Checks to see if it a Map/Set/List or a property supported by the MongoDB java driver
 *
 * @param clazz the type to check
 * @return true if the type is supported
 */
public static boolean isSupportedType(final Class<?> clazz) {
    if (ReflectionUtils.isPropertyType(clazz)) {
        return true;
    }
    if (clazz.isArray() || Map.class.isAssignableFrom(clazz) || Iterable.class.isAssignableFrom(clazz)) {
        Class<?> subType;
        if (clazz.isArray()) {
            subType = clazz.getComponentType();
        } else {
            subType = ReflectionUtils.getParameterizedClass(clazz);
        }

        //get component type, String.class from List<String>
        if (subType != null && subType != Object.class && !ReflectionUtils.isPropertyType(subType)) {
            return false;
        }

        //either no componentType or it is an allowed type
        return true;
    }
    return false;
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
protected void validate(final MappedField mappedField, final Object value, final List<ValidationFailure> validationFailures) {
    if (value == null) {
        validationFailures.add(new ValidationFailure("For a $mod operation, value cannot be null."));
    } else if (value.getClass().isArray()) {
        if (Array.getLength(value) != 2) {
            validationFailures.add(new ValidationFailure(format("For a $mod operation, value '%s' should be an array with two integer"
                                                                + " elements.  Instead it had %s", value, Array.getLength(value))));

        }
        if (!(ReflectionUtils.isIntegerType(value.getClass().getComponentType()))) {
            validationFailures.add(new ValidationFailure(format("Array value needs to contain integers for $mod, but contained: %s",
                                                                value.getClass().getComponentType())));
        }
    } else {
        validationFailures.add(new ValidationFailure(format("For a $mod operation, value '%s' should be an integer array.  "
                                                            + "Instead it was a: %s",
                                                            value, value.getClass()
                                                           )));
    }
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
public Object decode(final Class targetClass, final Object val, final MappedField optionalExtraInfo) {
    if (val == null) {
        return null;
    }

    if (val instanceof Integer) {
        return val;
    }

    if (val instanceof Number) {
        return ((Number) val).intValue();
    }

    if (val instanceof List) {
        final Class<?> type = targetClass.isArray() ? targetClass.getComponentType() : targetClass;
        return ReflectionUtils.convertToArray(type, (List<?>) val);
    }

    return Integer.parseInt(val.toString());
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
public Object decode(final Class targetClass, final Object val, final MappedField optionalExtraInfo) {
    if (val == null) {
        return null;
    }

    if (val instanceof Double) {
        return val;
    }

    if (val instanceof Number) {
        return ((Number) val).doubleValue();
    }

    if (val instanceof List) {
        final Class<?> type = targetClass.isArray() ? targetClass.getComponentType() : targetClass;
        return ReflectionUtils.convertToArray(type, (List<?>) val);
    }

    return Double.parseDouble(val.toString());
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
public Object decode(final Class targetClass, final Object fromDBObject, final MappedField optionalExtraInfo) {
    if (fromDBObject == null) {
        return null;
    }

    if (targetClass.equals(fromDBObject.getClass())) {
        return fromDBObject;
    }

    if (fromDBObject instanceof List) {
        final Class<?> type = targetClass.isArray() ? targetClass.getComponentType() : targetClass;
        return ReflectionUtils.convertToArray(type, (List<?>) fromDBObject);
    }

    if (targetClass.equals(String[].class)) {
        return new String[]{fromDBObject.toString()};
    }

    return fromDBObject.toString();
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
public Object decode(final Class targetClass, final Object val, final MappedField optionalExtraInfo) {
    if (val == null) {
        return null;
    }

    if (val instanceof Boolean) {
        return val;
    }

    //handle the case for things like the ok field
    if (val instanceof Number) {
        return ((Number) val).intValue() != 0;
    }

    if (val instanceof List) {
        final Class<?> type = targetClass.isArray() ? targetClass.getComponentType() : targetClass;
        return ReflectionUtils.convertToArray(type, (List<?>) val);
    }

    return Boolean.parseBoolean(val.toString());
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
@Override
public Object decode(final Class targetClass, final Object val, final MappedField optionalExtraInfo) {
    if (val == null) {
        return null;
    }

    if (val instanceof Long) {
        return val;
    }

    if (val instanceof Number) {
        return ((Number) val).longValue();
    }

    if (val instanceof List) {
        final Class<?> type = targetClass.isArray() ? targetClass.getComponentType() : targetClass;
        return ReflectionUtils.convertToArray(type, (List<?>) val);
    }

    return Long.parseLong(val.toString());
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
EntryMappedField(final Field field, final Class<?> clazz, final MappedField mappedField) {
    super(field, clazz);
    super.discover();
    if (MapKeyValueMapper.KEY.equals(field.getName())) {
        this.realType = mappedField.getMapKeyClass();
        this.subType = this.realType.getComponentType();
    } else if (MapKeyValueMapper.VALUE.equals(field.getName())) {
        this.realType = mappedField.getSubClass();
        this.subType = mappedField.getSubType() instanceof ParameterizedType ? ((ParameterizedType) mappedField.getSubType()).getActualTypeArguments()[0] : null;
    } else {
        throw new RuntimeException("Entry field is neither key nor entry");
    }

    if (this.realType.isArray()
        || Collection.class.isAssignableFrom(this.realType)
        || Map.class.isAssignableFrom(this.realType)) {

        this.isSingleValue = false;

        this.isMap = Map.class.isAssignableFrom(this.realType);
        this.isSet = Set.class.isAssignableFrom(this.realType);
        //for debugging
        this.isCollection = Collection.class.isAssignableFrom(this.realType);
        this.isArray = this.realType.isArray();

        if (this.isMap) {
            this.mapKeyType = ReflectionUtils.getParameterizedType(field, 0);
        }
    }
    try {
        this.constructor = this.realType.getDeclaredConstructor();
        this.constructor.setAccessible(true);
    } catch (final NoSuchMethodException e) {
        this.constructor = null;
    }
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
MapOrCollectionMF(final ParameterizedType t) {
    this();
    this.pType = t;
    final Class rawClass = (Class) t.getRawType();
    this.isSet = ReflectionUtils.implementsInterface(rawClass, Set.class);
    this.isMap = ReflectionUtils.implementsInterface(rawClass, Map.class);
    this.mapKeyType = getMapKeyClass();
    this.subType = getSubType();
    this.isMongoType = ReflectionUtils.isPropertyType(getSubClass());
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
/**
 * Discovers interesting (that we care about) things about the field.
 */
protected void discover(final Mapper mapper) {
    for (final Class<? extends Annotation> clazz : INTERESTING) {
        addAnnotation(clazz);
    }

    //type must be discovered before the constructor.
    discoverType(mapper);
    constructor = discoverConstructor();
    discoverMultivalued();

    // check the main type
    isMongoType = ReflectionUtils.isPropertyType(realType);

    // if the main type isn't supported by the Mongo, see if the subtype is.
    // works for T[], List<T>, Map<?, T>, where T is Long/String/etc.
    if (!isMongoType && subType != null) {
        isMongoType = ReflectionUtils.isPropertyType(subType);
    }

    if (!isMongoType && !isSingleValue && (subType == null || subType == Object.class)) {
        if (LOG.isWarningEnabled() && !mapper.getConverters().hasDbObjectConverter(this)) {
            LOG.warning(format("The multi-valued field '%s' is a possible heterogeneous collection. It cannot be verified. "
                               + "Please declare a valid type to get rid of this warning. %s", getFullName(), subType));
        }
        isMongoType = true;
    }
}
 

import org.mongodb.morphia.utils.ReflectionUtils; //导入依赖的package包/类
protected Class toClass(final Type t) {
    if (t == null) {
        return null;
    } else if (t instanceof Class) {
        return (Class) t;
    } else if (t instanceof GenericArrayType) {
        final Type type = ((GenericArrayType) t).getGenericComponentType();
        Class aClass;
        if (type instanceof ParameterizedType) {
            aClass = (Class) ((ParameterizedType) type).getRawType();
        } else if (type instanceof TypeVariable) {
            aClass = ReflectionUtils.getTypeArgument(persistedClass, (TypeVariable<?>) type);
            if (aClass == null) {
                aClass = Object.class;
            }
        } else {
            aClass = (Class) type;
        }
        return Array.newInstance(aClass, 0).getClass();
    } else if (t instanceof ParameterizedType) {
        return (Class) ((ParameterizedType) t).getRawType();
    } else if (t instanceof WildcardType) {
        return (Class) ((WildcardType) t).getUpperBounds()[0];
    }

    throw new RuntimeException("Generic TypeVariable not supported!");

}