private Class<?> getReturnType(Method method) { Class<?> returnType = method.getReturnType(); Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, type); if (resolvedReturnType instanceof Class) { returnType = (Class<?>) resolvedReturnType;
private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) { if (type instanceof TypeVariable) { return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass); } else if (type instanceof ParameterizedType) { return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass); } else if (type instanceof GenericArrayType) { return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass); } else { return type; } }
/** * @return The field type as {@link Type}. If it has type parameters in the declaration,<br> * they will be resolved to the actual runtime {@link Type}s. */ public static Type resolveFieldType(Field field, Type srcType) { Type fieldType = field.getGenericType(); Class<?> declaringClass = field.getDeclaringClass(); return resolveType(fieldType, srcType, declaringClass); }
private static Type[] resolveWildcardTypeBounds(Type[] bounds, Type srcType, Class<?> declaringClass) { Type[] result = new Type[bounds.length]; for (int i = 0; i < bounds.length; i++) { if (bounds[i] instanceof TypeVariable) { result[i] = resolveTypeVar((TypeVariable<?>) bounds[i], srcType, declaringClass); } else if (bounds[i] instanceof ParameterizedType) { result[i] = resolveParameterizedType((ParameterizedType) bounds[i], srcType, declaringClass); } else if (bounds[i] instanceof WildcardType) { result[i] = resolveWildcardType((WildcardType) bounds[i], srcType, declaringClass); } else { result[i] = bounds[i]; } } return result; }
private Type getGenericGetterType(String propertyName) { try { Invoker invoker = reflector.getGetInvoker(propertyName); if (invoker instanceof MethodInvoker) { Field _method = MethodInvoker.class.getDeclaredField("method"); _method.setAccessible(true); Method method = (Method) _method.get(invoker); return TypeParameterResolver.resolveReturnType(method, reflector.getType()); } else if (invoker instanceof GetFieldInvoker) { Field _field = GetFieldInvoker.class.getDeclaredField("field"); _field.setAccessible(true); Field field = (Field) _field.get(invoker); return TypeParameterResolver.resolveFieldType(field, reflector.getType()); } } catch (NoSuchFieldException e) { } catch (IllegalAccessException e) { } return null; }
private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz, Type superclass) { if (superclass instanceof ParameterizedType) { ParameterizedType parentAsType = (ParameterizedType) superclass; Class<?> parentAsClass = (Class<?>) parentAsType.getRawType(); TypeVariable<?>[] parentTypeVars = parentAsClass.getTypeParameters(); if (srcType instanceof ParameterizedType) { parentAsType = translateParentTypeVars((ParameterizedType) srcType, clazz, parentAsType); } if (declaringClass == parentAsClass) { for (int i = 0; i < parentTypeVars.length; i++) { if (typeVar == parentTypeVars[i]) { return parentAsType.getActualTypeArguments()[i]; } } } if (declaringClass.isAssignableFrom(parentAsClass)) { return resolveTypeVar(typeVar, parentAsType, declaringClass); } } else if (superclass instanceof Class && declaringClass.isAssignableFrom((Class<?>) superclass)) { return resolveTypeVar(typeVar, superclass, declaringClass); } return null; }
private void addGetField(Field field) { if (isValidPropertyName(field.getName())) { getMethods.put(field.getName(), new GetFieldInvoker(field)); Type fieldType = TypeParameterResolver.resolveFieldType(field, type); getTypes.put(field.getName(), typeToClass(fieldType)); } }
private void addSetMethod(String name, Method method) { if (isValidPropertyName(name)) { setMethods.put(name, new MethodInvoker(method)); Type[] paramTypes = TypeParameterResolver.resolveParamTypes(method, type); setTypes.put(name, typeToClass(paramTypes[0])); } }
private static Type resolveWildcardType(WildcardType wildcardType, Type srcType, Class<?> declaringClass) { Type[] lowerBounds = resolveWildcardTypeBounds(wildcardType.getLowerBounds(), srcType, declaringClass); Type[] upperBounds = resolveWildcardTypeBounds(wildcardType.getUpperBounds(), srcType, declaringClass); return new WildcardTypeImpl(lowerBounds, upperBounds); }
result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass); if (result != null) { return result; result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface); if (result != null) { return result;
result = resolveTypeVar(typeVar, parentAsType, declaringClass); result = resolveTypeVar(typeVar, superclass, declaringClass);
private static Type[] resolveWildcardTypeBounds(Type[] bounds, Type srcType, Class<?> declaringClass) { Type[] result = new Type[bounds.length]; for (int i = 0; i < bounds.length; i++) { if (bounds[i] instanceof TypeVariable) { result[i] = resolveTypeVar((TypeVariable<?>) bounds[i], srcType, declaringClass); } else if (bounds[i] instanceof ParameterizedType) { result[i] = resolveParameterizedType((ParameterizedType) bounds[i], srcType, declaringClass); } else if (bounds[i] instanceof WildcardType) { result[i] = resolveWildcardType((WildcardType) bounds[i], srcType, declaringClass); } else { result[i] = bounds[i]; } } return result; }
private Type getGenericGetterType(String propertyName) { try { Invoker invoker = reflector.getGetInvoker(propertyName); if (invoker instanceof MethodInvoker) { Field _method = MethodInvoker.class.getDeclaredField("method"); _method.setAccessible(true); Method method = (Method) _method.get(invoker); return TypeParameterResolver.resolveReturnType(method, reflector.getType()); } else if (invoker instanceof GetFieldInvoker) { Field _field = GetFieldInvoker.class.getDeclaredField("field"); _field.setAccessible(true); Field field = (Field) _field.get(invoker); return TypeParameterResolver.resolveFieldType(field, reflector.getType()); } } catch (NoSuchFieldException | IllegalAccessException ignored) { } return null; }
private void addGetField(Field field) { if (isValidPropertyName(field.getName())) { getMethods.put(field.getName(), new GetFieldInvoker(field)); Type fieldType = TypeParameterResolver.resolveFieldType(field, type); getTypes.put(field.getName(), typeToClass(fieldType)); } }
private void addSetMethod(String name, Method method) { if (isValidPropertyName(name)) { setMethods.put(name, new MethodInvoker(method)); Type[] paramTypes = TypeParameterResolver.resolveParamTypes(method, type); setTypes.put(name, typeToClass(paramTypes[0])); } }
private static Type resolveWildcardType(WildcardType wildcardType, Type srcType, Class<?> declaringClass) { Type[] lowerBounds = resolveWildcardTypeBounds(wildcardType.getLowerBounds(), srcType, declaringClass); Type[] upperBounds = resolveWildcardTypeBounds(wildcardType.getUpperBounds(), srcType, declaringClass); return new WildcardTypeImpl(lowerBounds, upperBounds); }
result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass); if (result != null) { return result; result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface); if (result != null) { return result;
private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) { if (type instanceof TypeVariable) { return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass); } else if (type instanceof ParameterizedType) { return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass); } else if (type instanceof GenericArrayType) { return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass); } else { return type; } }
private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class<?> declaringClass) { Class<?> rawType = (Class<?>) parameterizedType.getRawType(); Type[] typeArgs = parameterizedType.getActualTypeArguments(); Type[] args = new Type[typeArgs.length]; for (int i = 0; i < typeArgs.length; i++) { if (typeArgs[i] instanceof TypeVariable) { args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass); } else if (typeArgs[i] instanceof ParameterizedType) { args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass); } else if (typeArgs[i] instanceof WildcardType) { args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass); } else { args[i] = typeArgs[i]; } } return new ParameterizedTypeImpl(rawType, null, args); }
public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) { Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface); if (resolvedReturnType instanceof Class<?>) { this.returnType = (Class<?>) resolvedReturnType; } else if (resolvedReturnType instanceof ParameterizedType) { this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType(); } else { this.returnType = method.getReturnType(); } this.returnsVoid = void.class.equals(this.returnType); this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray(); this.returnsCursor = Cursor.class.equals(this.returnType); this.returnsOptional = Optional.class.equals(this.returnType); this.mapKey = getMapKey(method); this.returnsMap = this.mapKey != null; this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class); this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class); this.paramNameResolver = new ParamNameResolver(configuration, method); }