Java Target.value方法代码示例

import java.lang.annotation.Target; //导入方法依赖的package包/类
static boolean annotationMatchesTarget(Element annotationElement, ElementType elementType) {
  @Nullable Target target = annotationElement.getAnnotation(Target.class);
  if (target != null) {
    ElementType[] targetTypes = target.value();
    if (targetTypes.length == 0) {
      return false;
    }
    boolean found = false;
    for (ElementType t : targetTypes) {
      if (t == elementType) {
        found = true;
      }
    }
    if (!found) {
      return false;
    }
  }
  return true;
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
private static void annotationTypeAnnotation() {
    // @Target这个就是 此类型
    ClassBinds classBinds = Test.class.getAnnotation(ClassBinds.class);
    if (classBinds != null) {
        Annotation[] annotations = classBinds.annotationType().getAnnotations();
        Target target = classBinds.annotationType().getAnnotation(Target.class);
        if (target != null)
            System.out.print("ANNOTATION_TYPE---->targets:" );
        for (ElementType elementType : target.value()) {
            System.out.print("\t elementType:"+elementType);
        }
        System.out.println();
    }


}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
/**
 * 获得 method.
 * 
 * @param joinPoint
 *            the join point
 * @param klass
 *            the klass
 * @return the method
 * @deprecated 目前作用不大,将来会重构
 */
@Deprecated
protected Method getMethod(JoinPoint joinPoint,Class<? extends Annotation> klass){
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    Method method = methodSignature.getMethod();
    if (method.isAnnotationPresent(klass)){
        return method;
    }
    Target annotation = klass.getAnnotation(Target.class);
    ElementType[] value = annotation.value();
    try{
        Object target = joinPoint.getTarget();
        Class<? extends Object> targetClass = target.getClass();
        String methodName = method.getName();
        Class<?>[] parameterTypes = method.getParameterTypes();
        Method m1 = targetClass.getMethod(methodName, parameterTypes);
        if (m1.isAnnotationPresent(klass)){
            return m1;
        }
    }catch (Exception e){
        LOGGER.error(e.getClass().getName(), e);
    }
    throw new RuntimeException("No Proper annotation found.");
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
/**
 * Checks if is annotation present.
 * 
 * @param joinPoint
 *            the join point
 * @param klass
 *            the klass
 * @return true, if checks if is annotation present
 * @deprecated 目前作用不大,将来会重构
 */
@Deprecated
protected boolean isAnnotationPresent(JoinPoint joinPoint,Class<? extends Annotation> klass){
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    Method method = methodSignature.getMethod();
    if (method.isAnnotationPresent(klass)){
        return true;
    }
    Target annotation = klass.getAnnotation(Target.class);
    ElementType[] value = annotation.value();
    try{
        Object target = joinPoint.getTarget();
        Class<? extends Object> targetClass = target.getClass();
        String methodName = method.getName();
        Class<?>[] parameterTypes = method.getParameterTypes();
        Method m1 = targetClass.getMethod(methodName, parameterTypes);
        if (m1.isAnnotationPresent(klass)){
            return true;
        }
    }catch (Exception e){
        LOGGER.error(e.getClass().getName(), e);
    }
    return false;
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
@Nullable
private static Class<Annotation> getDeclaredAnnotationClass(AnnotationMirror mirror) throws ClassNotFoundException {
    TypeElement element = (TypeElement) mirror.getAnnotationType().asElement();
    // Ensure the annotation has the correct retention and targets.
    Retention retention = element.getAnnotation(Retention.class);
    if (retention != null && retention.value() != RetentionPolicy.RUNTIME) {
        return null;
    }
    Target target = element.getAnnotation(Target.class);
    if (target != null) {
        if (target.value().length < 2) {
            return null;
        }
        List<ElementType> targets = Arrays.asList(target.value());
        if (!(targets.contains(ElementType.TYPE) && targets.contains(ElementType.ANNOTATION_TYPE))) {
            return null;
        }
    }
    return (Class<Annotation>) Class.forName(element.getQualifiedName().toString());
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public final Description matchClass(ClassTree classTree, VisitorState state) {
  Symbol classSymbol = ASTHelpers.getSymbol(classTree);
  if ((classSymbol.flags() & Flags.ANNOTATION) != 0
      && SCOPE_ANNOTATION_MATCHER.matches(classTree, state)) {
    Target target = ASTHelpers.getAnnotation(classSymbol, Target.class);
    boolean hasExclusivelyTypeAndOrMethodTargeting = false;
    if (target != null) {
      for (ElementType elementType : target.value()) {
        if (elementType != METHOD && elementType != TYPE) {
          return describe(classTree, state);
        } else if (elementType == METHOD || elementType == TYPE) {
          hasExclusivelyTypeAndOrMethodTargeting = true;
        }
      }
    }
    if(!hasExclusivelyTypeAndOrMethodTargeting) { // true for no target set and for @Target({})
      return describe(classTree, state);
    }
  }
  return Description.NO_MATCH;
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
private boolean _isValidElement(Element pElement)
{
  Retention retention = pElement.getAnnotation(Retention.class);
  if (retention == null || retention.value() != RetentionPolicy.RUNTIME)
  {
    processingEnv.getMessager().printMessage(Diagnostic.Kind.MANDATORY_WARNING, "Retention should be RUNTIME", pElement);
    return false;
  }
  Target target = pElement.getAnnotation(Target.class);
  if (target == null || target.value() == null || target.value().length == 0)
  {
    processingEnv.getMessager().printMessage(Diagnostic.Kind.MANDATORY_WARNING, "Target has to be defined", pElement);
    return false;
  }
  else
  {
    for (ElementType elementType : target.value())
    {
      if (elementType != ElementType.TYPE)
      {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.MANDATORY_WARNING, "Unsupported type: " + elementType, pElement);
        return false;
      }
    }
  }
  return true;
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
@Test
public void Annotation_can_only_be_applied_to_fields() {
    Target target = FromListOf.class.getAnnotation(Target.class);
    assertEquals(1, target.value().length);
    ElementType type = target.value()[0];
    assertTrue(type.equals(ElementType.FIELD));
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
@Test
public void Annotation_can_only_be_applied_to_fields() {
    Target target = Range.class.getAnnotation(Target.class);
    assertEquals(1, target.value().length);
    ElementType type = target.value()[0];
    assertTrue(type.equals(ElementType.FIELD));
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
@Test
public void Annotation_can_only_be_applied_to_fields() {
    Target target = Fixture.class.getAnnotation(Target.class);
    assertEquals(1, target.value().length);
    ElementType type = target.value()[0];
    assertTrue(type.equals(ElementType.FIELD));
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
private static boolean validTarget(Class<? extends Annotation> type) {
	final Target target = type.getAnnotation(Target.class);

	if(target==null) {
		return false;
	}

	final ElementType[] targets=target.value();

	return 
		targets.length == 1 && 
		targets[0] == ElementType.ANNOTATION_TYPE;
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
public static void copyAnnotationTarget(Class annotationClass, AnnotationDefinition annotationDefinition) {
    if (annotationClass.isAnnotationPresent(Target.class)) {
        Target targetAnnotation = (Target) annotationClass.getAnnotation(Target.class);
        java.lang.annotation.ElementType[] targets = targetAnnotation.value();
        if (targets != null && targets.length > 0) {
            for (int i = 0; i < targets.length; i++) {
                annotationDefinition.addTarget(buildElementType(targets[i]));
            }
        } else {
            //added to avoid an errai unmarshalling error in broser side, when an annotation has no targets, e.g.
            //javax.persistence.UniqueConstraint
            annotationDefinition.addTarget(ElementType.UNDEFINED);
        }
    }
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
public void process() {
    for (Entry<Class<?>, SimpleDeclarationVisitor> av_pair : _annotationVisitors.entrySet()) {

        Class<?> annotation = av_pair.getKey();
        String annotName = annotation.getName();

        AnnotationTypeDeclaration annotDeclaration = _annotationDefinitions.get(annotName);
        if (annotDeclaration == null) {
            _messager.printError("Cannot load class definition of annotation @" + annotName +
                ". This annotation will NOT be processed");
            continue;
        }

        Target applicableOn = annotDeclaration.getAnnotation(Target.class);

        SimpleDeclarationVisitor visitor = av_pair.getValue();
        if (visitor == null) {
            _messager.printError("Cannot find the visitor for annotation @" + annotName +
                ". This annotation will NOT be processed");
            continue;
        }

        for (Declaration typeDeclaration : _annotatedElements.get(annotDeclaration)) {

            if (applicableOn != null && applicableOn.value() != null)
                if (!testSuitableDeclaration(typeDeclaration, applicableOn)) {
                    _messager.printError(typeDeclaration.getPosition(), "[ERROR] The @" +
                        annotation.getSimpleName() +
                        "annotation is not applicable for this type of Java construct.");
                }

            // check using the visitor
            typeDeclaration.accept(visitor);
        }
    }
}
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
private boolean testSuitableDeclaration(Declaration typeDeclaration, Target applicableOn) {

        for (ElementType applicableType : applicableOn.value()) {
            if (UtilsAPT.applicableOnDeclaration(applicableType, typeDeclaration))
                return true;
        }
        return false;
    }
 

import java.lang.annotation.Target; //导入方法依赖的package包/类
public boolean canPresentOn(ElementType type) throws SyntaxException {
        String name = fullName();
        try {
                Class<?> cls = Class.forName(name);
                Annotation[] annotations = cls.getAnnotations();
                for (Annotation a : annotations) {
                        if (a instanceof Target) {
                                Target target = (Target) a;
                                ElementType[] types = target.value();
                                for (ElementType t : types) {
                                        if (t.equals(type)) return true;
                                }
                                return false;
                        }
                }
                return true;
        } catch (ClassNotFoundException e) {
                // annotation not compiled yet
                // check manually
                SAnno targetAnno = null;
                for (SAnno anno : annos()) {
                        if (anno.type().fullName().equals(Target.class.getName())) {
                                targetAnno = anno;
                                break;
                        }
                }
                if (null == targetAnno) return true;
                SAnnoField valueAnnoF = null;
                for (SAnnoField f : targetAnno.type().annoFields()) {
                        if (f.name().equals("value")) {
                                valueAnnoF = f;
                                break;
                        }
                }
                if (valueAnnoF == null) throw new LtBug("it should not be null");
                SArrayValue arrV = (SArrayValue) targetAnno.values().get(valueAnnoF);
                for (Value v : arrV.values()) {
                        if (v instanceof EnumValue && v.type().fullName().equals(ElementType.class.getName())) {
                                if (type.name().equals(((EnumValue) v).enumStr())) return true;
                        }
                }
                return false;
        }
}