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

Question

我有一个类，其方法仅在该类存在时才返回该类，如果未加载类路径，调用该方法将生成由 ClassNotFoundException 引起的 NoClassDefFoundError 异常(这是正确的，因为它不是强制性的)。

当某些方法(或字段)可能未加载到类路径中时，如何从 Class#getMethods() 获取方法？在检索方法/字段时是否可以忽略它们？

请注意，使用 try-catch 会导致整个过程完全无法运行，因此这不是解决方案!

这是我加载类的方式:

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

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

如果一个方法的返回类型引用了一个不可用的类，那么该方法的代码尝试处理该类的缺失(返回 null 或其他)或未调用该方法也无济于事。

不仅仅是Class.getMethods可能失败，还可能导致整个类无法使用。问题在于，如果无法解析直接引用的类，JVM 在何时抛出错误方面有一定的自由度。一个有效点是类加载时间，因此使用不同的 JVM，实现这样的解析策略，您甚至无法调用 Class.getMethods()。

拥有处理可选类的有效代码的唯一方法是将直接引用的类与可选类解耦，例如

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

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

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