免责声明:鉴于此问题，这可能不是最佳解决方案，但我很好奇如何实现此实现。

问题 我正在尝试处理一些具有如下定义的单例的遗留代码:

public class LegacySingleton {
    private static Boolean value;

    public static void setup(boolean v) {
        if (value != null) {
            throw new RuntimeException("Already Set up");
        }
        value = v;
        System.out.println("Setup complete");
    }

    public static void teardown() {
        value = null;
        System.out.println("Teardown complete");
    }

    public static boolean getValue() {
        return value;
    }
}

我没有能力更改此设计，并且该类在整个代码库中被大量使用。此单例返回的值可以极大地改变代码的功能。例如:

public class LegacyRequestHandler {
    public void handleRequest() {
        if (LegacySingleton.getValue()) {
            System.out.println("Path A");
        } else {
            System.out.println("Path B");
        }
    }
}

现在如果我想让代码采用路径A，那么我必须以特定方式初始化LegacySingleton。如果我想采用 Path B，我必须重新初始化 LegacySingleton。无法并行处理采用不同路径的请求； LegacySingleton 的每个不同配置意味着我需要启动一个单独的 JVM 实例。

我的问题 是否可以使用单独的类加载器来隔离这个单例？我一直在研究 ClassLoader API，但我不太明白。

我想它看起来应该是这样的:

public class LegacyRequestHandlerProvider extends Supplier<LegacyRequestHandler> {
    private final boolean value;
    public LegacyRequestHandlerProvider(boolean value) {
        this.value = value;
    }
    @Override
    public LegacyRequestHandler get() {
        LegacySingleton.setup(value);
        return new LegacyRequestHandler();
    }
}

...

ClassLoader loader1 = new SomeFunkyClassLoaderMagic();
Supplier<LegacyRequestHandler> supplier1 = loader1
    .loadClass("com.project.LegacyRequestHandlerProvider")
    .getConstructor(Boolean.TYPE)
    .newInstance(true);

ClassLoader loader2 = new SomeFunkyClassLoaderMagic();
Supplier<LegacyRequestHandler> supplier2 = loader2
    .loadClass("com.project.LegacyRequestHandlerProvider")
    .getConstructor(Boolean.TYPE)
    .newInstance(false);

LegacyRequestHandler handler1 = supplier1.get();
LegacyRequestHandler handler2 = supplier2.get();

最佳答案

在您希望 getValue 的输出发生变化的特定时间点，简单反射是否有效？

Field f = LegacySingleton.class.getDeclaredField("value");
f.setAccessible(true);
f.set(null, true|false);

如果不是，对于类加载器方法，您可以遵循插件架构。但正如其他人所指出的，这可能归结为在 2 个不同的类加载器层次结构上加载的整个依赖项。此外，您可能会遇到 LinkageError 问题，具体取决于依赖项在您的代码库中的工作方式。

受此启发post :

• 隔离代码库，主要是具有 LegacyRequestHandler 类的 jar，并且不包含在应用程序/主类路径中。
• 有一个自定义类加载器，它首先向内查找，然后检查父级。这种类加载器的一个完整示例是 here .

• 有一个包装器调用程序，它将使用提供 LegacySingleton 类的 jar 路径初始化类加载器，例如

  new ParentLastURLClassLoader(Arrays.asList(new URL[] {new URL("path/to/jar")}));

• 发布后，您可以在它的类加载器空间中加载单例并获取副本。

    //2 different classloaders 
    ClassLoader cl1 = new ParentLastURLClassLoader(urls);
    ClassLoader cl2 = new ParentLastURLClassLoader(urls);
    //LegacySingleton with value = true in Classloader space of cl1
    cl1.loadClass("LegacySingleton").getMethod("setup", boolean.class).invoke(null, true);
    //LegacySingleton with value = false in Classloader space of cl1
    cl2.loadClass("LegacySingleton").getMethod("setup", boolean.class).invoke(null, false);

• 接下来，您可以使用反射(通过cl1/2)获取遗留代码的驱动程序类并触发执行。

注意您不应该直接在主类中引用遗留代码中的类，因为它们将使用 Java 原始/应用程序类加载器加载。

关于java - 使用类加载器隔离静态单例类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49935733/