Java AnnotationMirror类代码示例

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
public static List<JoinColumn> getJoinColumns(final AnnotationModelHelper helper, Map<String, ? extends AnnotationMirror> annByType) {
    final List<JoinColumn> result = new ArrayList<JoinColumn>();
    AnnotationMirror joinColumnAnn = annByType.get("javax.persistence.JoinColumn"); // NOI18N
    if (joinColumnAnn != null) {
        result.add(new JoinColumnImpl(helper, joinColumnAnn));
    } else {
        AnnotationMirror joinColumnsAnnotation = annByType.get("javax.persistence.JoinColumns"); // NOI18N
        if (joinColumnsAnnotation != null) {
            AnnotationParser jcParser = AnnotationParser.create(helper);
            jcParser.expectAnnotationArray("value", helper.resolveType("javax.persistence.JoinColumn"), new ArrayValueHandler() { // NOI18N
                public Object handleArray(List<AnnotationValue> arrayMembers) {
                    for (AnnotationValue arrayMember : arrayMembers) {
                        AnnotationMirror joinColumnAnnotation = (AnnotationMirror)arrayMember.getValue();
                        result.add(new JoinColumnImpl(helper, joinColumnAnnotation));
                    }
                    return null;
                }
            }, null);
            jcParser.parse(joinColumnsAnnotation);
        }
    }
    return result;
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
public void testScanAnnotationsOnFields() throws Exception {
    final AnnotationModelHelper helper = AnnotationModelHelper.create(createClasspathInfoForScanningAnnotations());
    final Set<String> elements = new HashSet<String>();
    
    helper.runJavaSourceTask(new Callable<Void>() {
        public Void call() throws InterruptedException {
            helper.getAnnotationScanner().findAnnotations(
                    "javax.annotation.Resource",
                    EnumSet.of(ElementKind.FIELD),
                    new AnnotationHandler() {
                        public void handleAnnotation(TypeElement typeElement, Element element, AnnotationMirror annotationMirror) {
                            assertEquals("foo.MyClass", typeElement.getQualifiedName().toString());
                            elements.add(element.getSimpleName().toString());
                        }
                    });
            return null;
        }
    });
    assertEquals(1, elements.size());
    assertTrue(elements.contains("myDS"));
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
/**
 * Gets all the annotations on the given declaration.
 */
private Annotation[] getAllAnnotations(Element decl, Locatable srcPos) {
    List<Annotation> r = new ArrayList<Annotation>();

    for( AnnotationMirror m : decl.getAnnotationMirrors() ) {
        try {
            String fullName = ((TypeElement) m.getAnnotationType().asElement()).getQualifiedName().toString();
            Class<? extends Annotation> type =
                SecureLoader.getClassClassLoader(getClass()).loadClass(fullName).asSubclass(Annotation.class);
            Annotation annotation = decl.getAnnotation(type);
            if(annotation!=null)
                r.add( LocatableAnnotation.create(annotation,srcPos) );
        } catch (ClassNotFoundException e) {
            // just continue
        }
    }

    return r.toArray(new Annotation[r.size()]);
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
public ManyToManyImpl(final AnnotationModelHelper helper, final Element element, AnnotationMirror manyToManyAnnotation, String name, Map<String, ? extends AnnotationMirror> annByType) {
    this.name = name;
    AnnotationParser parser = AnnotationParser.create(helper);
    parser.expectClass("targetEntity", new DefaultProvider() { // NOI18N
        public Object getDefaultValue() {
            return EntityMappingsUtilities.getCollectionArgumentTypeName(helper, element);
        }
    });
    parser.expectEnumConstantArray("cascade", helper.resolveType("javax.persistence.CascadeType"), new ArrayValueHandler() { // NOI18N
        public Object handleArray(List<AnnotationValue> arrayMembers) {
            return new CascadeTypeImpl(arrayMembers);
        }
    }, parser.defaultValue(new CascadeTypeImpl()));
    parser.expectEnumConstant("fetch", helper.resolveType("javax.persistence.FetchType"), parser.defaultValue("LAZY")); // NOI18N
    parser.expectString("mappedBy", parser.defaultValue("")); // NOI18N
    parseResult = parser.parse(manyToManyAnnotation);

    joinTable = new JoinTableImpl(helper, annByType.get("javax.persistence.JoinTable")); // NOI18N
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
private boolean isDaggerRequired( @Nonnull final TypeElement typeElement,
                                  @Nullable final AnnotationMirror scopeAnnotation )
{
  final VariableElement daggerParameter = (VariableElement)
    ProcessorUtil.getAnnotationValue( processingEnv.getElementUtils(),
                                      typeElement,
                                      Constants.COMPONENT_ANNOTATION_CLASSNAME,
                                      "dagger" ).getValue();
  switch ( daggerParameter.getSimpleName().toString() )
  {
    case "ENABLE":
      return true;
    case "DISABLE":
      return false;
    default:
      return null != scopeAnnotation &&
             null != processingEnv.getElementUtils().getTypeElement( Constants.DAGGER_MODULE_CLASSNAME );
  }
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
public void testScanAnnotationsOnMethods() throws Exception {
    final AnnotationModelHelper helper = AnnotationModelHelper.create(createClasspathInfoForScanningAnnotations());
    final Set<String> elements = new HashSet<String>();
    
    helper.runJavaSourceTask(new Callable<Void>() {
        public Void call() throws InterruptedException {
            helper.getAnnotationScanner().findAnnotations(
                    "javax.annotation.Resource",
                    EnumSet.of(ElementKind.METHOD),
                    new AnnotationHandler() {
                        public void handleAnnotation(TypeElement typeElement, Element element, AnnotationMirror annotationMirror) {
                            assertEquals("foo.YourClass", typeElement.getQualifiedName().toString());
                            elements.add(element.getSimpleName().toString());
                        }
                    });
            return null;
        }
    });
    assertEquals(1, elements.size());
    assertTrue(elements.contains("setYourDataSource"));
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
@Override
public MethodSpec supplyFor(final AnnotationMirror anno) {
	final CodeBlock body = CodeBlock
			.builder()
			.addStatement(
					"return $T.getColorStateList($N(), $L)",
					AndroidClassNames.CONTEXT_COMPAT,
					CallerDef.GET_CONTEXT,
					getLiteralFromAnnotation(anno, "resId"))
			.build();

	return getBaseMethodSpec()
			.returns(AndroidClassNames.COLOR_STATE_LIST)
			.addCode(body)
			.build();
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
public OneToOneImpl(final AnnotationModelHelper helper, final Element element, AnnotationMirror oneToOneAnnotation, String name, Map<String, ? extends AnnotationMirror> annByType) {
    this.name = name;
    AnnotationParser parser = AnnotationParser.create(helper);
    parser.expectClass("targetEntity", new DefaultProvider() { // NOI18N
        public Object getDefaultValue() {
            return EntityMappingsUtilities.getElementTypeName(element);
        }
    });
    parser.expectEnumConstantArray("cascade", helper.resolveType("javax.persistence.CascadeType"), new ArrayValueHandler() { // NOI18N
        public Object handleArray(List<AnnotationValue> arrayMembers) {
            return new CascadeTypeImpl(arrayMembers);
        }
    }, parser.defaultValue(new CascadeTypeImpl()));
    parser.expectEnumConstant("fetch", helper.resolveType("javax.persistence.FetchType"), parser.defaultValue("EAGER")); // NOI18N
    parser.expectPrimitive("optional", Boolean.class, parser.defaultValue(true)); // NOI18N
    parser.expectString("mappedBy", parser.defaultValue("")); // NOI18N
    parseResult = parser.parse(oneToOneAnnotation);

    joinTable = new JoinTableImpl(helper, annByType.get("javax.persistence.JoinTable")); // NOI18N
    joinColumnList = EntityMappingsUtilities.getJoinColumns(helper, annByType);
    pkJoinColumnList = EntityMappingsUtilities.getPrimaryKeyJoinColumns(helper, annByType);
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
private static Boolean findAnnotationValueAsBoolean(Element fieldElement, String[] fieldAnnotationFqns, String annotationKey) {
    Boolean isFieldXable = null;
    for (int i = 0; i < fieldAnnotationFqns.length; i++) {
        String fieldAnnotationFqn = fieldAnnotationFqns[i];
        AnnotationMirror fieldAnnotation = JpaControllerUtil.findAnnotation(fieldElement, fieldAnnotationFqn); //NOI18N
        if (fieldAnnotation != null) {  
            String annotationValueString = JpaControllerUtil.findAnnotationValueAsString(fieldAnnotation, annotationKey); //NOI18N
            if (annotationValueString != null) {
                isFieldXable = Boolean.valueOf(annotationValueString);
            }
            else {
                isFieldXable = Boolean.TRUE;
            }
            break;
        }
    }
    return isFieldXable;
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
@Test
public void testGenerateFor_defaultToBooleanAnnotationSupplied() {
	final Element element = avatarRule.getElementWithUniqueId("boolean");
	final AnnotationMirror mirror = AnnotationMirrorHelper.getAnnotationMirror(element, DefaultToBoolean.class);

	final MethodSpec generatedMethod = generator.generateFor(mirror);

	assertThat(generatedMethod, is(notNullValue()));
	checkMethodSignature(generatedMethod, ClassName.BOOLEAN.box());
	checkCompiles(generatedMethod);
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
@Override
public MethodSpec supplyFor(final AnnotationMirror useAnno, final int position) {
	return getBaseMethodSpec(position)
			.returns(Object.class)
			.addCode(CodeBlock
					.builder()
					.addStatement("return null")
					.build())
			.build();
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
private void addOnStale( @Nonnull final AnnotationMirror annotation, @Nonnull final ExecutableElement method )
  throws ArezProcessorException
{
  final String name =
    deriveHookName( method,
                    ComputedDescriptor.ON_STALE_PATTERN,
                    "Stale",
                    getAnnotationParameter( annotation, "name" ) );
  findOrCreateComputed( name ).setOnStale( method );
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
private ImmutableSet<String> buildAnnotations(ExecutableElement element) {
  ImmutableSet.Builder<String> builder = ImmutableSet.builder();

  List<? extends AnnotationMirror> annotations = element.getAnnotationMirrors();
  for (AnnotationMirror annotation : annotations) {
    builder.add(annotation.getAnnotationType()
        .asElement()
        .getSimpleName()
        .toString());
  }

  return builder.build();
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
@Override
public Result checkElement(final ExecutableElement element) {
	if (!ValueHandlerAnnoRetriever.hasAnnotation(element)) {
		return Result.createSuccessful();
	}

	final AnnotationMirror anno = ValueHandlerAnnoRetriever.getAnnotation(element);

	final MethodSpec supplier = getValueMethodGenerator.generateFor(anno);
	final TypeMirror suppliedType = returnTypeToTypeMirror(supplier);
	final TypeMirror recipientType = getParameterWithoutUseAnnotation(element).asType();

	if (!isAssignableOrConvertible(suppliedType, recipientType)) {
		return Result.createFailure(
				"Misused handler annotation found. \'%1$s\' cannot be cast to \'%2$s\'.",
				suppliedType,
				recipientType);
	}

	return Result.createSuccessful();
}
 

import javax.lang.model.element.AnnotationMirror; //导入依赖的package包/类
static void copyDocumentedAnnotations( @Nonnull final AnnotatedConstruct element,
                                       @Nonnull final MethodSpec.Builder builder )
{
  for ( final AnnotationMirror annotation : element.getAnnotationMirrors() )
  {
    final DeclaredType annotationType = annotation.getAnnotationType();
    if ( !annotationType.toString().startsWith( "react4j.annotations." ) &&
         null != annotationType.asElement().getAnnotation( Documented.class ) )
    {
      builder.addAnnotation( AnnotationSpec.get( annotation ) );
    }
  }
}