一个接口多个实现类，循环执行每个实现类

1.引用依赖

<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.9.11</version>
</dependency>

2.编写一个接口

public interface UseSearch {
    public String useSearch();
}

3.两个实现类

public class UseSearch1 implements UseSearch {
    @Override
    public String useSearch() {
        return "类1";
    }
}

public class UseSearch2 implements UseSearch {

    @Override
    public String useSearch() {
        return "类2";
    }
}

4.反射找到接口下所有的类，并执行它

public String test() throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        List<String> returnValue=new ArrayList<>();
        String packageName="com.demo";
        Reflections reflections = new Reflections(packageName);
        Set<Class<? extends UseSearch>> monitorClasses = reflections.getSubTypesOf(UseSearch.class);
        for(Class<? extends UseSearch> monitor:monitorClasses)
        {
            Class useClass = Class.forName(monitor.getName());
            UseSearch use= (UseSearch)useClass.newInstance();
            String result = use.useSearch();
            //循环执行类
            returnValue.add(result);
        }
        return returnValue.stream().collect(Collectors.joining(","));
    }

5.测试一下

public static void main(String[] args) {
        UseTest mainTest=new UseTest();
        try {
            System.out.println(mainTest.test());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

执行效果如下：