Java AnnotatedType.isAnnotationPresent方法代码示例

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
public static boolean containsTypeAnnotation(AnnotatedType type, Class<? extends Annotation> annotation) {
    if (type.isAnnotationPresent(annotation)) {
        return true;
    }
    if (type instanceof AnnotatedParameterizedType) {
        AnnotatedParameterizedType parameterizedType = ((AnnotatedParameterizedType) type);
        return Arrays.stream(parameterizedType.getAnnotatedActualTypeArguments())
                .anyMatch(param -> containsTypeAnnotation(param, annotation));
    }
    if (type instanceof AnnotatedTypeVariable) {
        AnnotatedTypeVariable variable = ((AnnotatedTypeVariable) type);
        return Arrays.stream(variable.getAnnotatedBounds())
                .anyMatch(bound -> containsTypeAnnotation(bound, annotation));
    }
    if (type instanceof AnnotatedWildcardType) {
        AnnotatedWildcardType wildcard = ((AnnotatedWildcardType) type);
        return Stream.concat(
                Arrays.stream(wildcard.getAnnotatedLowerBounds()),
                Arrays.stream(wildcard.getAnnotatedUpperBounds()))
                .anyMatch(param -> containsTypeAnnotation(param, annotation));
    }
    if (type instanceof AnnotatedArrayType) {
        return containsTypeAnnotation(((AnnotatedArrayType) type).getAnnotatedGenericComponentType(), annotation);
    }
    return false;
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
/**
 * Check whether the given <code>method</code> return type is annotated with the {@link PropertySetRef} annotation.
 * @param method Method to inspect
 * @return Optional {@link PropertySetRef} annotation, if available
 */
private static Optional<PropertySetRef> getResponsePropertySet(Method method) {
	final AnnotatedType rt = method.getAnnotatedReturnType();
	if (rt != null) {
		if (rt.isAnnotationPresent(PropertySetRef.class)) {
			return Optional.of(rt.getAnnotation(PropertySetRef.class));
		}
		// check meta-annotations
		List<PropertySetRef> annotations = AnnotationUtils.getAnnotations(rt, PropertySetRef.class);
		if (!annotations.isEmpty()) {
			return Optional.ofNullable(annotations.get(0));
		}
	}
	return Optional.empty();
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
/**
 * Check whether the given <code>method</code> return type is annotated with the {@link ApiPropertySetModel}
 * annotation.
 * @param method Method to inspect
 * @return Optional {@link ApiPropertySetModel} annotation, if available
 */
private static Optional<ApiPropertySetModel> getResponsePropertySetModel(Method method) {
	final AnnotatedType rt = method.getAnnotatedReturnType();
	if (rt != null) {
		if (rt.isAnnotationPresent(ApiPropertySetModel.class)) {
			return Optional.of(rt.getAnnotation(ApiPropertySetModel.class));
		}
		// check meta-annotations
		List<ApiPropertySetModel> annotations = AnnotationUtils.getAnnotations(rt, ApiPropertySetModel.class);
		if (!annotations.isEmpty()) {
			return Optional.ofNullable(annotations.get(0));
		}
	}
	return Optional.empty();
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public GraphQLInterfaceType toGraphQLType(String typeName, AnnotatedType javaType, Set<Type> abstractTypes, OperationMapper operationMapper, BuildContext buildContext) {
    GraphQLInterfaceType.Builder typeBuilder = newInterface()
            .name(typeName)
            .description(buildContext.typeInfoGenerator.generateTypeDescription(javaType));

    GraphQLInterface graphQLInterface = javaType.getAnnotation(GraphQLInterface.class);
    List<String> fieldOrder = graphQLInterface != null ? Arrays.asList(graphQLInterface.fieldOrder()) : Collections.emptyList();
    List<GraphQLFieldDefinition> fields = objectTypeMapper.getFields(javaType, fieldOrder, buildContext, operationMapper);
    fields.forEach(typeBuilder::field);

    typeBuilder.typeResolver(buildContext.typeResolver);
    GraphQLInterfaceType type = new MappedGraphQLInterfaceType(typeBuilder.build(), javaType);

    if (javaType.isAnnotationPresent(GraphQLInterface.class)) {
        GraphQLInterface meta = javaType.getAnnotation(GraphQLInterface.class);
        if (meta.implementationAutoDiscovery()) {
            String[] scanPackages = meta.scanPackages();
            if (scanPackages.length == 0 && Utils.arrayNotEmpty(buildContext.basePackages)) {
                scanPackages = buildContext.basePackages;
            }
            ClassUtils.findImplementations(javaType, scanPackages).forEach(impl ->
                    getImplementingType(impl, abstractTypes, operationMapper, buildContext)
                            .ifPresent(implType -> buildContext.typeRepository.registerDiscoveredCovariantType(type.getName(), impl, implType)));

        }
    }
    return type;
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public boolean supports(AnnotatedType type) {
    return type.isAnnotationPresent(GraphQLUnion.class)
            || ClassUtils.getRawType(type.getType()).isAnnotationPresent(GraphQLUnion.class);
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public boolean supports(AnnotatedType type) {
    return type.isAnnotationPresent(GraphQLRootContext.class);
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public boolean supports(AnnotatedType type) {
    return type.isAnnotationPresent(GraphQLContext.class);
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public boolean supports(AnnotatedType type) {
    return type.isAnnotationPresent(GraphQLId.class);
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public boolean supports(AnnotatedType type) {
    return type.isAnnotationPresent(GraphQLEnvironment.class);
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public boolean supports(AnnotatedType type) {
    return type.isAnnotationPresent(GraphQLScalar.class);
}
 

import java.lang.reflect.AnnotatedType; //导入方法依赖的package包/类
@Override
public boolean supportsInterface(AnnotatedType interfase) {
    return interfase.isAnnotationPresent(GraphQLInterface.class);
}