public enum PluginCapabilityState {
    SUPPORTED,
    UNSUPPORTED
}

public interface PluginInterface {
    String pluginUniqueName();

    String version();

    Map<String, PluginCapabilityState> capabilities();
}

public interface PluginEndpointSender extends PluginInterface {
    boolean send(PluginEndpointData message);
}

public interface PluginManager {
    boolean isCapabilitySupported(String pluginName, String capability);

    <T extends PluginInterface> T getPlugin(Class<? extends PluginInterface> pluginClass);
}

Platform.getReflections().getSubTypesOf(PluginInterface.class).forEach(clz -> {
    if (!clz.getCanonicalName().contains("org.zstack.abstraction")
            || !clz.isInterface()) {
        return;
    }

    if (interfaceMetadata.contains(clz)) {
        throw new CloudRuntimeException(
                String.format("duplicate PluginProtocol[name: %s]", clz));
    }

    interfaceMetadata.add(clz);
});

interfaceMetadata.forEach(clz -> Platform.getReflections().getSubTypesOf(clz)
        .forEach(pluginInstanceClz -> {
    try {
        PluginInterface pluginInterface = pluginInstanceClz.getConstructor().newInstance();
        if (pluginInstances.containsKey(pluginInterface.pluginUniqueName())) {
            throw new CloudRuntimeException(String.format("duplicate plugin[class: %s]",
                    pluginInstanceClz));
        }

        pluginInstances.put(pluginInstanceClz, pluginInterface);
        logger.debug(String.format("load plugin: %s, name: %s,  capabilities: \n %s",
                pluginInterface.version(),
                pluginInterface.pluginUniqueName(),
                JSONObjectUtil.toJsonString(pluginInterface.capabilities())));
    } catch (Exception e) {
        throw new CloudRuntimeException(e);
    }
}));

public static Reflections reflections = new Reflections(ClasspathHelper.forPackage("org.zstack"),
        new SubTypesScanner(), new MethodAnnotationsScanner(), new FieldAnnotationsScanner(),
        new TypeAnnotationsScanner(), new MethodParameterScanner());

protected void scan(URL url) {
    Vfs.Dir dir = Vfs.fromURL(url);

    try {
        for (final Vfs.File file : dir.getFiles()) {
            // scan if inputs filter accepts file relative path or fqn
            Predicate<String> inputsFilter = configuration.getInputsFilter();
            String path = file.getRelativePath();
            String fqn = path.replace('/', '.');
            if (inputsFilter == null || inputsFilter.apply(path) || inputsFilter.apply(fqn)) {
                Object classObject = null;
                for (Scanner scanner : configuration.getScanners()) {
                    try {
                        if (scanner.acceptsInput(path) || scanner.acceptResult(fqn)) {
                            classObject = scanner.scan(file, classObject);
                        }
                    } catch (Exception e) {
                        if (log != null && log.isDebugEnabled())
                            log.debug("could not scan file " + file.getRelativePath() + " in url " + url.toExternalForm() + " with scanner " + scanner.getClass().getSimpleName(), e.getMessage());
                    }
                }
            }
        }
    } finally {
        dir.close();
    }
}

public class FieldAnnotationsScanner extends AbstractScanner {
    public void scan(final Object cls) {
        final String className = getMetadataAdapter().getClassName(cls);
        List<Object> fields = getMetadataAdapter().getFields(cls);
        for (final Object field : fields) {
            List<String> fieldAnnotations = getMetadataAdapter().getFieldAnnotationNames(field);
            for (String fieldAnnotation : fieldAnnotations) {

                if (acceptResult(fieldAnnotation)) {
                    String fieldName = getMetadataAdapter().getFieldName(field);
                    getStore().put(fieldAnnotation, String.format("%s.%s", className, fieldName));
                }
            }
        }
    }
}

public class SubTypesScanner extends AbstractScanner {

    /** created new SubTypesScanner. will exclude direct Object subtypes */
    public SubTypesScanner() {
        this(true); //exclude direct Object subtypes by default
    }

    /** created new SubTypesScanner.
     * @param excludeObjectClass if false, include direct {@link Object} subtypes in results.  */
    public SubTypesScanner(boolean excludeObjectClass) {
        if (excludeObjectClass) {
            filterResultsBy(new FilterBuilder().exclude(Object.class.getName())); //exclude direct Object subtypes
        }
    }

    @SuppressWarnings({"unchecked"})
    public void scan(final Object cls) {
		String className = getMetadataAdapter().getClassName(cls);
		String superclass = getMetadataAdapter().getSuperclassName(cls);

        if (acceptResult(superclass)) {
            getStore().put(superclass, className);
        }

		for (String anInterface : (List<String>) getMetadataAdapter().getInterfacesNames(cls)) {
			if (acceptResult(anInterface)) {
                getStore().put(anInterface, className);
            }
        }
    }
}

public class MethodAnnotationsScanner extends AbstractScanner {
    public void scan(final Object cls) {
        for (Object method : getMetadataAdapter().getMethods(cls)) {
            for (String methodAnnotation : (List<String>) getMetadataAdapter().getMethodAnnotationNames(method)) {
                if (acceptResult(methodAnnotation)) {
                    getStore().put(methodAnnotation, getMetadataAdapter().getMethodFullKey(cls, method));
                }
            }
        }
    }
}

public class TypeAnnotationsScanner extends AbstractScanner {
    public void scan(final Object cls) {
      final String className = getMetadataAdapter().getClassName(cls);

        for (String annotationType : (List<String>) getMetadataAdapter().getClassAnnotationNames(cls)) {

            if (acceptResult(annotationType) ||
                annotationType.equals(Inherited.class.getName())) { //as an exception, accept Inherited as well
                getStore().put(annotationType, className);
            }
        }
    }

}

public class MethodParameterScanner extends AbstractScanner {

    @Override
    public void scan(Object cls) {
        final MetadataAdapter md = getMetadataAdapter();

        for (Object method : md.getMethods(cls)) {

            String signature = md.getParameterNames(method).toString();
            if (acceptResult(signature)) {
                getStore().put(signature, md.getMethodFullKey(cls, method));
            }

            String returnTypeName = md.getReturnTypeName(method);
            if (acceptResult(returnTypeName)) {
                getStore().put(returnTypeName, md.getMethodFullKey(cls, method));
            }

            List<String> parameterNames = md.getParameterNames(method);
            for (int i = 0; i < parameterNames.size(); i++) {
                for (Object paramAnnotation : md.getParameterAnnotationNames(method, i)) {
                    if (acceptResult((String) paramAnnotation)) {
                        getStore().put((String) paramAnnotation, md.getMethodFullKey(cls, method));
                    }
                }
            }
        }
    }
}

 public boolean acceptsInput(String file) {
     return getMetadataAdapter().acceptsInput(file);
 }
 
 public boolean acceptResult(final String fqn) {
   return fqn != null && resultFilter.apply(fqn);
}

public SubTypesScanner(boolean excludeObjectClass) {
    if (excludeObjectClass) {
        filterResultsBy(new FilterBuilder().exclude(Object.class.getName())); //exclude direct Object subtypes
    }
}

(configuration.isParallel() ? urls.stream().parallel() : urls.stream()).forEach(url -> {
    Vfs.Dir dir = null;
    try {
        dir = Vfs.fromURL(url);
        for (Vfs.File file : dir.getFiles()) {
            if (doFilter(file, configuration.getInputsFilter())) {
                ClassFile classFile = null;
                for (Scanner scanner : configuration.getScanners()) {
                    try {
                        if (doFilter(file, scanner::acceptsInput)) {
                            List<Map.Entry<String, String>> entries = scanner.scan(file);
                            if (entries == null) {
                                if (classFile == null) classFile = getClassFile(file);
                                entries = scanner.scan(classFile);
                            }
                            if (entries != null) collect.get(scanner.index()).addAll(entries);
                        }
                    } catch (Exception e) {
                        if (log != null) log.trace("could not scan file {} with scanner {}", file.getRelativePath(), scanner.getClass().getSimpleName(), e);
                    }
                }
            }
        }
    } catch (Exception e) {
        if (log != null) log.warn("could not create Vfs.Dir from url. ignoring the exception and continuing", e);
    } finally {
        if (dir != null) dir.close();
    }
});

public enum Scanners implements Scanner, QueryBuilder, NameHelper {

    /** scan type superclasses and interfaces
     * <p></p>
     * <i>Note that {@code Object} class is excluded by default, in order to reduce store size.
     * <br>Use {@link #filterResultsBy(Predicate)} to change, for example {@code SubTypes.filterResultsBy(c -> true)}</i>
     * */
    SubTypes {
        /* Object class is excluded by default from subtypes indexing */
        { filterResultsBy(new FilterBuilder().excludePattern("java\\.lang\\.Object")); }

        @Override
        public void scan(ClassFile classFile, List<Map.Entry<String, String>> entries) {
            entries.add(entry(classFile.getSuperclass(), classFile.getName()));
            entries.addAll(entries(Arrays.asList(classFile.getInterfaces()), classFile.getName()));
        }
    },

    /** scan method annotations */
    MethodsAnnotated {
        @Override
        public void scan(ClassFile classFile, List<Map.Entry<String, String>> entries) {
            getMethods(classFile).forEach(method ->
                entries.addAll(entries(getAnnotations(method::getAttribute), methodName(classFile, method))));
        }
    },
    
    /** scan field annotations */
    FieldsAnnotated {
        @Override
        public void scan(ClassFile classFile, List<Map.Entry<String, String>> entries) {
            classFile.getFields().forEach(field ->
                entries.addAll(entries(getAnnotations(field::getAttribute), fieldName(classFile, field))));
        }
    },

    /** scan type annotations */
    TypesAnnotated {
        @Override
        public boolean acceptResult(String annotation) {
            return super.acceptResult(annotation) || annotation.equals(Inherited.class.getName());
        }

        @Override
        public void scan(ClassFile classFile, List<Map.Entry<String, String>> entries) {
            entries.addAll(entries(getAnnotations(classFile::getAttribute), classFile.getName()));
        }
    },

    /** scan method parameters types and annotations */
    MethodsParameter {
        @Override
        public void scan(ClassFile classFile, List<Map.Entry<String, String>> entries) {
            getMethods(classFile).forEach(method -> {
                String value = methodName(classFile, method);
                entries.addAll(entries(getParameters(method), value));
                getParametersAnnotations(method).forEach(annotations -> entries.addAll(entries(annotations, value)));
            });
        }
    },

for (Scanner scanner : configuration.getScanners()) {
    try {
        if (doFilter(file, scanner::acceptsInput)) {
            List<Map.Entry<String, String>> entries = scanner.scan(file);
            if (entries == null) {
                if (classFile == null) classFile = getClassFile(file);
                entries = scanner.scan(classFile);
            }
            if (entries != null) collect.get(scanner.index()).addAll(entries);
        }
    } catch (Exception e) {
        if (log != null) log.trace("could not scan file {} with scanner {}", file.getRelativePath(), scanner.getClass().getSimpleName(), e);
    }
}

package org.zstack;

import org.reflections.Reflections;
import org.reflections.scanners.*;
import org.reflections.util.ClasspathHelper;

import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.util.Set;

public class TestReflections {
    public static void main(String[] args) throws IOException {
        System.out.println("==========================");
        printLoadedClasses(null);
        System.out.println("==========================");


        // reflections 0.9.10
        Reflections reflections = new Reflections(ClasspathHelper.forPackage("org.zstack"),
            new SubTypesScanner(false), new MethodAnnotationsScanner(), new FieldAnnotationsScanner(),
            new TypeAnnotationsScanner(), new MethodParameterScanner());

        // reflections 0.10.2
//        Reflections reflections = new Reflections(ClasspathHelper.forPackage("org.zstack"),
//            new SubTypesScanner(false), new MethodAnnotationsScanner(), new FieldAnnotationsScanner(),
//            new TypeAnnotationsScanner(), new MethodParameterScanner());

        System.out.println("==========================");
        printLoadedClasses(reflections);
        System.out.println("==========================");
    }

    private static void printLoadedClasses(Reflections reflections) throws IOException {
        if (reflections != null) {
            Set<String> types = reflections.getAllTypes();

            types.forEach(System.out::println);

            System.out.println("loaded class number from reflection: " + types.size());
        }

        System.out.println("loaded class number from jmx: " + ManagementFactory.getClassLoadingMXBean().getLoadedClassCount());
    }
}

// reflections 0.10.2
ConfigurationBuilder builder = ConfigurationBuilder.build()
        .setUrls(ClasspathHelper.forPackage("org.zstack"))
        .setScanners(new SubTypesScanner(false),
                new MethodAnnotationsScanner(),
                new FieldAnnotationsScanner(),
                new TypeAnnotationsScanner(),
                new MethodParameterScanner())
        .setExpandSuperTypes(false)
        .filterInputsBy(new FilterBuilder().includePackage("org.zstack"));
Reflections reflections = new Reflections(builder);

// SubTypes
// reflections 0.10.2
entries.add(this.entry(classFile.getSuperclass(), classFile.getName()));
entries.addAll(this.entries(Arrays.asList(classFile.getInterfaces()), classFile.getName()));

// reflections 0.9.10
filterResultsBy(new FilterBuilder().exclude(Object.class.getName())); //exclude direct Object subtypes

String className = getMetadataAdapter().getClassName(cls);
String superclass = getMetadataAdapter().getSuperclassName(cls);

if (acceptResult(superclass)) {
    getStore().put(superclass, className);
}

for (String anInterface : (List<String>) getMetadataAdapter().getInterfacesNames(cls)) {
		if (acceptResult(anInterface)) {
        getStore().put(anInterface, className);
    }
}

if (inputsFilter == null || inputsFilter.apply(path) || inputsFilter.apply(fqn)) {
    Object classObject = null;
    for (Scanner scanner : configuration.getScanners()) {
        try {
            if (scanner.acceptsInput(path) || scanner.acceptResult(fqn)) {
                classObject = scanner.scan(file, classObject);
            }
        } catch (Exception e) {
            if (log != null && log.isDebugEnabled())
                log.debug("could not scan file " + file.getRelativePath() + " in url " + url.toExternalForm() + " with scanner " + scanner.getClass().getSimpleName(), e.getMessage());
        }
    }
}

for (Scanner scanner : configuration.getScanners()) {
    try {
        if (doFilter(file, scanner::acceptsInput)) {
            List<Map.Entry<String, String>> entries = scanner.scan(file);
            if (entries == null) {
                if (classFile == null) classFile = getClassFile(file);
                entries = scanner.scan(classFile);
            }
            if (entries != null) collect.get(scanner.index()).addAll(entries);
        }
    } catch (Exception e) {
        if (log != null) log.trace("could not scan file {} with scanner {}", file.getRelativePath(), scanner.getClass().getSimpleName(), e);
    }
}

public Set<String> getAllTypes() {
    Set<String> allTypes = Sets.newHashSet(store.getAll(index(SubTypesScanner.class), Object.class.getName()));
    if (allTypes.isEmpty()) {
        throw new ReflectionsException("Couldn't find subtypes of Object. " +
                "Make sure SubTypesScanner initialized to include Object class - new SubTypesScanner(false)");
    }
    return allTypes;
}

public Set<String> getAll(Scanner scanner) {
    Map<String, Set<String>> map = store.getOrDefault(scanner.index(), Collections.emptyMap());
    return Stream.concat(map.keySet().stream(), map.values().stream().flatMap(Collection::stream)).collect(Collectors.toCollection(LinkedHashSet::new));
}

ConfigurationBuilder builder = ConfigurationBuilder.build()
        .setUrls(ClasspathHelper.forPackage("org.zstack"))
        .setScanners(new SubTypesScanner(false),
                new MethodAnnotationsScanner(),
                new FieldAnnotationsScanner(),
                new TypeAnnotationsScanner(),
                new MethodParameterScanner())
        .setExpandSuperTypes(false)
        .filterInputsBy(new FilterBuilder().includePackage("org.zstack"));
Reflections reflections = new Reflections(builder);