java - 带反射的模块化共闭包原理

Question

拥有这个 Maven 项目结构

root pom
     ---> ModuleCore/pom.xml
     ---> ModuleA/pom.xml
     ---> ModuleB/pom.xml
     ---> ModuleC/pom.xml
     ---> ModuleD/pom.xml

其中模块 A、B、C 和 D 与模块 Core 具有依赖关系，并且假设 ModuleA 与 具有依赖关系ModuleB 和 ModuleB 与 ModuleC 具有依赖关系。

通过这种依赖分布，我们同意:

如果我修改

  ModuleCore

必须版本

  ModuleA/pom.xml
  ModuleB/pom.xml
  ModuleC/pom.xml
  ModuleD/pom.xml

如果我更新ModuleD，则无需进行版本控制。

如果我更新ModuleC

必须版本

  ModuleA/pom.xml
  ModuleB/pom.xml

好吧，在整个解释之后，我想要实现的是没有模块之间有相互依赖关系，而只有 ModuleCore

我的第一个方法是创建接口(interface)作为模块之间通信的契约，并将该契约放入moduleCore中，然后通过reflection在中查找来调用实现>classpath 用于实现该接口(interface)并调用。但我对反射看起来很糟糕感到不太舒服，

有人可以给我一些建议，如何应用通用闭包原则而不将所有代码移至 ModuleCore 并制作一个整体吗？

我使用反射的第一种方法的代码示例。

@Test
void dependencyWithModuleA() {
    Reflections reflections = new Reflections("com.modularization.ccp");
    Optional<Optional<?>> any = reflections.getSubTypesOf(MainA.class)
            .stream()
            .map(clazz -> {
                try {
                    MainA mainA = clazz.newInstance();
                    return Optional.of(mainA.main());
                } catch (InstantiationException | IllegalAccessException e) {
                    e.printStackTrace();
                }
                return Optional.empty();
            }).findAny();
    if (any.isPresent() && any.get().isPresent()) {
        System.out.println(any.get().get());
    }

}

需要澄清的是，它将在服务启动时完成反射调用，并且将使用单例模式保存实例引用以进行 future 调用，以避免性能问题。

请对这种方法提出所有批评，我们非常欢迎。

问候。

Answer 1

从问题的标签来看，这个问题似乎仅限于 Java 8。使用这个假设......

看看 ServiceLoader JDK 中内置的类。您可以在每个 ModuleA-D jar 中的 META-INF/package.MainA 文件中声明 MainA 的实现。然后找到这些实现:

ServiceLoader.load(MainA.class).iterator()

Java 9 的情况发生了一些变化。现在 JDK9 模块可以直接声明其服务，但仍然可以通过 ServiceLoader 发现它们，因此这种方法也具有一定程度的面向 future 的能力。

显然，在 JDK 之外还有很多解决方案，例如Spring 有 Autowiring ，或者 ApplicationContext.getBeansOfType(Class)，Java EE 有 javax.enterprise.inject.Instance，还有 OSGi 等等...