如何在不使用 try-catch 的情况下使用 Java 时忽略可能的 ClassNotFoundException

Question

我有一个 class 方法 return 一个 class 只有当那个 class 存在时，调用该方法会产生一个 NoClassDefFoundError caused by ClassNotFoundException 异常如果class路径未加载（这是正确的，因为它不是强制性的）。

当 class 路径中可能未加载某些方法（或字段）时，我如何仍能从 Class#getMethods() 获取方法？ 检索时是否可以忽略 methods/fields？

请注意，使用 try-catch 将完全阻止整个进程工作，因此这不是解决方案！

这是我加载 class:

的方式

try {
    String name = StringUtil.format("Nifty{0}", (isBungee ? "Bungee" : "Bukkit"));
    Reflection main = new Reflection(name, StringUtil.format("net.netcoding.{0}", name.toLowerCase())); // net.netcoding.niftybukkit.NiftyBukkit
    Object mainObj = main.invokeMethod("getPlugin", null); // See below
    logger = (Logger)main.invokeMethod("getLogger", mainObj);
} catch (Exception ex) { }

这里是试图在反射中定位方法的两个位：

public class Reflection {

    private static final transient ConcurrentHashMap<Class<?>, Class<?>> CORRESPONDING_TYPES = new ConcurrentHashMap<>();
    private final String className;
    private final String subPackage;
    private final String packagePath;

    static {
        CORRESPONDING_TYPES.put(Byte.class, byte.class);
        CORRESPONDING_TYPES.put(Short.class, short.class);
        CORRESPONDING_TYPES.put(Integer.class, int.class);
        CORRESPONDING_TYPES.put(Long.class, long.class);
        CORRESPONDING_TYPES.put(Character.class, char.class);
        CORRESPONDING_TYPES.put(Float.class, float.class);
        CORRESPONDING_TYPES.put(Double.class, double.class);
        CORRESPONDING_TYPES.put(Boolean.class, boolean.class);
    }

    public Reflection(String className, String packagePath) {
        this(className, "", packagePath);
    }

    public Reflection(String className, String subPackage, String packagePath) {
        this.className = className;
        this.subPackage = StringUtil.stripNull(subPackage).replaceAll("\.$", "").replaceAll("^\.", "");
        this.packagePath = packagePath;
    }

    public String getClassName() {
        return this.className;
    }

    public String getClassPath() {
        return this.getPackagePath() + (StringUtil.notEmpty(this.subPackage) ? "." + this.subPackage : "") + "." + this.getClassName();
    }

    public Class<?> getClazz() throws Exception {
        return Class.forName(this.getClassPath());
    }

    public Object invokeMethod(String name, Object obj, Object... args) throws Exception {
        return this.getMethod(name, toPrimitiveTypeArray(args)).invoke(obj, args);
    }

    private static Class<?> getPrimitiveType(Class<?> clazz) {
        return clazz != null ? CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz : null;
    }

    public Method getMethod(String name, Class<?>... paramTypes) throws Exception {
        Class<?>[] types = toPrimitiveTypeArray(paramTypes);

        // In this example, this.getClazz() simply returns
        // a Class of net.netcoding.niftybukkit.NiftyBukkit
        // this.getClazz().getMethods() throws the ClassNotFOundException
        // I want to still access the methods, even if one of them is not available
        for (Method method : this.getClazz().getMethods()) {
            Class<?>[] methodTypes = toPrimitiveTypeArray(method.getParameterTypes());

            if (method.getName().equals(name) && isEqualsTypeArray(methodTypes, types)) {
                method.setAccessible(true);
                return method;
            }
        }

        System.out.println(StringUtil.format("The method {0} was not found with parameters {1}!", name, Arrays.asList(types)));
        return null;
    }

Answer 1

怎么样：

public Class<?> getClazz() {
    try {
        return Class.forName(this.getClassPath());
    } catch (ClassNotFoundException e) {
        // ignore or better log
    }
    return null;
}

然后稍后：

Class<?> clazz = this.getClazz();
if (clazz != null) {
    for (Method method : clazz.getMethods()) {
        // ....
    }
}

Answer 2

如果您保留自己的设计，您将创建依赖于非保证行为的不可移植代码。

如果方法的 return 类型引用不可用的 class，如果方法的代码试图处理 class 的缺失（return null 或其他）或未调用该方法。

不仅Class.getMethods可能失效，还可能导致整个class无法使用。问题是 JVM 在 when 方面有一定的自由度，如果无法解析直接引用的 class 则抛出错误。一个有效的点是 class loading 时间，所以使用不同的 JVM，实现这样的解析策略，你甚至不会走到可以调用 Class.getMethods().

使有效代码处理可选 classes 的唯一方法是将直接引用的 classes 与可选 classes 分离，例如

public static BaseType getOptionalFeature() {
  try {
    return (BaseType)Class.forName("OptionalType").newInstance();
  } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
    return null;
  }
}

假设 OptionalType 扩展或实现 BaseType，重要的方面是 Baseype 是一种始终可用的类型，并且所有非可选代码始终通过以下方式引用可选功能BaseType。您可能有更多代码直接访问 OptionalType，如果 OptionalType 不可用，您假设不会调用它，但它也必须使用动态 class 加载与非可选代码分离.

否则，您将冒着急切解析 JVM 完全失败的风险，以及像 Oracle 那样延迟解析 JVM 的虚假失败的风险。事实上，如果您不调用有问题的方法，它不会立即失败，这对您来说并不是一种有保证的行为——这只是一种优化。

如何在不使用 try-catch 的情况下使用 Java 时忽略可能的 ClassNotFoundException

How to ignore possible ClassNotFoundException when using Java without try-catch

java

reflection

classnotfoundexception