Java 类org.reflections.scanners.TypeAnnotationsScanner 实例源码

protected GuiceApplication(String... basePackages) {
  final ConfigurationBuilder confBuilder = new ConfigurationBuilder();
  final FilterBuilder filterBuilder = new FilterBuilder();

  if (basePackages.length == 0) {
    basePackages = new String[] {};
  }

  logger.info("op=create, auto_scan_packages={}", (Object[]) basePackages);

  for (String pkg : basePackages) {
    confBuilder.addUrls(ClasspathHelper.forPackage(pkg));
    filterBuilder.include(FilterBuilder.prefix(pkg));
  }

  confBuilder.filterInputsBy(filterBuilder)
      .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());

  this.reflections = new Reflections(confBuilder);
}

public ReflectionsServiceDiscovery(String resourceSearchPackages, JsonServiceLocator locator) {
    this.locator = locator;

    ConfigurationBuilder builder = new ConfigurationBuilder();

    PreconditionUtil.assertNotNull("no resourceSearchPackage configured", resourceSearchPackages);

    FilterBuilder filter = new FilterBuilder();
    for (String resourceSearchPackage : resourceSearchPackages.split(",")) {
        builder = builder.addUrls(ClasspathHelper.forPackage(resourceSearchPackage));
        filter.includePackage(resourceSearchPackage);
    }
    filter.includePackage(Repository.class.getPackage().getName());
    filter.includePackage(ResourceRepository.class.getPackage().getName());
    builder = builder.filterInputsBy(filter);

    builder = builder.addUrls(ClasspathHelper.forClass(Repository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepositoryV2.class));

    builder = builder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner());
    reflections = new Reflections(builder);
}

public ReflectionsServiceDiscovery(String resourceSearchPackages, JsonServiceLocator locator) {
    this.locator = locator;

    ConfigurationBuilder builder = new ConfigurationBuilder();

    PreconditionUtil.assertNotNull("no resourceSearchPackage configured", resourceSearchPackages);

    FilterBuilder filter = new FilterBuilder();
    for (String resourceSearchPackage : resourceSearchPackages.split(",")) {
        builder = builder.addUrls(ClasspathHelper.forPackage(resourceSearchPackage));
        filter.includePackage(resourceSearchPackage);
    }
    filter.includePackage(Repository.class.getPackage().getName());
    filter.includePackage(ResourceRepository.class.getPackage().getName());
    builder = builder.filterInputsBy(filter);

    builder = builder.addUrls(ClasspathHelper.forClass(Repository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepositoryV2.class));

    builder = builder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner());
    reflections = new Reflections(builder);
}

public void addLoader(ClassLoader loader) {
    if (builder == null) {
        this.builder = new ConfigurationBuilder();
        builder.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
    }
    builder.addClassLoader(loader);
    builder.addUrls(ClasspathHelper.forClassLoader(loader));

    if(loader instanceof JoinClassLoader) {
        // When the object "reflections" is created in the method scanClassPath(), are scanned the URLs so
        // it is necessary to add the URLs from the enclosing class loader in the JoinClassLoader that it
        // contains the fixture classpath (see org.reflections.Reflections.scan()).
        builder.addUrls(ClasspathHelper.forClassLoader(((JoinClassLoader) loader).getEnclosingClassLoader()));
    }

    scanClassPath(builder);
}

private static Set<Class<?>> getReflected() {
    synchronized (LOCK) {
        if (reflected != null) {
            return reflected;
        }
        Reflections reflections = new Reflections(new ConfigurationBuilder()
                .setUrls(ClasspathHelper.forPackage("com.jivesoftware"))
                .setScanners(new MethodAnnotationsScanner(), new TypeAnnotationsScanner()));
        Set<Class<?>> result = reflections.getTypesAnnotatedWith(Path.class);
        Set<Method> methods = reflections.getMethodsAnnotatedWith(Path.class);
        for (Method method : methods) {
            result.add(method.getDeclaringClass());
        }
        reflected = Collections.unmodifiableSet(result);
        return reflected;
    }
}

public synchronized void init(ServletContext context) {
    if (HANDLERS != null) {
        return;
    }
    LOG.info("Initializing output handlers...");
    Map<String, Class<? extends IOutputHandler>> handlers = new HashMap<>();
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .addUrls(ClasspathHelper.forWebInfLib(context))
            .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner(false)));
    Set<Class<?>> classes = reflections.getTypesAnnotatedWith(OutputHandler.class);
    for (Class<?> clazz : classes) {
        LOG.info("Found annotated output handler class: " + clazz.getName());
        if (IOutputHandler.class.isAssignableFrom(clazz)) {
            String id = clazz.getAnnotation(OutputHandler.class).id();
            //noinspection unchecked
            handlers.put(id, (Class<? extends IOutputHandler>)clazz);
            LOG.info("Added output handler " + id + " in class: " + clazz.getName());
        }
    }
    HANDLERS = handlers;
    LOG.info("Initialization of output handlers completed.");
}

public void test()
{
    final Reflections reflections = new Reflections(new ConfigurationBuilder()
            .addUrls(ClasspathHelper.forClassLoader())
            .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner())
            );

    final Set<Class<?>> classes_withValidator = reflections.getTypesAnnotatedWith(Validator.class);
    System.out.println("Found " + classes_withValidator.size() + " classes annotated with " + Validator.class);

    final Set<Class<?>> classes_withInterceptor = reflections.getTypesAnnotatedWith(Interceptor.class);
    System.out.println("Found " + classes_withInterceptor.size() + " classes annotated with " + Interceptor.class);

    final Set<Class<?>> classes = ImmutableSet.<Class<?>> builder()
            .addAll(classes_withValidator)
            .addAll(classes_withInterceptor)
            .build();
    System.out.println("=> " + classes.size() + " classes to test");

    for (final Class<?> clazz : classes)
    {
        testClass(clazz);
    }

    assertNoExceptions();
}

private void scanConceptsWithReflections() throws ObjectStoreConfigException {
    logger.debug("Search for concepts with reflections");
    Set<URL> classpath = new HashSet<>();
    classpath.addAll(ClasspathHelper.forClassLoader());
    classpath.addAll(ClasspathHelper.forJavaClassPath());
    classpath.addAll(ClasspathHelper.forManifest());
    classpath.addAll(ClasspathHelper.forPackage(""));
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(classpath)
.useParallelExecutor()
.filterInputsBy(FilterBuilder.parsePackages("-java, -javax, -sun, -com.sun"))
            .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()));

    Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Iri.class, true);
    logger.debug("Search for concepts with reflections resulted in " + annotated.size() + " classes");
    for (Class clazz : annotated) {
        logger.debug("Found concept class: " + clazz.getCanonicalName());
        roleMapper.addConcept(clazz);
    }
}

/**
 * Init stuff is responsible to grab all DTOs found in classpath (classloader) and setup model for
 * String Template
 */
protected void init() {

  ConfigurationBuilder configurationBuilder =
      new ConfigurationBuilder().setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
  if (useClassPath) {
    configurationBuilder.setUrls(forJavaClassPath());
  } else {
    configurationBuilder.setUrls(forClassLoader());
  }

  // keep only DTO interfaces
  Reflections reflections = new Reflections(configurationBuilder);
  List<Class<?>> annotatedWithDtos =
      new ArrayList<>(reflections.getTypesAnnotatedWith(DTO.class));
  List<Class<?>> interfacesDtos =
      annotatedWithDtos
          .stream()
          .filter(clazz -> clazz.isInterface())
          .collect(Collectors.toList());
  interfacesDtos.stream().forEach(this::analyze);
}

@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(ClasspathHelper.forPackage(basePackage)).setScanners(
                    new SubTypesScanner(), new TypeAnnotationsScanner()));

    Set<Class<?>> resources = reflections
            .getTypesAnnotatedWith(Resource.class);

    Set<Class<?>> apis = reflections
            .getTypesAnnotatedWith(ApiGateway.class);

    Map<String, EndpointResource> endpointResources = getEndpointResources(resources);
    String apiName = getApiName(apis);
    fileWriter.createSwaggerFile(new ArrayList<EndpointResource>(endpointResources.values()), apiName);

}

@SuppressWarnings("unchecked")
private void registerScriptEngineFactories() {
    List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner())
            .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("com.jsen"))));

    Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ScriptEngineFactory.class);

    for (Class<?> clazz : annotated) {
        if (AbstractScriptEngineFactory.class.isAssignableFrom(clazz)) {
            registerMimeContentFactory((Class<AbstractScriptEngineFactory>)clazz);  
        }
    }
}

/**
 * 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);
}

/**
 * Creates a {@link org.reflections.Reflections} with the given packages (configuration)
 *
 * @param scanPackages
 */
private void createReflections(String[] scanPackages) {
    if (scanPackages.length < 1) {
        LOGGER.warn("No package defined in configuration (scanPackages)!");
        return;
    }
    ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
    FilterBuilder filterBuilder = new FilterBuilder();
    for (String packageName : scanPackages) {
        configurationBuilder.addUrls(ClasspathHelper.forPackage(packageName));
        filterBuilder.include(FilterBuilder.prefix(packageName));
    }

    configurationBuilder.filterInputsBy(filterBuilder).setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
    this.reflections = new Reflections(configurationBuilder);

}

public void init() {

        packages = config.getConfig().getString("fuse.scan.packages");
        verbose  = config.getConfig().getBoolean("fuse.scan.verbose");

        if (!StringUtils.isEmpty(packages)) {

            // prepare reflections config builder
            ConfigurationBuilder builder = new ConfigurationBuilder();
            builder.addScanners(new TypeAnnotationsScanner());

            // add packages to scan
            Arrays.stream(packages.split(","))
                  .forEach(
                      name -> builder.addUrls(ClasspathHelper.forPackage(name))
                  );

            reflections = new Reflections(builder);
        }
    }

private Reflections buildReflections(String packages) {
    String[] packagesArray = packages.replaceAll(" ", "").split(",");

    FilterBuilder filter = new FilterBuilder();

    Set<URL> urls = new HashSet();

    for (String packageStr : packagesArray) {
        urls.addAll(ClasspathHelper.forPackage(packageStr));
        filter.include(FilterBuilder.prefix(packageStr));
    }

    return new Reflections(new ConfigurationBuilder()
            .addUrls(urls)
            .filterInputsBy(filter)
            .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner()));
}

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();
}

public static ArrayList<Class> getSubtypes(String rootPackage) {
    log.debug("------------ Getting all children of MOI from package: " + rootPackage);
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .filterInputsBy(new FilterBuilder.Include(FilterBuilder.prefix(rootPackage)))
            .setUrls(ClasspathHelper.forPackage(rootPackage))
            .setScanners(new SubTypesScanner(),
                    new TypeAnnotationsScanner(),
                    new ResourcesScanner()));
    ArrayList<Class> annoList = new ArrayList<Class>();
    annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true));
    log.debug("annoList.size()::" + annoList.size());
    ArrayList<Class> subTypesList = new ArrayList<Class>();
    subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class));
    log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList);
    subTypesList.removeAll(annoList);
    log.debug("getSubtypes: found types: " + subTypesList);
    return subTypesList;
}

public static ArrayList<Class> getSubtypes(Class rootClass) {
    log.debug("------------ Getting all children of MOI for class: " + rootClass.getCanonicalName());
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(ClasspathHelper.forClass(rootClass))
            .setScanners(new SubTypesScanner(),
                    new TypeAnnotationsScanner(),
                    new ResourcesScanner()));
    ArrayList<Class> annoList = new ArrayList<Class>();
    annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true));
    log.debug("annoList.size()::" + annoList.size());
    ArrayList<Class> subTypesList = new ArrayList<Class>();
    subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class));
    log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList);
    subTypesList.removeAll(annoList);
    log.debug("getSubtypes: found types: " + subTypesList);
    return subTypesList;
}

public void generateReport(String packageName,List<String> flagList) throws IOException
{

    URL testClassesURL = Paths.get("target/test-classes").toUri().toURL();

    URLClassLoader classLoader = URLClassLoader.newInstance(new URL[]{testClassesURL},
            ClasspathHelper.staticClassLoader());

    reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(ClasspathHelper.forPackage(packageName,classLoader))
            .addClassLoader(classLoader)
            .filterInputsBy(new FilterBuilder().includePackage(packageName))
            .setScanners(new MethodAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner())
    );


    List<Map<String, TestClass>> list = new ArrayList<>();

    for (String flag : flagList)
    {
        list.add(printMethods(flag));
    }

    Gson gson = new Gson();
    String overviewTemplate = IOUtils.toString(getClass().getResourceAsStream("/index.tpl.html"));


    String editedTemplate = overviewTemplate.replace("##TEST_DATA##", gson.toJson(list));

    FileUtils.writeStringToFile(new File("target/test-list-html-report/index.html"), editedTemplate);
    logger.info("report file generated");
}

public static Reflections getReflections(Class<?> appClass) {

        String packageName = appClass.getPackage().getName();

        return new Reflections(
                packageName,
                new SubTypesScanner(),
                new TypeAnnotationsScanner(),
                new FilterBuilder.Exclude(".*.xml")
        );
    }

public static boolean init() {
    LogUtils.infof("Initializing commands...");

    Reflections reflections = new Reflections(Shadbot.class.getPackage().getName(), new SubTypesScanner(), new TypeAnnotationsScanner());
    for(Class<?> cmdClass : reflections.getTypesAnnotatedWith(Command.class)) {
        if(!AbstractCommand.class.isAssignableFrom(cmdClass)) {
            LogUtils.errorf("An error occurred while generating command, %s cannot be cast to AbstractCommand.", cmdClass.getSimpleName());
            continue;
        }

        try {
            AbstractCommand cmd = (AbstractCommand) cmdClass.newInstance();

            List<String> names = cmd.getNames();
            if(!cmd.getAlias().isEmpty()) {
                names.add(cmd.getAlias());
            }

            for(String name : names) {
                if(COMMANDS_MAP.putIfAbsent(name, cmd) != null) {
                    LogUtils.errorf(String.format("Command name collision between %s and %s",
                            cmdClass.getSimpleName(), COMMANDS_MAP.get(name).getClass().getSimpleName()));
                    continue;
                }
            }
        } catch (InstantiationException | IllegalAccessException err) {
            LogUtils.errorf(err, "An error occurred while initializing command %s.", cmdClass.getDeclaringClass().getSimpleName());
            return false;
        }
    }

    LogUtils.infof("%s initialized.", StringUtils.pluralOf((int) COMMANDS_MAP.values().stream().distinct().count(), "command"));
    return true;
}

public Set<Class<?>> loadClasses() {
  Reflections reflections =
          new Reflections(
                  new ConfigurationBuilder()
                          .setUrls(ClasspathHelper.forPackage(packageToScan))
                          .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner())
                          .filterInputsBy(new FilterBuilder().includePackage(packageToScan)));

  Set<Class<?>> result = new LinkedHashSet<>();
  result.addAll(getClasses(reflections));
  return result;
}

@Override
    public ReflectionsWrapper configure() {
        reflections = (Reflections) cache.get(Reflections.class.getName());

        if (reflections == null) {
            ConfigurationBuilder cb = new ConfigurationBuilder();

            Set<URL> classLocations = new LinkedHashSet<>();

            try {
                List<URL> urls = Collections.list(Thread.currentThread().getContextClassLoader().getResources(""));

                for (URL url : urls) {
                    if (url.getPath().contains("/geemvc/target/")) {
                        classLocations.add(url);
                    }
                }
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }

            cb = cb.addUrls(classLocations).addClassLoader(Thread.currentThread().getContextClassLoader());
            cb = cb.setScanners(new ResourcesScanner(), new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new SubTypesScanner());
            reflections = cb.build();

//            Reflections cachedReflections = (Reflections)
              cache.putIfAbsent(Reflections.class.getName(), reflections);

//            if (cachedReflections != null)
//                reflections = cachedReflections;
        }

        return this;
    }

private static String getExceptionAdviceAnnotatedClassName() {
  Reflections reflections = new Reflections("", new TypeAnnotationsScanner());

  Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ExceptionAdvice.class,true);
  if (annotated.size() != 1) {
    return "";
  }
  Class<?> item = (Class<?>) annotated.toArray()[0];
  return item.getName();
}

private static String getExceptionAdviceAnnotatedClassName() {
  Reflections reflections = new Reflections("", new TypeAnnotationsScanner());

  Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ExceptionAdvice.class, true);
  if (annotated.size() != 1) {
    return "";
  }
  Class<?> item = (Class<?>) annotated.toArray()[0];
  declaredClass = item;
  return item.getName();
}

public static Set<Class<?>> getClassesWithAnnotation(final Class<? extends Annotation> annotation, final String[] packageNames) {
    final Reflections reflections;
    final Set<Class<?>> classes = new HashSet<>();
    final ConfigurationBuilder builder = new ConfigurationBuilder();
    for (final String packageName : packageNames) {
        builder.addUrls(ClasspathHelper.forPackage(packageName));
    }
    builder.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
    reflections = new Reflections(builder);
    classes.addAll(reflections.getTypesAnnotatedWith(annotation));
    return classes;
}

public QuikReflector() {
    this.reflections = new Reflections(
            new ConfigurationBuilder().setScanners(
                    new SubTypesScanner(),
                    new TypeAnnotationsScanner()
            ).forPackages("com", "net", "org")
    );
    this.registers = new QuikRegisterRegistry();
    this.domains = new QuikDomains();
}

/**
 * Scans the specified classpath for an annotation.
 * 
 * @param classpathUrls  the classpath, not null
 * @param annotationClassName  the annotation to find, not null
 * @return the matching elements, not null
 */
public static Set<String> scan(URL[] classpathUrls, String annotationClassName) {
  ArgumentChecker.notNull(annotationClassName, "annotationClassName");
  Set<URL> urls = new HashSet<>(Arrays.asList(classpathUrls));
  AnnotationReflector reflector = new AnnotationReflector(
      null, urls, new TypeAnnotationsScanner(),
      ClassNameAnnotationScannerUtils.class.getClassLoader(), Thread.currentThread().getContextClassLoader());
  Set<String> classNames = reflector.getReflector().getStore().getTypesAnnotatedWith(annotationClassName);
  if (classNames == null) {
    return Collections.emptySet();
  }
  return Collections.unmodifiableSet(classNames);
}

@Parameters(name= "{0}")
public static Collection<Object[]> getDomainClasses() {
    Reflections reflections = new Reflections(TestConstants.DOMAIN_PACKAGE, new SubTypesScanner(false), new TypeAnnotationsScanner());
    Collection<Object[]> classes = new ArrayList<Object[]>();
    for (Class<? extends Object> dclass:reflections.getTypesAnnotatedWith(Entity.class)) {

        classes.add(new Object[]{dclass});
    }
    return classes;
}

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);
    }
}

@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);
}

@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);
}

private void findDynaObjects() throws IOException {
  ConfigurationBuilder configuration = new ConfigurationBuilder();

  List<URL> urls = new ArrayList<>();
  for (String element : classpath) {
    urls.add(new File(element).toURI().toURL());
  }

  ClassLoader contextClassLoader =
      URLClassLoader.newInstance(
          urls.toArray(new URL[urls.size()]), Thread.currentThread().getContextClassLoader());
  Thread.currentThread().setContextClassLoader(contextClassLoader);
  configuration.setUrls(ClasspathHelper.forClassLoader(contextClassLoader));
  configuration.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
  Reflections reflection = new Reflections(configuration);

  Set<Class<?>> classes = reflection.getTypesAnnotatedWith(DynaObject.class);
  for (Class clazz : classes) {
    // accept only classes
    if (clazz.isEnum() || clazz.isInterface() || clazz.isAnnotation()) {
      continue;
    }
    dynaClasses.add(new ClassModel(clazz));
    System.out.println(String.format("New Dyna Object Found: %s", clazz.getCanonicalName()));
  }
  System.out.println(String.format("Found: %d Dyna Objects", dynaClasses.size()));
}

@Override
public void afterPropertiesSet() throws Exception {


    final Map<String, Object> nanaClients = ((ListableBeanFactory) applicationContext)
            .getBeansWithAnnotation((Class<? extends Annotation>) EntityRestService.class);
    for (final Object myClient : nanaClients.values()) {
        final Class<? extends Object>clientClass = myClient.getClass();
        final EntityRestService annotation = clientClass
                .getAnnotation(EntityRestService.class);
        System.out.println(String.format("Found class %s\n",clientClass.getName() ));
    }

    Predicate<String> myClassAnnotationsFilter = new Predicate<String>() {

        @Override
        public boolean apply(String arg0) {
            return true;
        }
    };
    final Reflections reflections = new Reflections(
                       new ConfigurationBuilder()
                           .filterInputsBy(new FilterBuilder().include("example.api"))
                           .setUrls(ClasspathHelper.forClassLoader())
                           .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner().filterResultsBy(myClassAnnotationsFilter)));

    Set<Class<?>> theFoos = reflections.getTypesAnnotatedWith(EntityRestService.class);
    System.out.println(theFoos.size());
    for(Class<?> eachFoo : theFoos)
    {
        System.out.println(String.format("Found class %s\n",eachFoo.getName() ));
        ;
    }
}

@Override
public void autoSetup(String packageName) {

    List<ClassLoader> classLoadersList = Lists.newArrayList();
    ClassLoader contextClassLoader = ClasspathHelper.contextClassLoader();
    classLoadersList.add(contextClassLoader);

    ClassLoader staticClassLoader = ClasspathHelper.staticClassLoader();
    if (staticClassLoader != contextClassLoader) {
        classLoadersList.add(staticClassLoader);
    }

    // formatter: off
    ConfigurationBuilder configuration = new ConfigurationBuilder()
        .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner())
        .addClassLoaders(classLoadersList)
        .setUrls(ClasspathHelper.forPackage(packageName));
    // formatter: on
    Reflections reflections = new Reflections(configuration);

    Set<Class<?>> collections =
        reflections.getTypesAnnotatedWith(io.seventyone.mongoutils.annotations.MongoCollection.class);
    collections.forEach(c -> {
        io.seventyone.mongoutils.annotations.MongoCollection annotation;
        annotation = c.getAnnotation(io.seventyone.mongoutils.annotations.MongoCollection.class);
        if (annotation.noAutoSetup() == false) {
            this.setupCollection(c, annotation.value());
        }
    });
}

@Override
public void populateEntityDictionary(EntityDictionary dictionary) {
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .addUrls(ClasspathHelper.forPackage(beanPackage.getName()))
            .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()));
    reflections.getTypesAnnotatedWith(Entity.class).stream()
            .filter(entityAnnotatedClass -> entityAnnotatedClass.getPackage().getName()
                    .startsWith(beanPackage.getName()))
            .forEach(dictionary::bindEntity);
}

@Override
public void populateEntityDictionary(EntityDictionary dictionary) {
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .addUrls(ClasspathHelper.forPackage(beanPackage.getName()))
            .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()));
    reflections.getTypesAnnotatedWith(Entity.class).stream()
            .filter(entityAnnotatedClass -> entityAnnotatedClass.getPackage().getName()
                    .startsWith(beanPackage.getName()))
            .forEach((cls) -> {
                dictionary.bindEntity(cls);
                dataStore.put(cls, Collections.synchronizedMap(new LinkedHashMap<>()));
            });
    this.dictionary = dictionary;
}

/**
 * Get all the entities in a package.
 *
 * @param packageName Package name
 * @return All entities found in package.
 */
public static HashSet<Class> getAllEntities(String packageName) {
    return new HashSet<>(new Reflections(new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner())
            .setUrls(ClasspathHelper.forClassLoader(ClassLoader.getSystemClassLoader()))
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName))))
            .getTypesAnnotatedWith(Entity.class));
}

/**
 * Looks for classes annotated with a given annotation.
 *
 * @param annotation an annotation to look for
 * @param bundle a bundle to look in.
 * @return A list of classes, annotated with the given annotation
 */
public static Set<Class<?>> getClasses(Class<? extends Annotation> annotation, Bundle bundle) {
    LOGGER.debug("Scanning bundle: {}", bundle.getSymbolicName());
    LOGGER.debug("Searching for classes with annotations: {}", annotation.getName());

    Reflections reflections = configureReflection(bundle, new PristineBundleClassLoader(bundle),
            new TypeAnnotationsScanner(), new SubTypesScanner());

    Set<Class<?>> classes = reflections.getTypesAnnotatedWith(annotation);

    // in order to prevent processing of user defined or auto generated fields
    // we have to load the bytecode from the jar and define the class in a temporary
    // classLoader
    PristineBundleClassLoader pristineBundleClassLoader = new PristineBundleClassLoader(bundle);

    Set<Class<?>> result = new HashSet<>();
    for (Class clazz : classes) {
        try {
            result.add(pristineBundleClassLoader.loadClass(clazz.getName()));
        } catch (ClassNotFoundException e) {
            LOGGER.error("Could not find class", e);
        }
    }

    LOGGER.debug("Searched for classes with annotations: {}", annotation.getName());
    LOGGER.trace("Found {} classes with annotations: {}", result.size(), annotation.getName());

    return result;
}

@GET
@Path("getclasses")
public List<GenericClassDescription> getSupportedClasses() {
    List<GenericClassDescription> classes=new ArrayList<GenericClassDescription>();

    Reflections reflections = new Reflections(
            new ConfigurationBuilder().setUrls(ClasspathHelper.forPackage("cm.homeautomation")).setScanners(
                    new SubTypesScanner(), new TypeAnnotationsScanner(), new MethodAnnotationsScanner()));

    // MethodAnnotationsScanner
    Set<Class<?>> typesAnnotatedWith = reflections.getTypesAnnotatedWith(Entity.class);

    for (Class<?> declaringClass : typesAnnotatedWith) {
        GenericClassDescription clazz=new GenericClassDescription();
        clazz.setName(declaringClass.getName());

        Field[] fields = declaringClass.getDeclaredFields();
        for (Field field : fields) {
            clazz.getFields().put(field.getName(), field.getType().getSimpleName());
        }

        /*Method[] methods = declaringClass.getDeclaredMethods();
        for (Method method : methods) {
            clazz.getMethods().put(method.getName(), method.getParameters());
        }*/


        classes.add(clazz);
    }

    return classes;
}