Question

我遇到的问题是：我有一系列通过注释收集的类。它们都驻留在同一个文件夹中，如果它们具有特定的注释，它们将通过Reflections library实例化。在实例化这些类时，有一个静态初始化程序调用静态工厂，它构建一些结构。尝试获取工厂创建的对象时，Java将抛出InvocationTargetException错误。更具体地说，当我输出ITE的堆栈跟踪时，它直接指向静态初始化程序，该初始化程序向工厂询问该对象。

以下是我用来复制问题的代码。

我有一个注释：InferenceRule.java

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface funRule {
    String ruleName();
    String ruleType();
    String analyze() default "node";
}

然后我将该注释应用于包inference.rules中的一些类：

@InferenceRule(ruleName = "assign", ruleType = "term")
public class Assign extends NodeAnalyzer {
    public Assign() {super();}
    public Assign(String... args) { super(args); }
    public Rule gatherAllCOnstraints(InstructionNode node) {
        // use the Identifier object here.
    }
    // rest of class here
}

NodeAnalyzer类，上面Assign类的超级：

public abstract class NodeAnalyzer {
    protected Identifier identifier;

    protected NodeAnalyzer() {
        // Construct things here
    }

    protected NodeAnalyzer(String... args) {
        // Construct other things here
    }

    // Construct common things here
    {
        this.identifier = IdentifierFactory.getIdentifier();
    }
    // rest of class here
}

Assign类在Inference类中实例化，如下所述：

public class Inference {
    public final String NODE_ANALYSIS = "NODE";
    public static final String INFERENCE_PACKAGE = "inference.rules";
    private final Map<String, NodeAnalyzer> nodeAnalyzer = new HashMap<>();
    private final Map<String, EdgeAnalyzer> edgeAnalyzer = new HashMap<>();
    public Inference() {

    }
    // other non-interesting things here

    private void loadRules() {
        Reflections reflection = new Reflections(INFERENCE_PACKAGE);
        Set<Class<?>> annotated = reflection.getTypesAnnotatedWith(InferenceRule.class);

        for(Class<?> clazz : annotated) {
            try {
                String name = clazz.getAnnotation(InferenceRule.class).ruleName();
                String type = clazz.getAnnotation(InferenceRule.class).ruleType();
                String analyze = clazz.getAnnotation(InferenceRule.class).analyze();
                if (StringUtils.equalsIgnoreCase(analyze, NODE_ANALYSIS)) {
                    final NodeAnalyzer newInstance = (NodeAnalyzer) clazz.getConstructor(InferenceType.class).newInstance(InferenceType.valueOf(type));
                    this.nodeAnalyzer.put(name, newInstance);
                }
                // handle other cases...
            } catch(InvocationTargetException ite) {
                // For debugging, only
                ite.printStackTrace();
                logger.error(ite.getCause.getMessage());
                logger.error(ite.getTargetException.getMessage());
            }
        }
    }
}

如您所见，从Assign和NodeAnalyzer中的实例化路径，它必须调用IdentifierFactory类：

public class IdentifierFactory {
    private static final Identifier identifier;
    static {
        if (ConfigFactory.getConfig().isDebEnabled()) {
            identifier = new DBIdentifier();
        } else {
            identifier = new NaiveIdentifier();
        }
    }

    public static Identifier getIdentifier() {
        return identifier;
    }
}

NaiveIdentifier类：

public class NaiveIdentifier {
    private Set<Integer> unknowns = new HashSet<Integer>() {{
        unknowns.add(0);
        // add more here.
    };

    public NaiveIdentifier() {} // empty default constructor
}

ConfigFactory类遵循与IdentifierFactory类类似的模式。它基于某些输入构建配置。

抛出的确切异常如下：

java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at phases.inference.Inference.loadRules(Inference.java:197)
    at phases.inference.Inference.<init>(Inference.java:76)
    at phases.PhaseFacade$PHASES.getPhase(PhaseFacade.java:27)
    at phases.PhaseFacade.<init>(PhaseFacade.java:42)
    at compilation.Compiler.runPhases(Compiler.java:126)
    at compilation.Compiler.runAllOps(Compiler.java:118)
    at Main.main(Main.java:45)
Caused by: java.lang.ExceptionInInitializerError
    at phases.inference.rules.NodeAnalyzer.<init>(NodeAnalyzer.java:35)
    at phases.inference.rules.Assign.<init>(Assign.java:22)
    ... 11 more
Caused by: java.lang.NullPointerException
    at typesystem.identification.NaiveIdentifier$1.<init>(NaiveIdentifier.java:23)
    at typesystem.identification.NaiveIdentifier.<init>(NaiveIdentifier.java:22)
    at typesystem.identification.IdentifierFactory.<clinit>(IdentifierFactory.java:25)
    ... 13 more

和

java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at phases.inference.Inference.loadRules(Inference.java:197)
    at phases.inference.Inference.<init>(Inference.java:76)
    at phases.PhaseFacade$PHASES.getPhase(PhaseFacade.java:27)
    at phases.PhaseFacade.<init>(PhaseFacade.java:42)
    at compilation.Compiler.runPhases(Compiler.java:126)
    at compilation.Compiler.runAllOps(Compiler.java:118)
    at Main.main(Main.java:45)
Caused by: java.lang.NoClassDefFoundError: Could not initialize class typesystem.identification.IdentifierFactory
    at phases.inference.rules.NodeAnalyzer.<init>(NodeAnalyzer.java:35)
    at phases.inference.rules.Assign.<init>(Assign.java:18)
    ... 11 more

从这些，我无法充分辨别根本原因是什么。为了进一步复杂化，我尝试使用其他输入文件运行它，并且它可以正常工作。

Answer 1

此代码

public class NaiveIdentifier {
    private Set<Integer> unknowns = new HashSet<Integer>() {{
        unknowns.add(0);
        // add more here.
    }}; // ( <- added missing brace here)

    public NaiveIdentifier() {} // empty default constructor
}

正在使用“Double Curly Brace Initialization”反模式。通常，这种反模式用于在源代码中保存一些输入：

public class NaiveIdentifier {
    private Set<Integer> unknowns = new HashSet<Integer>() {{
        // yeah, we saved writing the nine characters "unknowns."
        add(0);
        // add more here.
    }};

    public NaiveIdentifier() {} // empty default constructor
}

以创建集合类的新子类为代价，并可能创建内存泄漏，因为内部类保存对其外部类实例的引用，如this Q&A中所述。

具有讽刺意味的是，你没有省略字符unknowns.，因此不仅没有利用这种反模式，而且还创建了这个错误，因为你正在访问应该初始化的字段。从set的构造函数中构造set实例。换句话说，您的代码等同于以下代码：

public class NaiveIdentifier {
    private Set<Integer> unknowns;
    {
      Set<Integer> temp = new HashSet<Integer>() {{
        unknowns.add(0);
        // add more here.
      }};
      unknowns = temp;
    }

    public NaiveIdentifier() {} // empty default constructor
}

清楚地说明了为什么此代码失败并带有NullPointerException。

您可以通过一致地使用反模式来修复此问题，即删除unknowns.个字符以更改外部实例字段对超类调用的访问（如上面的第二个代码示例中所示），但是，现在，如果有字符，您可以轻松更改代码以使用没有反模式的干净初始化程序：

public class NaiveIdentifier {
    private Set<Integer> unknowns = new HashSet<Integer>();
    {
        unknowns.add(0);
        // add more here.
    }

    public NaiveIdentifier() {} // empty default constructor
}

使用单个花括号时，您不是要创建HashSet的内部类子类，而只是定义将添加到NaiveIdentifier的构造函数中的初始化程序，以预期的程序文本顺序执行，首先是初始值设定项unknowns = new HashSet<Integer>()，然后是unknowns.add(…);语句。

对于简单的初始化语句，您可以考虑替代

public class NaiveIdentifier {
    private Set<Integer> unknowns = new HashSet<>(Arrays.asList(0, 1, 2, 3 …));

    public NaiveIdentifier() {} // empty default constructor
}

Java`InvocationTargetException`，通过反射进行类实例化

1 个答案: