Java FieldAnnotationsScanner类代码示例

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
/**
 * Scans the specified packages for annotated classes, and applies Config values to them.
 * 
 * @param config the Config to derive values from
 * @param packageNamePrefix the prefix to limit scanning to - e.g. "com.github"
 * @return The constructed TypesafeConfigModule.
 */
public static TypesafeConfigModule fromConfigWithPackage(Config config, String packageNamePrefix) {
	 ConfigurationBuilder configBuilder = 
		 new ConfigurationBuilder()
         .filterInputsBy(new FilterBuilder().includePackage(packageNamePrefix))
         .setUrls(ClasspathHelper.forPackage(packageNamePrefix))
         .setScanners(
        	new TypeAnnotationsScanner(), 
        	new MethodParameterScanner(), 
        	new MethodAnnotationsScanner(), 
        	new FieldAnnotationsScanner()
         );
	Reflections reflections = new Reflections(configBuilder);
	
	return new TypesafeConfigModule(config, reflections);
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
/**
 * Get fields for a type. It extracts all JsonProperty fields
 * @param type
 * @return
 */
public static String[] getIncludeFields(Class type) {
  if (!fieldsCache.containsKey(type.getTypeName())) {
    Reflections
        reflections =
        new Reflections(type.getCanonicalName(), new FieldAnnotationsScanner());
    List<String> ret = new ArrayList<>();
    for (Field field : reflections.getFieldsAnnotatedWith(JsonProperty.class)) {
      JsonProperty property = field.getAnnotation(JsonProperty.class);
      ret.add(property.value());
    }

    if (type.getSuperclass() != null) {
      ret.addAll(Arrays.asList(getIncludeFields(type.getSuperclass())));
    }

    fieldsCache.putIfAbsent(type.getTypeName(), ret.toArray(new String[ret.size()]));
  }
  return fieldsCache.get(type.getTypeName());
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
private void init(String packageName) {
  FilterBuilder filters = new FilterBuilder().includePackage(packageName);

  Scanner[] scanners = {
      new TypeAnnotationsScanner(),
      new MethodAnnotationsScanner(),
      new MethodParameterScanner(),
      new FieldAnnotationsScanner(),
      new SubTypesScanner().filterResultsBy(filters)
  };

  reflections = new ConfigurationBuilder()
      .addUrls(ClasspathHelper.forPackage(packageName))
      .addScanners(scanners)
      .filterInputsBy(filters)
      .build();
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
/**
 * Loads the configuration
 * @throws IOException
 */
public void build() throws IOException {
    if (configFile == null) throw new IllegalStateException("File not initialized");

    Reflections reflections = new Reflections(new org.reflections.util.ConfigurationBuilder()
            .setUrls(ClasspathHelper.forClass(Configuration.class))
            .addScanners(new FieldAnnotationsScanner()));
    Set<Field> options = reflections.getFieldsAnnotatedWith(Option.class);

    // Load config file if it exists
    if (configFile.exists()) properties.load(new FileInputStream(configFile));

    // Load configuration fields
    options.forEach(o -> {
        Option option = o.getAnnotation(Option.class);
        try {
            Object value = configFile.exists()
                    ? properties.getOrDefault(option.value(), o.get(null))
                    : o.get(null);
            o.setAccessible(true);
            o.set(null, value);
            if (value.getClass().isAssignableFrom(String.class)) {
                properties.setProperty(option.value(), (String) value);
            }
        } catch (IllegalAccessException e) {
            LOG.severe("Could not load configuration, IllegalAccessException");
            System.exit(-1);
        }
    });

    // Write the full configuration file
    properties.store(new FileOutputStream(configFile), null);
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
static synchronized Reflections reflectionsForPrefixes(List<String> prefixes) {
  if (packagePrefixesToReflections.containsKey(prefixes)) {
    return packagePrefixesToReflections.get(prefixes);
  }
  ConfigurationBuilder builder = new ConfigurationBuilder()
      .setUrls(urlsToReflect(prefixes))
      .setScanners(
          new FieldAnnotationsScanner(),
          new SubTypesScanner());
  Reflections reflections = new Reflections(builder);
  packagePrefixesToReflections.put(prefixes, reflections);
  return reflections;
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
public Anno4j(Repository repository, IDGenerator idGenerator, URI defaultContext, boolean persistSchemaAnnotations, Set<URL> additionalClasses) throws RepositoryConfigException, RepositoryException {
    this.idGenerator = idGenerator;
    this.defaultContext = defaultContext;

    classpath = new HashSet<>();
    classpath.addAll(ClasspathHelper.forClassLoader());
    classpath.addAll(ClasspathHelper.forJavaClassPath());
    classpath.addAll(ClasspathHelper.forManifest());
    classpath.addAll(ClasspathHelper.forPackage(""));
    if(additionalClasses != null) {
        classpath.addAll(additionalClasses);
    }

    Reflections annotatedClasses = new Reflections(new ConfigurationBuilder()
            .setUrls(classpath)
            .useParallelExecutor()
            .filterInputsBy(FilterBuilder.parsePackages("-java, -javax, -sun, -com.sun"))
            .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new FieldAnnotationsScanner()));

    // Bugfix: Searching for Reflections creates a lot ot Threads, that are not closed at the end by themselves,
    // so we close them manually.
    annotatedClasses.getConfiguration().getExecutorService().shutdown();

    // find classes with @Partial annotation
    this.partialClasses = annotatedClasses.getTypesAnnotatedWith(Partial.class, true);

    scanForEvaluators(annotatedClasses);

    if(!repository.isInitialized()) {
        repository.initialize();
    }

    this.setRepository(repository, additionalClasses, additionalClasses);

    // Persist schema information to repository:
    if(persistSchemaAnnotations) {
        persistSchemaAnnotations(annotatedClasses);
    }
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
@Test
public void testMatchingExistingSchema() throws Exception {
    Anno4j anno4j = new Anno4j();

    OWLClazz myPerson = anno4j.createObject(OWLClazz.class, (Resource) new URIImpl("http://example.de/#validly_annotated_person"));
    RDFSProperty bossProperty = anno4j.createObject(RDFSProperty.class, (Resource) new URIImpl("http://example.de/#has_boss"));

    Restriction bossAllValuesFromRestr = anno4j.createObject(Restriction.class);
    bossAllValuesFromRestr.setOnClazz(Sets.newHashSet(myPerson));
    bossAllValuesFromRestr.setOnProperty(Sets.newHashSet(bossProperty));
    bossAllValuesFromRestr.setAllValuesFrom(Sets.<OWLClazz>newHashSet(myPerson));

    Reflections types = new Reflections(
            new ConfigurationBuilder()
                    .setUrls(
                            ClasspathHelper.forClass(Person.class, ClasspathHelper.staticClassLoader()),
                            ClasspathHelper.forClass(PersonSupport.class, ClasspathHelper.staticClassLoader())
                    )
                    .setScanners(new MethodAnnotationsScanner(), new FieldAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner())
    );

    Transaction transaction = anno4j.createTransaction();
    transaction.begin();
    SchemaPersistingManager persistingManager = new OWLSchemaPersistingManager(transaction.getConnection());

    boolean exceptionThrown = false;
    try {
        persistingManager.persistSchema(types);
    } catch (SchemaPersistingManager.ContradictorySchemaException e) {
        exceptionThrown = true;
    }
    assertFalse(exceptionThrown);
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
@Test
public void testContradictoryExistingSchema() throws Exception {
    Anno4j anno4j = new Anno4j();

    Transaction setupTransaction = anno4j.createTransaction();
    setupTransaction.begin();
    setupTransaction.getConnection().prepareUpdate("INSERT DATA {" +
            "  <http://example.de/#validly_annotated_person> rdfs:subClassOf _:restr . " +
            "  _:restr a owl:Restriction . " +
            "  _:restr owl:onProperty <http://example.de/#id> . " +
            "  _:restr owl:minCardinality '42'^^xsd:nonNegativeInteger . " +
            "}").execute();
    setupTransaction.commit();

    Transaction transaction = anno4j.createTransaction();
    transaction.begin();
    SchemaPersistingManager persistingManager = new OWLSchemaPersistingManager(transaction.getConnection());

    Reflections types = new Reflections(
            new ConfigurationBuilder()
                    .setUrls(
                            ClasspathHelper.forClass(Person.class, ClasspathHelper.staticClassLoader()),
                            ClasspathHelper.forClass(PersonSupport.class, ClasspathHelper.staticClassLoader())
                    )
                    .setScanners(new MethodAnnotationsScanner(), new FieldAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner())
    );

    boolean exceptionThrown = false;
    try {
        persistingManager.persistSchema(types);
    } catch (SchemaPersistingManager.ContradictorySchemaException e) {
        exceptionThrown = true;
    }
    assertTrue(exceptionThrown);
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
@Override
public Set<Field> load(Class<? extends Annotation> key)
        throws Exception
{
    Reflections reflections = new Reflections(forPackage(PACKAGES_PREFIX),
            new FieldAnnotationsScanner(), ReflectionHelper.class.getClassLoader());
    return unmodifiableSet(reflections.getFieldsAnnotatedWith(key));
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
@Test
public void getAllAndReflections() {
    Reflections reflections = new Reflections(TestModel.class, new FieldAnnotationsScanner());

    Set<Field> af1 = reflections.getFieldsAnnotatedWith(TestModel.AF1.class);
    Set<? extends Field> allFields = ReflectionUtils.getAll(af1, withModifier(Modifier.PROTECTED));
    assertTrue(allFields.size() == 1);
    assertThat(allFields, names("f2"));
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
private Collection<Field> findAnnotatedFields() {
  final Reflections reflections = new Reflections(new ConfigurationBuilder()
      .filterInputsBy(new FilterBuilder()
          .include(FilterBuilder.prefix(PROXIED_FLAGS_PACKAGE_WHITELIST_PREFIX)))
      .setUrls(ClasspathHelper.forPackage(PROXIED_FLAGS_PACKAGE_WHITELIST_PREFIX))
      .setScanners(new FieldAnnotationsScanner()));

  return reflections.getFieldsAnnotatedWith(Option.class);
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
/**
 * Initializes the instance based on what is returned by {@link #ignoreAllAnnotationsAssociatedWithTheseProjectClasses()}
 * and {@link #specificAnnotationDeclarationExclusionsForProject()}. This is time consuming and should only be done
 * once per project if possible - see the usage info in the {@link ReflectionBasedJsr303AnnotationTrollerBase}
 * class-level javadocs.
 *
 * <p>The given set of extra packages for constraint annotation searching will be passed into {@link
 * #getFinalPackagesToSearchForConstraintAnnotations(Set)} to generate the final set of packages that are searched.
 * If you don't want the {@link #DEFAULT_CONSTRAINT_SEARCH_PACKAGES} default packages to be searched you can
 * override {@link #getDefaultPackagesToSearchForConstraintAnnotations()}.
 */
public ReflectionBasedJsr303AnnotationTrollerBase(Set<String> extraPackagesForConstraintAnnotationSearch) {

    /*
     * Set up the {@link #ignoreAllAnnotationsAssociatedWithTheseClasses} and
     * {@link #specificAnnotationDeclarationsExcludedFromStrictMessageRequirement} fields so we know which
     * annotations are project-relevant vs. unit-test-only.
     */
    ignoreAllAnnotationsAssociatedWithTheseClasses =
        new ArrayList<>(setupIgnoreAllAnnotationsAssociatedWithTheseClasses());
    specificAnnotationDeclarationsExcludedFromStrictMessageRequirement =
        new ArrayList<>(setupSpecificAnnotationDeclarationExclusions());

    /*
     * Set up the {@link #reflections}, {@link #constraintAnnotationClasses}, and
     * {@link #allConstraintAnnotationsMasterList} fields. This is where the crazy reflection magic happens to troll
     * the project for the JSR 303 annotation declarations.
     */
    // Create the ConfigurationBuilder to search the relevant set of packages.
    ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
    for (String packageToAdd : getFinalPackagesToSearchForConstraintAnnotations(
        extraPackagesForConstraintAnnotationSearch)) {
        configurationBuilder.addUrls(ClasspathHelper.forPackage(packageToAdd));
    }

    // Create the Reflections object so it scans for all validation annotations we care about and all project
    //      classes that might have annotations on them.
    reflections = new Reflections(configurationBuilder.setScanners(
        new SubTypesScanner(), new MethodParameterScanner(), new TypeAnnotationsScanner(),
        new MethodAnnotationsScanner(), new FieldAnnotationsScanner()
    ));

    // Gather the list of all JSR 303 validation annotations in the project. Per the JSR 303 spec this is any
    //      annotation class type that is marked with @Constraint.
    constraintAnnotationClasses = new ArrayList<>();
    for (Class<?> constraintAnnotatedType : reflections.getTypesAnnotatedWith(Constraint.class, true)) {
        if (constraintAnnotatedType.isAnnotation()) {
            //noinspection unchecked
            constraintAnnotationClasses.add((Class<? extends Annotation>) constraintAnnotatedType);
        }
    }

    // We're not done gathering validation annotations though, unfortunately. JSR 303 also says that *any*
    //      annotation (whether it is a Constraint or not) that has a value field that returns an array of actual
    //      Constraints is treated as a "multi-value constraint", and the validation processor will run each
    //      of the Constraints in the array as if they were declared separately on the annotated element. Therefore,
    //      we have to dig through all the annotations in the project, find any that fall into this "multi-value
    //      constraint" category, and include them in our calculations.
    for (Class<? extends Annotation> annotationClass : reflections.getSubTypesOf(Annotation.class)) {
        if (isMultiValueConstraintClass(annotationClass))
            constraintAnnotationClasses.add(annotationClass);
    }

    // Setup the master constraint list
    allConstraintAnnotationsMasterList =
        new ArrayList<>(setupAllConstraintAnnotationsMasterList(reflections, constraintAnnotationClasses));

    /*
     * Finally use the info we've gathered/constructed previously to populate the
     * {@link #projectRelevantConstraintAnnotationsExcludingUnitTestsList} field, which is the main chunk of data
     * that extensions of this class will care about.
     */
    projectRelevantConstraintAnnotationsExcludingUnitTestsList = Collections.unmodifiableList(
        getSubAnnotationListUsingExclusionFilters(allConstraintAnnotationsMasterList,
                                                  ignoreAllAnnotationsAssociatedWithTheseClasses,
                                                  specificAnnotationDeclarationsExcludedFromStrictMessageRequirement));
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
private static FudgeContext constructContext() {
  FudgeContext fudgeContext = new FudgeContext();
  ExtendedFudgeBuilderFactory.init(fudgeContext.getObjectDictionary());
  InnerClassFudgeBuilderFactory.init(fudgeContext.getObjectDictionary());
  
  // hack to handle non-existent classpath directory entries
  List<UrlType> urlTypes = Lists.newArrayList(Vfs.getDefaultUrlTypes());
  urlTypes.add(0, new OGFileUrlType());
  Vfs.setDefaultURLTypes(urlTypes);
  
  // init annotation reflector, which needs this class loader
  Set<ClassLoader> loaders = new HashSet<>();
  loaders.add(OpenGammaFudgeContext.class.getClassLoader());
  try {
    ClassLoader loader = Thread.currentThread().getContextClassLoader();
    if (loader != null) {
      loaders.add(loader);
    }
  } catch (Exception ex) {
    // ignore
  }
  
  int availableProcessors = Runtime.getRuntime().availableProcessors();
  ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("Reflections-scan-%d").build();
  ExecutorService executorService = Executors.newFixedThreadPool(availableProcessors, factory);
  
  try {
    Configuration config = new ConfigurationBuilder()
      .setUrls(ClasspathHelper.forManifest(ClasspathHelper.forJavaClassPath()))
      .setScanners(new TypeAnnotationsScanner(), new FieldAnnotationsScanner(), new SubTypesScanner(false))
      .filterInputsBy(FilterBuilder.parse(AnnotationReflector.DEFAULT_ANNOTATION_REFLECTOR_FILTER))
      .addClassLoaders(loaders)
      .setExecutorService(executorService);
  
    AnnotationReflector.initDefaultReflector(new AnnotationReflector(config));
    AnnotationReflector reflector = AnnotationReflector.getDefaultReflector();
    
    fudgeContext.getObjectDictionary().addAllAnnotatedBuilders(reflector);
    fudgeContext.getTypeDictionary().addAllAnnotatedSecondaryTypes(reflector);
  } finally {
    executorService.shutdown();
  }
  
  FudgeTypeDictionary td = fudgeContext.getTypeDictionary();
  td.registerClassRename("com.opengamma.util.timeseries.zoneddatetime.ArrayZonedDateTimeDoubleTimeSeries", ImmutableZonedDateTimeDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.timeseries.zoneddatetime.ArrayZonedDateTimeDoubleTimeSeries", ImmutableZonedDateTimeDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.util.timeseries.zoneddatetime.ListZonedDateTimeDoubleTimeSeries", ImmutableZonedDateTimeDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.timeseries.zoneddatetime.ListZonedDateTimeDoubleTimeSeries", ImmutableZonedDateTimeDoubleTimeSeries.class);
  
  td.registerClassRename("com.opengamma.util.timeseries.localdate.ArrayLocalDateDoubleTimeSeries", ImmutableLocalDateDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.timeseries.localdate.ArrayLocalDateDoubleTimeSeries", ImmutableLocalDateDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.util.timeseries.localdate.ListLocalDateDoubleTimeSeries", ImmutableLocalDateDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.timeseries.localdate.ListLocalDateDoubleTimeSeries", ImmutableLocalDateDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.util.timeseries.localdate.MapLocalDateDoubleTimeSeries", ImmutableLocalDateDoubleTimeSeries.class);
  td.registerClassRename("com.opengamma.timeseries.localdate.MapLocalDateDoubleTimeSeries", ImmutableLocalDateDoubleTimeSeries.class);

  td.registerClassRename("com.opengamma.id.Identifier", ExternalId.class);
  td.registerClassRename("com.opengamma.id.IdentifierBundleWithDates", ExternalIdBundleWithDates.class);
  td.registerClassRename("com.opengamma.id.IdentifierBundle", ExternalIdBundle.class);
  td.registerClassRename("com.opengamma.id.IdentifierWithDates", ExternalIdWithDates.class);
  td.registerClassRename("com.opengamma.id.ObjectIdentifier", ObjectId.class);
  td.registerClassRename("com.opengamma.id.UniqueIdentifier", UniqueId.class);
  return fudgeContext;
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
@Test
public void testAnnotationPersisting() throws Exception {
    Anno4j anno4j = new Anno4j();

    Reflections types = new Reflections(
            new ConfigurationBuilder()
            .setUrls(
                    ClasspathHelper.forClass(Person.class, ClasspathHelper.staticClassLoader()),
                    ClasspathHelper.forClass(PersonSupport.class, ClasspathHelper.staticClassLoader())
            )
            .setScanners(new MethodAnnotationsScanner(), new FieldAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner())
    );

    Transaction transaction = anno4j.createTransaction();
    transaction.begin();
    SchemaPersistingManager persistingManager = new OWLSchemaPersistingManager(transaction.getConnection());

    persistingManager.persistSchema(types);

    // Query property characteristics:
    String q = QUERY_PREFIX + "ASK { " +
            "   <http://example.de/#id> a owl:FunctionalProperty . " +
            "   <http://example.de/#id> a owl:InverseFunctionalProperty . " +
            "   <http://example.de/#partner> a owl:SymmetricProperty . " +
            "   <http://example.de/#has_subordinate> a owl:TransitiveProperty . " +
            "   <http://example.de/#has_boss> a owl:TransitiveProperty . " +
            "   <http://example.de/#has_boss> owl:inverseOf <http://example.de/#has_subordinate> . " +
            "   <http://example.de/#has_subordinate> owl:inverseOf <http://example.de/#has_boss> . " +
            "}";
    BooleanQuery characteristicsQuery = transaction.getConnection().prepareBooleanQuery(QueryLanguage.SPARQL, q);
    assertTrue(characteristicsQuery.evaluate());

    // Query property restrictions:
    q = QUERY_PREFIX + "ASK { " +
            "   ?r1 a owl:Restriction . " +
            "   <http://example.de/#validly_annotated_person> rdfs:subClassOf ?r1 . " +
            "   ?r1 owl:onProperty <http://example.de/#id> . " +
            "   ?r1 owl:minCardinality ?v1 . " +
            "   FILTER ( ?v1 = 1 )" +

            "   ?r2 a owl:Restriction . " +
            "   <http://example.de/#validly_annotated_person> rdfs:subClassOf ?r2 . " +
            "   ?r2 owl:onProperty <http://example.de/#id> . " +
            "   ?r2 owl:maxCardinality ?v2 . " +
            "   FILTER ( ?v2 = 1 )" +

            "   ?r3 a owl:Restriction . " +
            "   <http://example.de/#validly_annotated_person> rdfs:subClassOf ?r3 . " +
            "   ?r3 owl:onProperty <http://example.de/#partner> . " +
            "   ?r3 owl:onClass <http://example.de/#validly_annotated_person> . " +
            "   ?r3 owl:minQualifiedCardinality ?v3 . " +
            "   FILTER ( ?v3 = 0 )" +

            "   ?r4 a owl:Restriction . " +
            "   <http://example.de/#validly_annotated_person> rdfs:subClassOf ?r4 . " +
            "   ?r4 owl:onProperty <http://example.de/#has_boss> . " +
            "   ?r4 owl:allValuesFrom <http://example.de/#validly_annotated_person> . " +

            "   ?r5 a owl:Restriction . " +
            "   <http://example.de/#validly_annotated_person> rdfs:subClassOf ?r5 . " +
            "   ?r5 owl:onProperty <http://example.de/#has_activity> . " +
            "   ?r5 owl:minCardinality ?v5 . " +
            "   FILTER( ?v5 = 2 )" +

            "   ?r6 a owl:Restriction . " +
            "   <http://example.de/#validly_annotated_person> rdfs:subClassOf ?r6 . " +
            "   ?r6 owl:onProperty <http://example.de/#has_activity> . " +
            "   ?r6 owl:minQualifiedCardinality ?v6 . " +
            "   ?r6 owl:onClass <http://example.de/#job> . " +
            "   FILTER( ?v6 = 1 )" +
            "}";

    BooleanQuery restrictionQuery = transaction.getConnection().prepareBooleanQuery(QueryLanguage.SPARQL, q);
    assertTrue(restrictionQuery.evaluate());
}
 

import org.reflections.scanners.FieldAnnotationsScanner; //导入依赖的package包/类
public TypesFinder(){
    reflections = new Reflections(new FieldAnnotationsScanner(), 
                                    new MethodAnnotationsScanner(), 
                                    new TypeAnnotationsScanner(), 
                                    new SubTypesScanner());
}