通过自定义类加载器进行动态编译与动态实现接口

两种动态加载类的方法
1. 使用java.lang.Class.forName(fullClassName ).
2. 使用自定义类加载器.
这里看看如何通过自定义加载器来进行java类加载.

通过默认使用的类加载器来加载类,一般都是通过如下方法:

Class obj = aLoader.loadClass(customFullClassName, true);

看一下loadClass方法的实现:

protected synchronized Class<?> loadClass(String name, boolean resolve) 
    throws ClassNotFoundException 
    { 
    Class c = findLoadedClass(name); 
    …………… 
……… 
}

这是一个采用双亲委派机制的实现,最主要的就是一个findLoadedClass方法,其它就是递归找父亲了..
所以要进行自定义扩展,就要从这个方法入手.
findLoadClass的默认实现如下:
这里我们看到了一个最让我们感兴趣的方法: defineClass
protected final Class<?> defineClass(String name, byte[] b, int off, int len);
这个方法将一个字节数据转换成一个Class并初始化.
当然如果不能转换的话,异常: ClassFormatError.

所以我们就有了一个自由加载文件系统中任意合法类文件的思路了.
写一个类继承ClassLoader-—将文件系统中的*.class文件以byte[]的方式传入---交给defineClass处理. 这样的做法似乎破坏了Java的双亲委派

所以类定义如下:

/** 
 * 一个自定义的类加载器. 
 * @author nileader 
 */ 
public class CustomClassLoader extends ClassLoader { 
 
    public static final String classPath = System.getProperty("user.dir") + "\\bin\\"; 
 
    /** 
     * 自定义的一个加载方法,这样的做法似乎破坏了Java的双亲委派 
     * @param classFullName 
     * @return 
     */ 
    protected Class customLoadClass(String classFullName){ 
        String filePath = classFullName2FileName(classFullName, classPath); 
        byte[] data = loadClassFromFS(filePath ); 
        //调用defineClass将一个字节数据转换成一个类并进行初始化工作. 
        return defineClass(classFullName, data, 0, data.length); 
    } 
 
    /** 
     * 从文件系统中加载类文件,生成一个byte[]. 
     * @param name   文件路径 
     * @return   类文件的字节码数组 
     */ 
    private byte[] loadClassFromFS(String filePath) { 
        FileInputStream fis = null; 
        byte[] byteSource = null; 
        try { 
            fis = new FileInputStream(new File(filePath ) ); 
            ByteArrayOutputStream tempSource = new ByteArrayOutputStream(); 
            int readChar= 0; 
            while ((readChar = fis.read()) != -1) { 
                tempSource.write(readChar ); 
            } 
            byteSource = tempSource.toByteArray(); 
        } catch (IOException e) { 
            //IO出错 
        } 
        return byteSource; 
    } 
     
    /** 
     * 将一个完整类名转换为一个当前工程classpath为基础的文件路径. 
     * @param classFullName     一个完整类名 
     * @param classPath         当前工程类路径 
     * @return 
     */ 
    public String classFullName2FileName(String classFullName, String classPath){ 
        classFullName = classFullName.replaceAll("[.]", "\\\\" ); 
        return classPath  + classFullName + ".class"; 
    }

现在,就可以使用修改后的类加载器来进行类的加载了.

CustomClassLoader customClassLoader = new CustomClassLoader(); 
 
Class obj = customClassLoader.customLoadClass("com.test.DemoInterface" );

加载完后就可以Class、Field和Method的一些方法来进行接口的“实现”.
方法很多.
这里所谓的”实现”是: 就是根据程序运行过程中的一些需求,进行具体方法的写. 如:
动态编译
动态编译的过程是:

生成一个临时的*.java文件, 使用com.sun.tools.javac.Main来模拟命令行中的java文件编译.

/** 
     * 将Java源程序生成一个类文件. 
     *  
     * @param sourceCode 
     *            要编译的Java源程序 
     * @throws Exception 
     */ 
    public static boolean compile(String sourceCode, String className) { 
        File file = null; 
        // 生成一个临时的*.java文件. 
        try { 
            file = File.createTempFile("JavaRuntime", ".java", new File( 
                    targetPath)); 
        } catch (IOException e) { 
            // 发生IO异常 
        } 
        String fileName = null; 
        if (null != file) { 
            // 取得类名 
            fileName = file.getName(); 
            file.deleteOnExit(); 
        } 
 
        // 将代码输出到java文件中去. 
        PrintWriter out = null; 
        try { 
            out = new PrintWriter(new FileOutputStream(file)); 
        } catch (FileNotFoundException e) { 
            // 发生 FileNotFoundException 异常. 
        } 
        if (null != out) { 
            out.write(sourceCode); 
            out.flush(); 
            out.close(); 
        } 
 
        /** 开始编译 */ 
        if (fileName != null) { 
            Main.compile(new String[] { "-d", 
                    System.getProperty("user.dir") + "\\bin\\", 
                    targetPath + fileName }); 
        } 
 
        return true; 
 
    }

生成好之后,就可以用同样的方式进行实现类的加载,通过如下方式进行

Class c1 = customClassLoader.customLoadClass(implementsFullName); 
        Constructor con = c1.getDeclaredConstructor(); 
        con.setAccessible(true ); 
        Object o = con.newInstance(); 
        // 调用封装bean的方法 
        Method method = c1.getMethod("print"); 
        method.setAccessible(true); 
        method.invoke(o);

本文出自 “专栏：Paxos与ZooKeeper” 博客，请务必保留此出处http://nileader.blog.51cto.com/1381108/307975