public static AnnotatedElement getAnnotatedElement(Class<?> beanClass, String propertyName, Class<?> propertyClass) { Field field = getFieldOrNull(beanClass, propertyName); Method method = getGetterOrNull(beanClass, propertyName, propertyClass); if (field == null || field.getAnnotations().length == 0) { return (method != null && method.getAnnotations().length > 0) ? method : EMPTY; } else if (method == null || method.getAnnotations().length == 0) { return field; } else { return new Annotations(field, method); } }
continue; AnnotatedElement annotated = ReflectionUtils.getAnnotatedElement(cl, field.getName(), field.getType()); Type propertyType = getPropertyType(cl, annotated, field.getType(), field.getGenericType()); Annotations ann = new Annotations(field);
@SuppressWarnings("rawtypes") private Type getGenericParameter(Class<?> cl, java.lang.reflect.Type genericType, int i) { java.lang.reflect.Type parameter = ReflectionUtils.getTypeParameter(genericType, i); if (parameter instanceof TypeVariable) { TypeVariable variable = (TypeVariable) parameter; Type rv = get(ReflectionUtils.getTypeParameterAsClass(genericType, i), null, parameter); return new TypeExtends(variable.getName(), rv); } else if (parameter instanceof WildcardType && ((WildcardType) parameter).getUpperBounds()[0].equals(Object.class) && ((WildcardType) parameter).getLowerBounds().length == 0) { return ANY; } else { Type rv = get(ReflectionUtils.getTypeParameterAsClass(genericType, i), null, parameter); if (parameter instanceof WildcardType) { rv = new TypeExtends(rv); } return rv; } }
public static Class<?> getTypeParameterAsClass(java.lang.reflect.Type type, int index) { Type parameter = getTypeParameter(type, index); if (parameter != null) { return asClass(parameter); } else { return null; } }
@Override public Class<?> validate(Class<?> parent, String property, Class<?> propertyType) { while (!parent.equals(Object.class)) { try { Field field = parent.getDeclaredField(property); if (Map.class.isAssignableFrom(field.getType())) { return (Class) ReflectionUtils.getTypeParameterAsClass(field.getGenericType(), 1); } else if (Collection.class.isAssignableFrom(field.getType())) { return (Class) ReflectionUtils.getTypeParameterAsClass(field.getGenericType(), 0); } else { return (Class) Primitives.wrap(field.getType()); } } catch (NoSuchFieldException e) { parent = parent.getSuperclass(); } } return null; } };
public static <T> T get(Object parent, String f) { try { Field field = ReflectionUtils.getFieldOrNull(parent.getClass(), f); if (field != null) { field.setAccessible(true); @SuppressWarnings("unchecked") T rv = (T) field.get(parent); return rv; } else { throw new IllegalArgumentException("No field " + f + " for " + parent.getClass()); } } catch (IllegalAccessException e) { throw new IllegalStateException(e); } }
@Nullable public static Method getGetterOrNull(Class<?> beanClass, String name) { Method method = getGetterOrNull(beanClass, name, Object.class); if (method != null) { return method; } else { return getGetterOrNull(beanClass, name, Boolean.class); } }
public static int getTypeParameterCount(java.lang.reflect.Type type) { if (type instanceof ParameterizedType) { return ((ParameterizedType) type).getActualTypeArguments().length; } else if (type instanceof TypeVariable) { return getTypeParameterCount(((TypeVariable) type).getBounds()[0]); } else { return 0; } }
@Nullable public static Type getTypeParameter(java.lang.reflect.Type type, int index) { if (type instanceof ParameterizedType) { return ((ParameterizedType) type).getActualTypeArguments()[index]; } else if (type instanceof TypeVariable) { return getTypeParameter(((TypeVariable) type).getBounds()[0], index); } else { return null; } }
@Test @SuppressWarnings("unchecked") public void getImplementedInterfaces() { Set<Class<?>> ifaces = ReflectionUtils.getImplementedInterfaces(SimpleExpression.class); assertEquals(new HashSet<Class<?>>(Arrays.asList(Serializable.class, Expression.class)), ifaces); }
@Override public Class<?> validate(Class<?> parent, String property, Class<?> propertyType) { Method getter = BeanUtils.getAccessor("get", property, parent); if (getter == null && Primitives.wrap(propertyType).equals(Boolean.class)) { getter = BeanUtils.getAccessor("is", property, parent); } if (getter != null) { if (Map.class.isAssignableFrom(getter.getReturnType())) { return (Class) ReflectionUtils.getTypeParameterAsClass(getter.getGenericReturnType(), 1); } else if (Collection.class.isAssignableFrom(getter.getReturnType())) { return (Class) ReflectionUtils.getTypeParameterAsClass(getter.getGenericReturnType(), 0); } else { return (Class) Primitives.wrap(getter.getReturnType()); } } else { return null; } } };
public static <T> T get(Object parent, String f) { try { Field field = ReflectionUtils.getFieldOrNull(parent.getClass(), f); if (field != null) { field.setAccessible(true); @SuppressWarnings("unchecked") T rv = (T) field.get(parent); return rv; } else { throw new IllegalArgumentException("No field " + f + " for " + parent.getClass()); } } catch (IllegalAccessException e) { throw new IllegalStateException(e); } }
@Nullable public static Method getGetterOrNull(Class<?> beanClass, String name) { Method method = getGetterOrNull(beanClass, name, Object.class); if (method != null) { return method; } else { return getGetterOrNull(beanClass, name, Boolean.class); } }
public static Class<?> getTypeParameterAsClass(java.lang.reflect.Type type, int index) { Type parameter = getTypeParameter(type, index); if (parameter != null) { return asClass(parameter); } else { return null; } }
private Type[] getParameters(Class<?> cl, java.lang.reflect.Type genericType) { int parameterCount = ReflectionUtils.getTypeParameterCount(genericType); if (parameterCount > 0) { return getGenericParameters(cl, genericType, parameterCount); } else if (Map.class.isAssignableFrom(cl)) { return new Type[]{Types.OBJECT, Types.OBJECT}; } else if (Collection.class.isAssignableFrom(cl)) { return new Type[]{Types.OBJECT}; } else { return new Type[0]; } }
@Nullable public static Type getTypeParameter(java.lang.reflect.Type type, int index) { if (type instanceof ParameterizedType) { return ((ParameterizedType) type).getActualTypeArguments()[index]; } else if (type instanceof TypeVariable) { return getTypeParameter(((TypeVariable) type).getBounds()[0], index); } else { return null; } }
@Nullable private Type<?> findType(Class<?> clazz) { //Look for a registered type in the class hierarchy Class<?> cl = clazz; do { if (typeByClass.containsKey(cl)) { return typeByClass.get(cl); } else if (defaultTypes.containsKey(cl)) { return defaultTypes.get(cl); } cl = cl.getSuperclass(); } while (!cl.equals(Object.class)); //Look for a registered type in any implemented interfaces Set<Class<?>> interfaces = ReflectionUtils.getImplementedInterfaces(clazz); for (Class<?> itf : interfaces) { if (typeByClass.containsKey(itf)) { return typeByClass.get(itf); } else if (defaultTypes.containsKey(itf)) { return defaultTypes.get(itf); } } return null; }
public static AnnotatedElement getAnnotatedElement(Class<?> beanClass, String propertyName, Class<?> propertyClass) { Field field = getFieldOrNull(beanClass, propertyName); Method method = getGetterOrNull(beanClass, propertyName, propertyClass); if (field == null || field.getAnnotations().length == 0) { return (method != null && method.getAnnotations().length > 0) ? method : EMPTY; } else if (method == null || method.getAnnotations().length == 0) { return field; } else { return new Annotations(field, method); } }
Class<Object> keyType = (Class) ReflectionUtils.getTypeParameter(genericType, 0); Class<Object> valueType = (Class) ReflectionUtils.getTypeParameter(genericType, 1); path = pathFactory.createMapPath(keyType, valueType, metadata); rv = aliasFactory.createAliasForProperty(type, path); Class<Object> elementType = (Class) ReflectionUtils.getTypeParameter(genericType, 0); path = pathFactory.createListPath(elementType, metadata); rv = aliasFactory.createAliasForProperty(type, path); Class<?> elementType = ReflectionUtils.getTypeParameterAsClass(genericType, 0); path = pathFactory.createSetPath(elementType, metadata); rv = aliasFactory.createAliasForProperty(type, path); Class<?> elementType = ReflectionUtils.getTypeParameterAsClass(genericType, 0); path = pathFactory.createCollectionPath(elementType, metadata); rv = aliasFactory.createAliasForProperty(type, path);
Class<?> embeddableType = type; if (Collection.class.isAssignableFrom(type)) { embeddableType = ReflectionUtils.getTypeParameterAsClass(genericType, 0); } else if (Map.class.isAssignableFrom(type)) { embeddableType = ReflectionUtils.getTypeParameterAsClass(genericType, 1);