自己实现JDK的Proxy

1.动态代理，就是在运行期间动态生成一个代理类，通过代理类来调用我们主题类的方法(本文不讲动态代理模式，要自己先了解清楚)。所以首先我们得搞清楚怎么动态生成类，这里我用到的是jdk自带的javax.tools里面的 JavaCompiler等工具。

2.动态生成类，下面是我封装好的一个工具代码：

public class CompilerTool {

    /**
     * 编译生成class类对象
     * @param packageName 包名
     * @param className class文件的名称
     * @param classContent java代码内容
     * @return
     */
    public static Class<?> compiler(String packageName , String className , String javaSrcContent){
        // 生成源代码的JavaFileObject
        SimpleJavaFileObject fileObject = new JavaSourceFromString(
                className, javaSrcContent);
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        // 被修改后的JavaFileManager
        JavaFileManager fileManager = new ClassFileManager(
                compiler.getStandardFileManager(null, null, null));
        // 执行编译
        JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager,
                null, null, null, Arrays.asList(fileObject));
        task.call();
        // 获得ClassLoader，加载class文件
        ClassLoader classLoader = fileManager.getClassLoader(null);
        try {
            String c = packageName+"."+className ;
            return classLoader.loadClass(c);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null ;
    }

    static class JavaSourceFromString extends SimpleJavaFileObject {
        final String code;
        JavaSourceFromString(String name, String code) {
            super(URI.create("string:///" + name.replace('.', '/')
                    + Kind.SOURCE.extension), Kind.SOURCE);
            this.code = code;
        }
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return code;
        }
    }
    static class JavaClassFileObject extends SimpleJavaFileObject {
        // 用于存储class字节
        ByteArrayOutputStream outputStream;

        public JavaClassFileObject(String className, Kind kind) {
            super(URI.create("string:///" + className.replace('.', '/')
                    + kind.extension), kind);
            outputStream = new ByteArrayOutputStream();
        }

        @Override
        public OutputStream openOutputStream() throws IOException {
            return outputStream;
        }

        public byte[] getClassBytes() {
            return outputStream.toByteArray();
        }
    }
    @SuppressWarnings("rawtypes")
    static class ClassFileManager extends ForwardingJavaFileManager {
        private JavaClassFileObject classFileObject;
        @SuppressWarnings("unchecked")
        protected ClassFileManager(JavaFileManager fileManager) {
            super(fileManager);
        }
        @Override
        public JavaFileObject getJavaFileForOutput(Location location,
                String className, JavaFileObject.Kind kind, FileObject sibling)
                throws IOException {
            classFileObject = new JavaClassFileObject(className, kind);
            return classFileObject;
        }
        @Override
        // 获得一个定制ClassLoader，返回我们保存在内存的类
        public ClassLoader getClassLoader(Location location) {
            return new ClassLoader() {
                @Override
                protected Class<?> findClass(String name)
                        throws ClassNotFoundException {
                    byte[] classBytes = classFileObject.getClassBytes();
                    return super
                            .defineClass(name, classBytes, 0, classBytes.length);
                }
            };
        }
    }
}

测试上面工具类：

public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        String java = "public class Aa{static{System.out.println(\"aaaa被动态加载了\");}}" ;

        Class<?> aa = CompilerTool.compiler("Aa", java) ;
        aa.newInstance();
    }
    //结果：aaaa被动态加载了

3.下面根据jdk的proxy简单实现下，注意是简单实现，不包括jdk的优化代理类缓存等。（ps:jdk动态生成类的技术肯定不是用的上述动态生成类的技术，我们这里只是模拟思想）

首先上jdk的InvocationHandler

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object... args)
            throws Exception;
}

重要角色Proxy类

public class Proxy{
    public static Object newProxyInstance(InvocationHandler invocationHandler , Class<?>[] interfaces){
        //代理类的随机名称
        String targetName = "$Proxy"+new Random().nextInt(10); 
        // 存储 代理类 的 java代码字符串
        StringBuilder proxyContent = new StringBuilder();
        //--------- 包名  :　　package 抽象主题接口的包 一致
        proxyContent.append("package "+interfaces[0].getPackage().getName() + ";");
        //--------- import 的一些必须
        for(Class<?> clazz : interfaces){
            proxyContent.append("import ").append(clazz.getName()).append(';');
        }
        proxyContent.append("import java.lang.reflect.Method;");
        //--------- 头部 ：  public class $Proxy implements xxx1,xx2{
        proxyContent.append("public class ").append(targetName).append(" implements ");
        for(int i=0;i<interfaces.length;i++){
            if(i == interfaces.length - 1){ // 最后一个
                proxyContent.append(interfaces[i].getSimpleName());
                break;
            }
            proxyContent.append(interfaces[i].getSimpleName()).append(",");
        }
        proxyContent.append("{") ;
        //---------成员变量 InvocationHandler handler ;
        proxyContent.append("InvocationHandler handler;");
        //---------构造函数 
        proxyContent.append("public ").append(targetName).append("(InvocationHandler handler){this.handler=handler;}") ;
        // 一个接口一个接口找
        for(Class<?> inter : interfaces){
            //---------要实现的所有的方法,看抽象主题接口，有什么就都要实现
            for(Method method :inter.getDeclaredMethods()){
                method.setAccessible(true) ;

                proxyContent.append("public ").append(method.getReturnType().getName()).append(' ');
                proxyContent.append(method.getName()).append('(');
                // 构造 方法参数列表
                Class<?>[] parameterTypes = method.getParameterTypes() ;
                String ps = null ;
                for(int i=0;i<parameterTypes.length;i++){
                    if(i == parameterTypes.length - 1){
                        proxyContent.append(parameterTypes[i].getName()).append(" p").append(i);
                        ps += "p"+i;
                        break;
                    }
                    proxyContent.append(parameterTypes[i].getName()).append(" p").append(i).append(",");
                    ps += "p"+i+",";
                }
                // 方法里面 得反射调用 客户端 主题接口 的实现类 的 同样的方法
                proxyContent.append("){try{").append("Method md="+inter.getName()+".class.getMethod(\""+method.getName()+"\");");
                if(ps == null){
                    proxyContent.append("this.handler.invoke(this,"+"md"+");}catch(Exception e){e.printStackTrace();}}");
                }else{
                    proxyContent.append("this.handler.invoke(this,"+"md"+ps+");}catch(Exception e){e.printStackTrace();}}");
                }
            }
        }
        proxyContent.append('}');
        System.out.println(proxyContent);
        Object proxy = null ;  //代理对象
        try {
            Class<?> pClass = CompilerTool.compiler(interfaces[0].getPackage().getName(),targetName, proxyContent.toString()) ;
            // 调用上面动态 类的 构造器 , 生成代理类对象
            proxy = pClass.getDeclaredConstructor(InvocationHandler.class).newInstance(invocationHandler);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return proxy;
    }
}

//上面字符串拼接的类实际上是生成了类似下面格式的类（假如随机名称是$Proxy5,包名:test.proxy,主题接口名：HttpSubject，主题接口只有一个方法：http，下面会有例子）：
package test.proxy;

import test.proxy.HttpSubject;
import java.lang.reflect.Method;

public class $Proxy5 implements HttpSubject {
    InvocationHandler handler;

    public $Proxy5tt(InvocationHandler handler) {
        this.handler = handler;
    }

    public void http() {
        try {
            Method md = test.proxy.HttpSubject.class.getMethod("http");
            this.handler.invoke(this, md);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

好了，jdk的工具实现完了，下面来举个代理模式的例子：

//这个使我们要代理 的 抽象主题
public interface HttpSubject{
    public void http();
}
//抽象主题的实现类
class HttpSubjectImpl implements HttpSubject{
    @Override
    public void http() {
        System.out.println("=========http========");
    }
}
//动态代理
class DynamicSubject implements InvocationHandler{
    Object subject ;
    public DynamicSubject(Object subject ) {
        this.subject = subject ;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object... args)
            throws Exception {
        return method.invoke(subject, args);
    }
}
//测试
    public static void main(String[] args) throws Exception {
        HttpSubject subject = new HttpSubjectImpl();
        InvocationHandler handler = new DynamicSubject(subject);

        long start = System.currentTimeMillis();
        HttpSubject proxy = (HttpSubject) Proxy.newProxyInstance(handler, subject.getClass().getInterfaces());
        System.out.println("动态生成时间："+ (System.currentTimeMillis()-start));
        proxy.http();
    }
    //测试结果：（时间太长了）
    动态生成时间：641
    =========http========

今天就到这里，谢谢大家！

老生常谈：深圳有爱好音乐的会打鼓（吉他，键盘，贝斯等）的程序员和其它职业可以一起交流加入我们乐队一起嗨。我的QQ：657455400