How to use

PackageScanClassResolver

in

org.apache.camel.spi

/**
 * Appends all the {@link org.apache.camel.builder.RouteBuilder} instances that can be found on the classpath
 */
public void appendBuilders(List<RoutesBuilder> list) throws IllegalAccessException, InstantiationException {
  Set<Class<?>> classes = resolver.findImplementations(RoutesBuilder.class, packages);
  for (Class<?> aClass : classes) {
    LOG.trace("Found RouteBuilder class: {}", aClass);
    // certain beans should be ignored
    if (shouldIgnoreBean(aClass)) {
      LOG.debug("Ignoring RouteBuilder class: {}", aClass);
      continue;
    }
    if (!isValidClass(aClass)) {
      LOG.debug("Ignoring invalid RouteBuilder class: {}", aClass);
      continue;
    }
    // type is valid so create and instantiate the builder
    @SuppressWarnings("unchecked")
    RoutesBuilder builder = instantiateBuilder((Class<? extends RoutesBuilder>) aClass);
    if (beanPostProcessor != null) {
      // Inject the annotated resource
      beanPostProcessor.postProcessBeforeInitialization(builder, builder.toString());
    }
    LOG.debug("Adding instantiated RouteBuilder: {}", builder);
    list.add(builder);
  }
}

public PackageScanRouteBuilderFinder(SpringCamelContext camelContext, String[] packages, ClassLoader classLoader,
                   BeanPostProcessor postProcessor, PackageScanClassResolver resolver) {
  this.camelContext = camelContext;
  this.applicationContext = camelContext.getApplicationContext();
  this.packages = packages;
  this.beanPostProcessor = postProcessor;
  this.resolver = resolver;
  // add our provided loader as well
  resolver.addClassLoader(classLoader);
}

@Override
protected void findRouteBuildersByPackageScan(String[] packages, PackageScanFilter filter, List<RoutesBuilder> builders) throws Exception {
  // add filter to class resolver which then will filter
  getContext().getPackageScanClassResolver().addFilter(filter);
  PackageScanRouteBuilderFinder finder = new PackageScanRouteBuilderFinder(getContext(), packages, getContextClassLoaderOnStart(),
                                       getBeanPostProcessor(), getContext().getPackageScanClassResolver());
  finder.appendBuilders(builders);
  // and remove the filter
  getContext().getPackageScanClassResolver().removeFilter(filter);
}

public Set<Class<?>> loadModels(String... packageNames) throws Exception {
  Set<Class<?>> results = resolver.findAnnotated(annotations, packageNames);
  
  //TODO;  this logic could be moved into the PackageScanClassResolver by creating:
  //          findAnnotated(annotations, packageNames, filter) 
  Set<Class<?>> resultsToRemove = new HashSet<>();
  if (filter != null) {
    for (Class<?> clazz : results) {
      if (!filter.matches(clazz)) {
        resultsToRemove.add(clazz);
      }
    }
  }
  results.removeAll(resultsToRemove);
  return results;
}

@Override
protected void findRouteBuildersByPackageScan(String[] packages, PackageScanFilter filter, List<RoutesBuilder> builders) throws Exception {
  // add filter to class resolver which then will filter
  getContext().getPackageScanClassResolver().addFilter(filter);
  ClassLoader classLoader = new BundleDelegatingClassLoader(bundleContext.getBundle());
  PackageScanRouteBuilderFinder finder = new PackageScanRouteBuilderFinder(getContext(), packages, classLoader,
                                       getContext().getPackageScanClassResolver());
  finder.appendBuilders(builders);
  // and remove the filter
  getContext().getPackageScanClassResolver().removeFilter(filter);
}

/**
 * Appends all the {@link org.apache.camel.builder.RouteBuilder} instances that can be found on the classpath
 */
public void appendBuilders(List<RoutesBuilder> list) throws IllegalAccessException, InstantiationException {
  Set<Class<?>> classes = resolver.findImplementations(RoutesBuilder.class, packages);
  for (Class<?> aClass : classes) {
    LOG.trace("Found RouteBuilder class: {}", aClass);
    // certain beans should be ignored
    if (shouldIgnoreBean(aClass)) {
      LOG.debug("Ignoring RouteBuilder class: {}", aClass);
      continue;
    }
    if (!isValidClass(aClass)) {
      LOG.debug("Ignoring invalid RouteBuilder class: {}", aClass);
      continue;
    }
    // type is valid so create and instantiate the builder
    RoutesBuilder builder = instantiateBuilder(aClass);
    LOG.debug("Adding instantiated RouteBuilder: {}", builder);
    list.add(builder);
  }
}

PackageScanRouteBuilderFinder(CamelContext camelContext, String[] packages, ClassLoader classLoader, PackageScanClassResolver resolver) {
  this.camelContext = camelContext;
  this.packages = packages;
  this.resolver = resolver;
  resolver.addClassLoader(classLoader);
}

@Override
protected void findRouteBuildersByPackageScan(String[] packages, PackageScanFilter filter, List<RoutesBuilder> builders) throws Exception {
  // add filter to class resolver which then will filter
  getContext().getPackageScanClassResolver().addFilter(filter);
  PackageScanRouteBuilderFinder finder = new PackageScanRouteBuilderFinder(getContext(), packages, getContextClassLoaderOnStart(), getContext().getPackageScanClassResolver());
  finder.appendBuilders(builders);
  // and remove the filter
  getContext().getPackageScanClassResolver().removeFilter(filter);
}

/**
 * Appends all the {@link org.apache.camel.builder.RouteBuilder} instances that can be found on the classpath
 */
void appendBuilders(List<RoutesBuilder> list) throws IllegalAccessException, InstantiationException {
  Set<Class<?>> classes = resolver.findImplementations(RoutesBuilder.class, packages);
  for (Class<?> aClass : classes) {
    logger.trace("Found RouteBuilder class: {}", aClass);
    // certain beans should be ignored
    if (shouldIgnoreBean(aClass)) {
      logger.debug("Ignoring RouteBuilder class: {}", aClass);
      continue;
    }
    if (!isValidClass(aClass)) {
      logger.debug("Ignoring invalid RouteBuilder class: {}", aClass);
      continue;
    }
    // type is valid so create and instantiate the builder
    @SuppressWarnings("unchecked")
    RoutesBuilder builder = instantiateBuilder((Class<? extends RoutesBuilder>) aClass);
    logger.debug("Adding instantiated RouteBuilder: {}", builder);
    list.add(builder);
  }
}

public PackageScanRouteBuilderFinder(BlueprintCamelContext camelContext, String[] packages, ClassLoader classLoader,
                   PackageScanClassResolver resolver) {
  this.camelContext = camelContext;
  this.blueprintContainer = camelContext.getBlueprintContainer();
  this.packages = packages;
  this.resolver = resolver;
  // add our provided loader as well
  resolver.addClassLoader(classLoader);
}

Set<Class<?>> classes = camelContext.getPackageScanClassResolver().findImplementations(RouteBuilder.class, path);
if (!classes.isEmpty()) {
  Set<RouteBuilder> builders = new LinkedHashSet<>();