类初始化后的Java调用方法

Question

我有一个由各种类扩展的类 X。 X 需要知道它在运行时存在的每个子类型。所以我的想法是在 X 中创建一个以 Class 作为参数的静态方法“static init()”。问题在于，在调用 init() 之前，需要通过其静态初始化块初始化 X 的子类。例如，X 可能会发现子类的一些静态字段，这些字段可能是任何声明的类型。所以以这段代码为例：

class X {
    X() {
        /*This would be one idea but does not work
          in this concrete example.*/
        init(getClass());
    }
    static void init(Class<? extends X> c) {
         if(c.getDeclaredField("a").get(null) == null) {
             throw new AssertionError();
         }
    }
}

class Y extends X {
    static X a = new X();
    static {
        /*Another idea. Works totally fine but
          I dont want to trust subclasses that
          they do that correctly.*/
        init(Y.class);
    }
}

所以我正在寻找一种方法，以某种方式将我的 init() 方法称为类静态初始化的最后一步。或任何其他防止 AssertionError 发生的方法。

编辑：因为这会导致cmets中的误解，我实际上想做第二件事。我希望在子类化我的类的任何类的静态初始化中调用我的方法（直接或间接）。我不知道存在哪些子类，我对它们的结构一无所知，并且必须在运行时检查所有断言（通过反射）。我的类和子类甚至可能不会由同一台机器上的同一编译器和/或同一个人编译。

Edit2：也许我可以构建一个 ClassLoader，它是 System-ClassLoader 的简单代理，并用它替换 System-ClassLoader。如果加载的类是我的类的子类，我可以初始化它并调用我的方法。不幸的是，我（还）对 ClassLoaders 知之甚少，网上也没有太多关于这个主题的教程或帮助。那么任何有自定义类加载器经验的人都可以告诉我这是否可能吗？如果我的类路径中的某个其他库在任何时间点也安装了自定义 ClassLoader，会发生什么情况？

Edit3：我不想做的——如果有其他选择的话——是直接修改字节码。

Answer 1

这将是您的 Edit2 的示例：

public class ConstraintClassLoader extends URLClassLoader {

public ConstraintClassLoader(URL[] urls, ClassLoader parent) {
    super(urls, parent);
}

@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        Class c = findLoadedClass(name);
        if (c == null) {
            try {
                c = findClass(name);
            } catch (ClassNotFoundException e) {
                c = super.loadClass(name, resolve);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
    try {
        System.out.println("find " + name);
        Class<?> c = super.findClass(name);
        Class<?> parent = c.getSuperclass();
        while (parent != null)  {
            if (parent.getName().contains("X")) {
                break;
            }
            parent = parent.getSuperclass();
        }
        if (parent == null) {
            return c;
        }
        Field declaredField = c.getDeclaredField("a");
        declaredField.setAccessible(true);
        if (declaredField.get(null) == null) {
            throw new AssertionError();
        }
        return c;
    } catch (NullPointerException | IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException | AssertionError e) {
        throw new RuntimeException(e);
    }
}
}

我认为它可以实现您在 Edit2 中描述的功能，但它也存在您提到的弱点（对于其他类加载应用程序，例如 OSGI、Reflections、AOP、Spring，会很脆弱）。

要安装此类加载器，您可以使用此类加载器加载 Main 类，并使用反射调用 main 方法。您可以找到其他更优雅的解决方案来在 Web 上设置类加载器。

Answer 2

如果你必须处理很多反射问题，我可以推荐reflections libary

你可以这样做：

    Reflections r = new Reflections("package.name");
    Set<Class<? extends X>> childs = r.getSubTypesOf(X.class);

Answer 3

X 需要知道它在运行时存在的每个子类型。

这可以通过以下代码实现：

import java.util.HashSet;
import java.util.Set;

public class Main {

    public static class X {
        private static Set<Class<? extends X>> classes = new HashSet<Class<? extends X>>();

        public X() {
            classes.add(getClass());
            // and here you can check for fields of subclasses
        }
    }

    public static class Y extends X {}

    public static void main(String[] args) {
        new Y(); new X();
        System.out.println(X.classes);
    }
}

如果你运行 main 方法，它会打印如下内容：

[class Main$X, class Main$Y]