Comment lire le nom complet d'un fichier .class

Question

Hé, je pense que le titre résume tout, mais quand même.

J'ai besoin de extrait le nom complet d'un objet de sa compilation .classe fichier, quelqu'un pourrait-il m'orienter dans la bonne direction ?

Merci,
Adam.

Answer 1

getClass().getName()

Mise à jour: Vous pouvez charger le fichier de classe dans un byte[] (en utilisant les E/S standard), puis utilisez getClass().getClassLoader().defineClass(...)

Answer 2

public String getFullClassName(String classFileName) throws IOException {           
        File file = new File(classFileName);

        FileChannel roChannel = new RandomAccessFile(file, "r").getChannel(); 
        ByteBuffer bb = roChannel.map(FileChannel.MapMode.READ_ONLY, 0, (int)roChannel.size());         

        Class<?> clazz = defineClass((String)null, bb, (ProtectionDomain)null);
        return clazz.getName();
    }

Answer 3

Utilisez une bibliothèque comme BCEC pour lire le fichier de classe en mémoire et la questionner pour le nom de la classe.

Answer 4

Vous pouvez lire ceci en analysant le binaire. Format de fichier de classe est définidans le VM SPEC .

jetez un coup d'œil au DataGuTretstream si vous êtes nouveau pour analyser les fichiers binaires.

Answer 5

Selon ce que vous utilisez IDE, il pourrait y avoir un mécanisme pour le faire.Par exemple dans Eclipse, vous pouvez explorer le fichier .class et cliquez avec le bouton droit de la souris et sélectionnez "Copier le nom qualifié".

Les versions anciennes d'Eclipse n'ont peut-être pas cette fonctionnalité, mais j'ai déjà utilisé ce plugin avant:

http://www.jave.de/eclipse/copyvery/index.html

Cela fonctionne à peu près de la même manière.J'espère que cela aide.

Answer 6

Vous pouvez regarder par exemple l'exemple à l'annotationcanner de la mise en œuvre de la JSF, ils chargent les classes manuellement (pour éviter la pollution de l'espace Perm) pour trouver des annotations JSF.En particulier regarder cela:

   /**
     * This class is encapsulating binary .class file information as defined at
     * http://java.sun.com/docs/books/vmspec/2nd-edition/html/ClassFile.doc.html
     * <p/>
     * This is used by the annotation frameworks to quickly scan .class files
     * for the presence of annotations. This avoid the annotation framework
     * having to load each .class file in the class loader.
     * <p/>
     * Taken from the GlassFish V2 source base.
     */
    @SuppressWarnings({"UnusedDeclaration"})
    private static final class ClassFile {

        private static final int magic = 0xCAFEBABE;

        public static final int ACC_PUBLIC = 0x1;
        public static final int ACC_PRIVATE = 0x2;
        public static final int ACC_PROTECTED = 0x4;
        public static final int ACC_STATIC = 0x8;
        public static final int ACC_FINAL = 0x10;
        public static final int ACC_SYNCHRONIZED = 0x20;
        public static final int ACC_THREADSAFE = 0x40;
        public static final int ACC_TRANSIENT = 0x80;
        public static final int ACC_NATIVE = 0x100;
        public static final int ACC_INTERFACE = 0x200;
        public static final int ACC_ABSTRACT = 0x400;

        public short majorVersion;
        public short minorVersion;
        public ConstantPoolInfo constantPool[];
        public short accessFlags;
        public ConstantPoolInfo thisClass;
        public ConstantPoolInfo superClass;
        public ConstantPoolInfo interfaces[];

        /**
         * bunch of stuff I really don't care too much for now.
         * <p/>
         * FieldInfo           fields[]; MethodInfo          methods[];
         * AttributeInfo       attributes[];
         */

        ByteBuffer header;
        ConstantPoolInfo constantPoolInfo = new ConstantPoolInfo();

        // ------------------------------------------------------------ Constructors


        /**
         * Creates a new instance of ClassFile
         */
        public ClassFile() {
            header = ByteBuffer.allocate(12000);
        }

        // ---------------------------------------------------------- Public Methods


        public void setConstantPoolInfo(ConstantPoolInfo poolInfo) {
            constantPoolInfo = poolInfo;
        }


        /**
         * Read the input channel and initialize instance data structure.
         *
         * @param in a <code>ReadableByteChannel</code> that provides the bytes
         *  of the classfile
         *
         * @return <code>true</code> if the bytes representing this classfile include
         *  one of the annotations we're looking for.
         *
         * @throws IOException if an I/O error occurs while reading the class
         */
        public boolean containsAnnotation(ReadableByteChannel in)
              throws IOException {

            /**
             * this is the .class file layout
             *
             ClassFile {
             u4 magic;
             u2 minor_version;
             u2 major_version;
             u2 constant_pool_count;
             cp_info constant_pool[constant_pool_count-1];
             u2 access_flags;
             u2 this_class;
             u2 super_class;
             u2 interfaces_count;
             u2 interfaces[interfaces_count];
             u2 fields_count;
             field_info fields[fields_count];
             u2 methods_count;
             method_info methods[methods_count];
             u2 attributes_count;
             attribute_info attributes[attributes_count];
             }
             **/
            header.clear();
            long read = (long) in.read(header);
            if (read == -1) {
                return false;
            }
            header.rewind();

            if (header.getInt() != magic) {
                return false;
            }

            minorVersion = header.getShort();
            majorVersion = header.getShort();
            int constantPoolSize = header.getShort();

            return constantPoolInfo
                  .containsAnnotation(constantPoolSize, header, in);

        }

    } // END ClassFile