Question

我有一个类只有在该类存在的情况下返回类的方法，如果未加载类路径，则调用该方法会生成NoClassDefFoundError caused by ClassNotFoundException异常（理所当然，因为它不是必需的）

当类路径中没有加载某些方法（或字段）时，如何从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) { }

以下是试图在Reflection中找到方法的两位：

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

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

如果方法的返回类型引用了不可用的类，如果方法的代码尝试处理类的缺失（返回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是一个始终可用的类型，并且所有非可选代码始终通过{{引用可选功能1}}。您可能有更多的代码直接访问BaseType，如果OptionalType不可用，则假设不会调用它，但它也必须使用动态类加载与非可选代码分离。

否则，您可能会因为急剧解决JVM而出现完全失败的问题，而且懒散地解决了像Oracle这样的JVM问题。如果你没有调用有问题的方法，它不会立即失败的事实不是你保证的行为 - 它只是一个优化。

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

2 个答案: