手写JDK动态代理实现原理

JDK动态代理生成对象的步骤;
1.获取被代理对象的引用,并且通过反射获取它的所有接口
2.重新生成新的类,实现被代理类的接口
3.动态生成java代码
4.编译java代码,生成class文件
5.重新加载到JVM中运行

以下为实例代码

public interface IAnimal {
    /**
     *  运动
     */
    void motion();
}

public class Cat implements IAnimal {

    @Override
    public void motion() {
        System.out.println("cat motion");
    }
}

/**
 * Animal 代理类
 */
public class AnimalInvocationHandle implements InvocationHandler {
    private Object object;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        method.invoke(object, args);
        after();
        return object;
    }

    private void after() {
        System.out.println("执行之后操作..");
    }

    private void before() {
        System.out.println("执行之前操作...");
    }

    public IAnimal getObject(IAnimal animal){
        this.object=animal;
        return (IAnimal) Proxy.newProxyInstance(new ClassLoader(), object.getClass().getInterfaces(), this);
    }
}

/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        IAnimal animal = new AnimalInvocationHandle().getObject(new Cat());
        animal.motion();
    }
}

以上代码中,Proxy,ClassLoader,InvocationHandler 引用下面自己写的代码类

public class ClassLoader extends java.lang.ClassLoader {

    private File classPathFile;
    public ClassLoader(){
        String classPath = ClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }

    @Override
    protected Class<?> findClass(String name) {

        String className = ClassLoader.class.getPackage().getName() + "." + name;
        if(classPathFile  != null){
            File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
            if(classFile.exists()){
                FileInputStream in;
                ByteArrayOutputStream out;
                try{
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte [] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1){
                        out.write(buff,0,len);
                    }
                    return defineClass(className,out.toByteArray(),0,out.size());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

public interface InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

/**
 * 用来生成源代码的工具类
 */
public class Proxy {

    private static final String LN = "\r\n";

    public static Object newProxyInstance(ClassLoader classLoader, Class<?>[] interfaces, InvocationHandler h) {
        try {
            //1、动态生成源代码.java文件
            String src = generateSrc(interfaces);
            //2、Java文件输出磁盘
            String filePath = Proxy.class.getResource("").getPath();
            File f = new File(filePath + "$Proxy0.java");
            FileWriter fw = new FileWriter(f);
            fw.write(src);
            fw.flush();
            fw.close();

            //3、把生成的.java文件编译成.class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manage = compiler.getStandardFileManager(null, null, null);
            Iterable iterable = manage.getJavaFileObjects(f);

            JavaCompiler.CompilationTask task = compiler.getTask(null, manage, null, null, null, iterable);
            task.call();
            manage.close();

            //4、编译生成的.class文件加载到JVM中来
            Class<?> proxyClass = classLoader.findClass("$Proxy0");
            Constructor<?> c = proxyClass.getConstructor(InvocationHandler.class);
            f.delete();

            //5、返回字节码重组以后的新的代理对象
            return c.newInstance(h);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 生成java文件
     */
    private static String generateSrc(Class<?>[] interfaces) {
        StringBuilder sb = new StringBuilder();
        sb.append(Proxy.class.getPackage()).append(";").append(LN);
        sb.append("import ").append(interfaces[0].getName()).append(";").append(LN);
        sb.append("import java.lang.reflect.*;" + LN);
        sb.append("public class $Proxy0 implements ").append(interfaces[0].getName()).append("{").append(LN);
        sb.append("InvocationHandler h;" + LN);
        sb.append("public $Proxy0(InvocationHandler h) { " + LN);
        sb.append("this.h = h;");
        sb.append("}" + LN);
        for (Method m : interfaces[0].getMethods()) {
            Class<?>[] params = m.getParameterTypes();

            StringBuilder paramNames = new StringBuilder();
            StringBuilder paramValues = new StringBuilder();
            StringBuilder paramClasses = new StringBuilder();

            for (int i = 0; i < params.length; i++) {
                Class<?> clazz = params[i];
                String type = clazz.getName();
                String paramName = toLowerFirstCase(clazz.getSimpleName());
                paramNames.append(type).append(" ").append(paramName);
                paramValues.append(paramName);
                paramClasses.append(clazz.getName()).append(".class");
                if (i > 0 && i < params.length - 1) {
                    paramNames.append(",");
                    paramClasses.append(",");
                    paramValues.append(",");
                }
            }

            sb.append("public ").append(m.getReturnType().getName()).append(" ").append(m.getName()).append("(").append(paramNames.toString()).append(") {").append(LN);
            sb.append("try{" + LN);
            sb.append("Method m = ").append(interfaces[0].getName()).append(".class.getMethod(\"").append(m.getName()).append("\",new Class[]{").append(paramClasses.toString()).append("});").append(LN);
            sb.append(hasReturnValue(m.getReturnType()) ? "return " : "").append(getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})", m.getReturnType())).append(";").append(LN);
            sb.append("}catch(Error _ex) { }");
            sb.append("catch(Throwable e){" + LN);
            sb.append("throw new UndeclaredThrowableException(e);" + LN);
            sb.append("}");
            sb.append(getReturnEmptyCode(m.getReturnType()));
            sb.append("}");
        }
        sb.append("}" + LN);
        return sb.toString();
    }


    private static Map<Class<Integer>, Class<Integer>> mappings = new HashMap<Class<Integer>, Class<Integer>>();

    static {
        mappings.put(int.class, Integer.class);
    }

    private static String getReturnEmptyCode(Class<?> returnClass) {
        if (mappings.containsKey(returnClass)) {
            return "return 0;";
        } else if (returnClass == void.class) {
            return "";
        } else {
            return "return null;";
        }
    }

    private static String getCaseCode(String code, Class<?> returnClass) {
        if (mappings.containsKey(returnClass)) {
            return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()";
        }
        return code;
    }

    private static boolean hasReturnValue(Class<?> clazz) {
        return clazz != void.class;
    }

    private static String toLowerFirstCase(String src) {
        char[] chars = src.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }

}