Caricare la matrice di byte del file nella memoria

Question

Sto provando a caricare un file jar direttamente nella memoria senza rilasciarlo sull'HDD. Ho provato a utilizzare ClassLoader, ma ottengo un errore.

Questo è il mio codice:

personalizzato programma di caricamento classi

public class CLS_ClassLoader extends ClassLoader { 

    private byte[] bArrData; 

    public CLS_ClassLoader(ClassLoader parent, byte[] bArrData) { 
     super(parent); 

     this.bArrData = bArrData; 
    } 

    public Class<?> loadClass(String name) throws ClassNotFoundException { 
     return defineClass(name, bArrData, 0, 
       bArrData.length); 
    } 
} 

principale

ClassLoader tParentClsLoader = CLS_ClassLoader.class.getClassLoader(); 
CLS_ClassLoader tClsLoader = new CLS_ClassLoader(tParentClsLoader, fileToByteArray("D:/App.jar")); 
Class<?> tClass = null; 

try { 
     tClass = tClsLoader.loadClass("pkg_main.CLS_Main"); 
} catch (ClassNotFoundException e) { 
    e.printStackTrace(); 
} 

uscita

Exception in thread "main" java.lang.ClassFormatError: Incompatible magic value 1347093252 in class file pkg_main/CLS_Main 
    at java.lang.ClassLoader.defineClass1(Native Method) 
    at java.lang.ClassLoader.defineClass(Unknown Source) 
    at java.lang.ClassLoader.defineClass(Unknown Source) 
    at pkg_main.CLS_ClassLoader.loadClass(CLS_ClassLoader.java:20) 
    at pkg_main.CSL_Main.main(CSL_Main.java:27) 

La mia idea è di prendere un file jar crittografato, decrittarlo in fase di runtime e caricare direttamente in memoria.

Siamo spiacenti per gli errori di battitura, non ho parlato bene l'inglese. Grazie in anticipo!

Answer 1

L'errore principale è che defineClass (...) si aspetta byte di classe e lo si sta alimentando con l'intero file jar. L'eccezione effettiva viene generata se i byte di classe non iniziano con 0xCAFEBABE, intestazione tipica del file di classe Java. Quindi, è necessario un ulteriore passaggio per ordinare le classi dal file jar. La seguente implementazione dimostra l'idea:

class CCLoader extends ClassLoader { 
    private Map<String, byte[]> classes = new HashMap<String, byte[]>(); 

    public CCLoader(InputStream in) { 
     super(CCLoader.class.getClassLoader()); 
     try { 
      JarInputStream jis = new JarInputStream(in); 
      JarEntry je = null; 
      String entryName = null; 
      while ((je = jis.getNextJarEntry()) != null) { 
       entryName = je.getName(); 
       if (je.getName().endsWith(".class")) { 
        byte[] classBytes = readClass(jis); 
        String canonicalName = entryName.replaceAll("/", ".").replaceAll(".class", ""); 
        classes.put(canonicalName, classBytes); 
       } 
      } 
      jis.close(); 
      in.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    private byte[] readClass(InputStream stream) throws IOException { 
     ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
     while(true){ 
      int qwe = stream.read(); 
      if(qwe == -1) break; 
      baos.write(qwe); 
     } 
     return baos.toByteArray(); 
    } 

    public Class loadClass(String name) throws ClassNotFoundException { 
     try { 
      return this.getParent().loadClass(name); 
     } catch (ClassNotFoundException e) { 
      return findClass(name); 
     } 
    } 

    public Class findClass(String name) throws ClassNotFoundException { 
     byte[] classBytes = classes.get(name); 
     return defineClass(name, classBytes, 0, classBytes.length); 
    } 

} 

Seguendo il tuo esempio si può provare così:

ClassLoader tClsLoader = new CCLoader(new FileInputStream("C:/commons-io-2.0.1.jar")); 
Class<?> tClass = tClsLoader.loadClass("org.apache.commons.io.FileExistsException");