Java: ¿Cómo cargar la clase almacenada como byte [] en la JVM?

Question

Si se ha serializado todo el archivo .class en byte [], y suponiendo que se conoce el nombre de la clase (pasado junto con el byte []), cómo se convierte byte [] -> Class -> luego se carga a la JVM para que luego pueda usarlo llamando a Class.forName()?

NOTA: que estoy haciendo esto porque me envió el .class a otro host, y JVM del anfitrión no sabe nada de este .class.

Answer 1

En realidad estoy usando algo como esto ahora en una prueba para dar un conjunto de definiciones de clases como byte [] a un cargador de clases:

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

Extienda ClassLoader y luego implemente la llamada necesaria para obtener su byte[] dentro del método defineClass(). Por el contrario, puede hacer esto en findClass(). De este modo, cargará este ClassLoader al principio o lo empleará cuando necesite definiciones de clase a través de su matriz.

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

Uso del (int, String, byte [], int) método defineClass de ClassLoader

Answer 4

bien, así que aquí es lo que hice:

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

espero que carga la clase en JVM? Si esto realmente funciona, ¿por qué el implementador Java no definió los métodos públicos defineClass y resolveClass? Realmente me pregunto qué estaban pensando. ¿Alguien puede iluminarme?

simplemente para la corrección, aquí está 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 respuesta de Alex es correcta, pero si tiene una relación de herencia entre clases, primero debe asegurarse de cargar la clase principal. De lo contrario, el cargador de clases no podrá definirlo.