Java: come caricare la classe memorizzata come byte [] nella JVM?

Question

Se uno ha serializzato l'intero file .class in byte [] e assumendo che il nome della classe sia noto (passato insieme al byte []), come si converte byte [] -> Classe -> quindi caricarlo alla JVM in modo che potrei in seguito usarlo chiamando Class.forName()?

NOTA: sto facendo questo perché ho inviato il .class su un altro host e JVM del padrone di casa non sapere su questo .class.

Answer 1

realtà sto usando qualcosa di simile in questo momento in un test per dare una serie di definizioni di classe come byte [] per un ClassLoader:

public static class ByteClassLoader extends URLClassLoader { 
    private final Map<String, byte[]> extraClassDefs; 

    public ByteClassLoader(URL[] urls, ClassLoader parent, Map<String, byte[]> extraClassDefs) { 
     super(urls, parent); 
     this.extraClassDefs = new HashMap<String, byte[]>(extraClassDefs); 
    } 

    @Override 
    protected Class<?> findClass(final String name) throws ClassNotFoundException { 
     byte[] classBytes = this.extraClassDefs.remove(name); 
     if (classBytes != null) { 
     return defineClass(name, classBytes, 0, classBytes.length); 
     } 
     return super.findClass(name); 
    } 

    } 

Answer 2

Estendere ClassLoader e quindi implementare la chiamata necessaria per ottenere il byte[] all'interno del metodo defineClass(). Al contrario, puoi farlo in findClass(). Caricherai quindi questo ClassLoader all'inizio o lo utilizzerai quando avrai bisogno di definizioni di classe tramite l'array.

public class ByteArrayClassLoader extends ClassLoader { 

    public Class findClass(String name) { 
     byte[] ba = /* go obtain your byte array by the name */; 

     return defineClass(name,ba,0,ba.length); 
    } 

} 

Answer 3

Utilizzare il (int String, byte [],, int) Metodo defineClass da ClassLoader

Answer 4

Bene, ecco quello che ho fatto:

public class AgentClassLoader extends ClassLoader 
{ 
    public void loadThisClass(ClassByte classByte_) 
    { 
    resolveClass(defineClass(classByte_.getName(), 
          classByte_.getBytes(), 
          0, 
          classByte_.getBytes().length)); 
    } 
} 

Spero che carica la classe in JVM? Se funziona davvero, perché l'implementatore Java non ha reso entrambi i metodi pubblici defineClass e resolveClass? Mi chiedo davvero cosa stessero pensando. Chiunque può illuminarmi?

Solo per completezza, ecco ClassByte

import java.io.Serializable; 

public class ClassByte implements Serializable 
{ 
    private String name; 
    private byte[] bytes; 

    ClassByte(String name_, byte[] bytes_) 
    { 
    name = name_; 
    bytes = bytes_; 
    } 

    public String getName() 
    { 
    return name; 
    } 

    public byte[] getBytes() 
    { 
    return bytes; 
    } 
} 

Answer 5

La risposta di Alex è corretta ma se si ha una relazione di ereditarietà tra classi è necessario assicurarsi di caricare prima la classe genitore. In caso contrario, il programma di caricamento classi non sarà in grado di definirlo.