示例#1
0
 /**
  * Scans for factory plug-ins of the given category, with guard against recursivities. The
  * recursivity check make debugging easier than inspecting a {@link StackOverflowError}.
  *
  * @param loader The class loader to use.
  * @param category The category to scan for plug-ins.
  */
 private <T> void scanForPlugins(final Collection<ClassLoader> loaders, final Class<T> category) {
   if (!scanningCategories.addAndCheck(category)) {
     throw new RecursiveSearchException(category);
   }
   try {
     final StringBuilder message = getLogHeader(category);
     boolean newServices = false;
     /*
      * First, scan META-INF/services directories (the default mechanism).
      */
     for (final ClassLoader loader : loaders) {
       newServices |= register(lookupProviders(category, loader), category, message);
       newServices |= registerFromSystemProperty(loader, category, message);
     }
     /*
      * Next, query the user-provider iterators, if any.
      */
     final FactoryIteratorProvider[] fip = FactoryIteratorProviders.getIteratorProviders();
     for (int i = 0; i < fip.length; i++) {
       final Iterator<T> it = fip[i].iterator(category);
       if (it != null) {
         newServices |= register(it, category, message);
       }
     }
     /*
      * Finally, log the list of registered factories.
      */
     if (newServices) {
       log("scanForPlugins", message);
     }
   } finally {
     scanningCategories.removeAndCheck(category);
   }
 }
示例#2
0
 /**
  * Synchronizes the content of the {@link #globalConfiguration} with {@link
  * FactoryIteratorProviders#GLOBAL}. New providers are {@linkplain #register registered}
  * immediately. Note that this method is typically invoked in a different thread than {@link
  * FactoryIteratorProviders} method calls.
  *
  * @see FactoryIteratorProviders#addFactoryIteratorProvider
  */
 private void synchronizeIteratorProviders() {
   final FactoryIteratorProvider[] newProviders =
       globalConfiguration.synchronizeIteratorProviders();
   if (newProviders == null) {
     return;
   }
   for (final Iterator<Class<?>> categories = getCategories(); categories.hasNext(); ) {
     final Class<?> category = categories.next();
     if (needScanForPlugins == null || !needScanForPlugins.contains(category)) {
       /*
        * Register immediately the factories only if some other factories were already
        * registered for this category,  because in such case scanForPlugin() will not
        * be invoked automatically. If no factory are registered for this category, do
        * nothing - we will rely on the lazy invocation of scanForPlugins() when first
        * needed. We perform this check because getServiceProviders(category).hasNext()
        * is the criterion used by FactoryRegistry in order to decide if it should invoke
        * automatically scanForPlugins().
        */
       for (int i = 0; i < newProviders.length; i++) {
         register(newProviders[i], category);
       }
     }
   }
 }