获取指定包下所有接口实现类

package com.i2stream.util;

import org.apache.commons.lang3.time.DateParser;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.io.File;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class PackageScanUtil {
    private static final Logger LOG = LogManager.getLogger(PackageScanUtil.class);
    private static final ClassLoader classLoader = PackageScanUtil.class.getClassLoader();

    public static void main(String[] args) {
        final List<Class<?>> classes = PackageScanUtil.addClass("org.apache.commons.lang3.time", DateParser.class);
        if (classes != null) {
            classes.forEach(cl -> System.out.println(cl.getName()));
        }
    }

    /**
     * Get all the classes under the package that implement the superStrategy and add them to the list
     */
    public static List<Class<?>> addClass(String classPath, Class<?> superStrategy) {
        URL url = classLoader.getResource(classPath.replace(".", "/"));
        if (url == null) {
            LOG.error("{} can not be found", classPath);
            return null;
        }
        String protocol = url.getProtocol();
        if ("file".equals(protocol)) {
            return findLocalClass(classPath, superStrategy);
        } else if ("jar".equals(protocol)) {
            return findJarClass(classPath, superStrategy);
        } else {
            LOG.error("unknown protocol: {}", classPath);
            return null;
        }
    }

    /**
     * find class at local
     */
    private static List<Class<?>> findLocalClass(final String classPath, Class<?> superStrategy) {
        List<Class<?>> eleStrategyList = new ArrayList<>();
        URI uri;
        try {
            URL url = classLoader.getResource(classPath.replace(".", "/"));
            if (url == null) {
                LOG.error("{} can not be found", classPath);
                return null;
            } else {
                uri = url.toURI();
            }
        } catch (URISyntaxException e1) {
            LOG.error("{} can not be found", classPath);
            return eleStrategyList;
        }

        File file = new File(uri);
        final File[] files = file.listFiles(chiFile -> {
            if (chiFile.isDirectory()) {
                findLocalClass(classPath + "." + chiFile.getName(), superStrategy);
            }
            if (chiFile.getName().endsWith(".class")) {
                Class<?> clazz;
                try {
                    clazz = classLoader.loadClass(classPath + "." + chiFile.getName().replace(".class", ""));
                } catch (ClassNotFoundException e) {
                    return false;
                }
                if (clazz != null && superStrategy.isAssignableFrom(clazz) && !superStrategy.getName().equals(clazz.getName())) {
                    eleStrategyList.add(clazz);
                    return true;
                }
            }
            return false;
        });
        if (files != null && LOG.isTraceEnabled()) {
            LOG.trace("add class:{}", Arrays.toString(files));
        }
        return eleStrategyList;
    }

    /**
     * find class tat jar file
     */
    private static List<Class<?>> findJarClass(String classPath, Class<?> superStrategy) {
        List<Class<?>> eleStrategyList = new ArrayList<>();
        String pathName = classPath.replace(".", "/");
        JarFile jarFile;
        URL url = classLoader.getResource(pathName);
        if (url == null) {
            LOG.error("{} can not be found", classPath);
            return null;
        }
        try {
            JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
            jarFile = jarURLConnection.getJarFile();
        } catch (IOException e) {
            LOG.error("{} can not be found", classPath);
            return null;
        }

        Enumeration<JarEntry> jarEntries = jarFile.entries();
        while (jarEntries.hasMoreElements()) {
            JarEntry jarEntry = jarEntries.nextElement();
            String jarEntryName = jarEntry.getName();

            if (jarEntryName.contains(pathName) && !jarEntryName.equals(pathName + "/")) {
                // recursive subclass
                if (jarEntry.isDirectory()) {
                    String clazzName = jarEntry.getName().replace("/", ".");
                    int endIndex = clazzName.lastIndexOf(".");
                    String prefix = null;
                    if (endIndex > 0) {
                        prefix = clazzName.substring(0, endIndex);
                    }
                    if (prefix == null) {
                        continue;
                    }
                    findJarClass(prefix, superStrategy);
                }
                if (jarEntry.getName().endsWith(".class")) {
                    Class<?> clazz;
                    try {
                        clazz = classLoader.loadClass(jarEntry.getName().replace("/", ".").replace(".class", ""));
                    } catch (ClassNotFoundException e) {
                        continue;
                    }
                    if (clazz != null && superStrategy.isAssignableFrom(clazz) && !superStrategy.getName().equals(clazz.getName())) {
                        eleStrategyList.add(clazz);
                    }
                }
            }

        }
        return eleStrategyList;
    }
}

 

运行main方法输出如下：

org.apache.commons.lang3.time.FastDateFormat
org.apache.commons.lang3.time.FastDateParser