获取所有classpath指定包下类的所有子类

Dear 丶 2022-01-23 12:23 309阅读 0赞

### 1.问题 ###

开发过程中，有时需要找到所有classpath下，特定包下某个类的所有子类，如何做到？

### 2. 实现 ###

比较常见的解决方案是自己遍历目录，查找所有.class文件。  
下面这个方法使用spring工具类实现，简化过程，不再需要自己遍历目录

/** * 获取在指定包下某个class的所有非抽象子类 * * @param parentClass 父类 * @param packagePath 指定包，格式如"com/sinosun/tarvel" * @return 该父类对应的所有子类列表 */
        private static <E> List<Class<E>> getSubClasses(final Class<E> parentClass, final String packagePath) throws ClassNotFoundException
        { 
            final ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
            provider.addIncludeFilter(new AssignableTypeFilter(parentClass));
            final Set<BeanDefinition> components = provider.findCandidateComponents(packagePath);
            final List<Class<E>> subClasses = new ArrayList<>();
            for (final BeanDefinition component : components)
            { 
                @SuppressWarnings("unchecked") final Class<E> cls = (Class<E>) Class.forName(component.getBeanClassName());
                if (Modifier.isAbstract(cls.getModifiers()))
                { 
                    continue;
                }
                subClasses.add(cls);
            }
            return subClasses;
        }

### 3. 实例 ###

扫描`com.sinosun`包下所有`CoreStart`类的子类，并采用反射的方式依次查看子类中是否启用数据源。

package com.sinosun.travel.core.main;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
    import org.springframework.core.type.filter.AssignableTypeFilter;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Set;
    
    /** * @author caogu * @date 2019/5/31 13:36 */
    public class DataSourceHandler
    { 
        private static final Logger logger = LoggerFactory.getLogger(DataSourceHandler.class);
        private static final String PARENT_PACKAGE= "com.sinosun";
        private static final String CORE_START_CLASS_NAME = "com.sinosun.travel.core.main.CoreStart";
        private static final String IS_ENABLE_DATA_SOURCE_METHOD_NAME = "isEnableDataSource";
    
        /** * 根据环境判定是否启用数据源 * 默认不启用数据源；扫描CoreStart类的所有子类，若子类中有一个启用数据源则启用数据源 * @throws Exception 异常 */
        public static void scanIsEnableDataSource() throws Exception
        { 
            List<Class<CoreStart>> coreStartClasses = getSubClasses(CoreStart.class, PARENT_PACKAGE);
            logger.info("扫描到CoreStart类的子类有：{}", coreStartClasses);
    
            for (Class<CoreStart> coreStartClass : coreStartClasses)
            { 
                // 只扫描CoreStart的子类，只要一个启用数据源就启用数据源; 默认不启用数据源
                // 只检测子类，父类排除
                if (!CORE_START_CLASS_NAME.equals(coreStartClass.getName()))
                { 
                    Constructor constructor = coreStartClass.getConstructor();
                    Object obj = constructor.newInstance();
    
                    Method[] methods = coreStartClass.getDeclaredMethods();
                    for (Method method : methods)
                    { 
                        if (IS_ENABLE_DATA_SOURCE_METHOD_NAME.equals(method.getName()))
                        { 
                            boolean isEnableDataSource = (boolean) method.invoke(obj);
                            logger.info("调用{}.{}方法的返回值为{}", coreStartClass.getName(), coreStartClass.getName(), isEnableDataSource);
                            if (isEnableDataSource)
                            { 
                                CoreStart.ENABLE_DATA_SOURCE = true;
                                logger.info("扫描到子类启用数据源，加载数据源！");
                                return;
                            }
                        }
                    }
                }
            }
        }
    
        /** * 获取在指定包下某个class的所有非抽象子类 * * @param parentClass 父类 * @param packagePath 指定包，格式如"com/sinosun/tarvel" * @return 该父类对应的所有子类列表 */
        private static <E> List<Class<E>> getSubClasses(final Class<E> parentClass, final String packagePath) throws ClassNotFoundException
        { 
            final ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
            provider.addIncludeFilter(new AssignableTypeFilter(parentClass));
            final Set<BeanDefinition> components = provider.findCandidateComponents(packagePath);
            final List<Class<E>> subClasses = new ArrayList<>();
            for (final BeanDefinition component : components)
            { 
                @SuppressWarnings("unchecked") final Class<E> cls = (Class<E>) Class.forName(component.getBeanClassName());
                if (Modifier.isAbstract(cls.getModifiers()))
                { 
                    continue;
                }
                subClasses.add(cls);
            }
            return subClasses;
        }
    
        public static void main(String[] args)
        { 
            System.out.println(System.getProperty("java.class.path"));
            System.out.println(System.getProperty("user.dir"));
        }
    
    }

结果如下：  
![在这里插入图片描述][2019060320304548.png]

[2019060320304548.png]: /images/20220123/678423a6ae7c44c7b7c729cb00185ab4.png