15

反射类和方法以及类加载器等需要使用所谓的“二进制”类名称。

问题是，如果只有完全限定名称，即在源代码中使用的名称，如何获得二进制名称。

例如：

package frege;
public static class RT {
    ....
    public static class X { .... }
}

类的完全限定名称是frege.RT.X. 然而，要获取类对象，需要编写：

Class.forName("frege.RT$X")

并不是

Class.forName("frege.RT.X")    // fails with ClassNotFoundException

因为X恰好是 的内部类frege.RT。

一个可能但笨拙的解决方案是从后退替换，一个接一个，直到.不再抛出或没有更多替换。$Class.forName()ClassNotFoundException.

有没有更好/众所周知/标准的解决方案？我查看了 API 文档Class，CLassLoader但java.lang.reflect没有找到任何可用的东西。

4

3 回答 3

13

现在听起来您想从规范名称中获取完全限定名称 (FQN)。由于这与使用简单名称不同，我将添加第二个答案。

如果会导致规范名称冲突，Sun javac 命令将不会编译类。但是，通过单独编译，您仍然可以获得具有相同规范名称的两个不同类。

一个例子：

文件 src1\com\stack\Test.java

package com.stack;

public class Test {
    public static class Example {
        public static class Cow {
            public static class Hoof {
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Class<?> cl1 = Class.forName("com.stack.Test$Example$Cow$Hoof");
        Class<?> cl2 = Class.forName("com.stack.Test.Example.Cow.Hoof");
        System.out.println(cl1.getName());
        System.out.println(cl1.getSimpleName());
        System.out.println(cl1.getCanonicalName());
        System.out.println();
        System.out.println(cl2.getName());
        System.out.println(cl2.getSimpleName());
        System.out.println(cl2.getCanonicalName());
    }
}

文件 src2\com\stack\Test\Example\Cow\Hoof.java

package com.stack.Test.Example.Cow;

public class Hoof { }

然后编译并执行：

set CLASSPATH=
mkdir bin1 bin2
javac -d bin1 -sourcepath src1 src1\com\stack\Test.java
javac -d bin2 -sourcepath src2 src2\com\stack\Test\Example\Cow\Hoof.java

set CLASSPATH=bin1;bin2
java com.stack.Test

产生输出：

com.stack.Test$Example$Cow$Hoof
Hoof
com.stack.Test.Example.Cow.Hoof

com.stack.Test.Example.Cow.Hoof
Hoof
com.stack.Test.Example.Cow.Hoof

因此，两个类具有相同的规范名称但不同的 FQN。即使两个类具有相同的 FQN 和相同的规范名称，如果它们通过不同的类加载器加载，它们仍然可能不同。

为了解决您的问题，我看到了您可以采取的几种前进方式。

首先，您可以指定您匹配具有最少嵌套量的类，因此 FQN 中的“$”数量最少。更新事实证明，Sun javac 与此完全相反，并且匹配嵌套最多的类。

其次，您可以测试所有可能的 FQN，如果有多个则抛出异常。

第三，接受唯一的唯一映射是与 FQN，然后仅在指定的类加载器中，并适当地重新处理您的应用程序。我发现使用线程上下文类加载器作为默认类加载器很方便。

于 2012-11-12T12:14:08.353 回答
2

一个简单的名称会省略很多信息，并且可能有许多具有相同简单名称的类。这可能使这成为不可能。例如：

package stack;

/**
 * 
 * @author Simon Greatrix
 */
public class TestLocal {

    public Object getObject1() {
        class Thing {
            public String toString() { 
                return "I am a Thing";
            }
        }
        return new Thing();
    }

    public Object getObject2() {
        class Thing {
            public String toString() { 
                return "I am another Thing";
            }
        }
        return new Thing();
    }

    public Object getObject3() {
        class Thing {
            public String toString() { 
                return "I am a rather different Thing";
            }
        }
        return new Thing();
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        TestLocal test = new TestLocal();
        Object[] objects = new Object[] {
                test.getObject1(),                
                test.getObject2(),                
                test.getObject3()                
        };

        for(Object o : objects) {
            System.out.println("Object      : "+o);
            System.out.println("Simple Name : "+o.getClass().getSimpleName());
            System.out.println("Name        : "+o.getClass().getName());
        }
    }
}

这将产生输出：

Object      : I am a Thing
Simple Name : Thing
Name        : stack.TestLocal$1Thing
Object      : I am another Thing
Simple Name : Thing
Name        : stack.TestLocal$2Thing
Object      : I am a rather different Thing
Simple Name : Thing
Name        : stack.TestLocal$3Thing

如您所见，所有三个本地类都具有相同的简单名称。

于 2012-11-11T20:14:52.303 回答
1

我认为规范名称指定唯一类是安全的选择。如上所述，javac 不允许您从单个编译单元创建具有相同规范名称的两个类。如果您有 2 个编译，那么您可能会在加载哪个类时遇到麻烦，但那时我会更担心库的包名与您的包名冲突，除了恶意之外，其他人都可以避免这种情况。

出于这个原因，我认为假设您不会遇到这种情况是一个安全的选择。沿着这些思路，对于那些感兴趣的人，我实现了 OP 的建议（将 s 翻转$为s），并在它没有找到任何具有该规范名称的类的情况下.简单地抛出一个，或者如果它找到两个或更多ClassNotFoundException有这个名字。

   /**
 * Returns the single class at the specified canonical name, or throws a {@link java.lang.ClassNotFoundException}.
 *
 * <p>Read about the issues of fully-qualified class paths vs the canonical name string
 * <a href="http://stackoverflow.com/questions/13331902/how-to-get-the-binary-name-of-a-java-class-if-one-has-only-the-fully-qualified">discussed here</a>.
 */
public static <TStaticallyNeeded> Class<TStaticallyNeeded> classForCanonicalName(String canonicalName)
        throws ClassNotFoundException {

    if (canonicalName == null) { throw new IllegalArgumentException("canonicalName"); }

    int lastDotIndex = canonicalName.length();
    boolean hasMoreDots = true;

    String attemptedClassName = canonicalName;

    Set<Class> resolvedClasses = new HashSet<>();

    while (hasMoreDots) try {
        Class resolvedClass = Class.forName(attemptedClassName);
        resolvedClasses.add(resolvedClass);
    }
    catch (ClassNotFoundException e) {
        continue;
    }
    finally {
        if(hasMoreDots){
            lastDotIndex = attemptedClassName.lastIndexOf('.');
            attemptedClassName = new StringBuilder(attemptedClassName)
                    .replace(lastDotIndex, lastDotIndex + 1, "$")
                    .toString();
            hasMoreDots = attemptedClassName.contains(".");
        }
    }

    if (resolvedClasses.isEmpty()) {
        throw new ClassNotFoundException(canonicalName);
    }

    if (resolvedClasses.size() >= 2) {
        StringBuilder builder = new StringBuilder();
        for (Class clazz : resolvedClasses) {
            builder.append("'").append(clazz.getName()).append("'");
            builder.append(" in ");
            builder.append("'").append(
                    clazz.getProtectionDomain().getCodeSource() != null
                            ? clazz.getProtectionDomain().getCodeSource().getLocation()
                            : "<unknown code source>"
            ).append("'");
            builder.append(System.lineSeparator());
        }

        builder.replace(builder.length() - System.lineSeparator().length(), builder.length(), "");

        throw new ClassNotFoundException(
                "found multiple classes with the same canonical names:" + System.lineSeparator() +
                        builder.toString()
        );
    }

    return resolvedClasses.iterator().next();
}

“预期的”流程是命中该catch(NoClass) continue代码仍然让我非常恼火，但如果你曾经告诉 eclipse 或 intelliJ 自动中断抛出的任何异常，你就会知道这种行为是正常的。

于 2015-01-03T23:23:45.627 回答