深入理解【代理模式】原理与技术

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。

23种常用的面向对象软件的设计模式之一。 代理模式分为静态代理、动态代理。

如何理解代理模式？

思考抽象问题最好的办法就是具体化！

比如我们需要为一个业务方法在执行前后记录日志，为了达到解耦的目的，我们可以再新建一个类并定义一个新的业务方法，该方法既可以调用原业务方法，又可以在调用前后进行日志处理，例如：

    carproxy.class

    public void move() {
        system.out.println("日志开始记录....");
        new car().move();
        system.out.println("日志记录完成....");
    }

代理模式的应用很多，比如spring容器的延迟加载，aop增强处理等。

一：静态代理

静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。

所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

一句话，自己手写代理类就是静态代理。

基于继承的静态代理

目标对象

public class car {

    public void move() {
        system.out.println("1.汽车开始跑步");
        system.out.println("2.汽车跑到了终点");
    }

}

代理对象

public class carproxy extends car {

    @override
    public void move() {
        system.out.println("日志开始记录....");
        super.move();
        system.out.println("日志记录完成....");
    }

}

测试方法

    public static void main(string[] args) {
        car car = new carproxy();
        car.move();
    }

基于接口的静态代理

共同接口

public interface moveable {
    void move();
}

目标对象

public class car implements moveable {

    @override
    public void move() {
        system.out.println("汽车行驶中....");
    }

}

代理对象

public class carproxy implements moveable{
    private moveable move;
    
    @override
    public void move() {
        if(move==null){
            move = new car();
        }
        system.out.println("开始记录日志：");
        move.move();
        system.out.println("记录日志结束！");
         
    }
}

测试方法

    public static void main(string[] args) throws exception {
        moveable m =new carproxy();
        m.move();
    }

静态代理的优缺点

优点：

业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。

缺点：

1）代理对象的一个接口只服务于一种类型的对象，如果要代理的类型很多，势必要为每一种类型的方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

• 比如car类的move()方法需要记录日志，如果还有汽车，火车，自行车的move()方法也需要记录日志，我们都要一个个的去为它们生成代理类，太麻烦了。

2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。 

二：动态代理

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

动态代理类的源码是在程序运行期间由jvm根据反射等机制动态的生成 。

简单来说，动态代理就是交给程序去生成代理类。

jdk的动态代理

jdk动态代理实现步骤：

1. 创建被代理的类以及实现的接口；
2. 创建一个实现接口invocationhandler的类，它必须实现invoke方法；

3. 调用proxy的静态方法，创建一个代理类：

   newproxyinstance(classloader loader,class[] interface,invocationhandler h); 

4. 通过代理对象调用目标方法。

代码示例

共同接口

public interface moveable {
    string move();
}

目标对象

public class car implements moveable {

    @override
    public string move() {
        return "汽车行驶中";
    }

}

每个代理对象都有一个关联的调用处理程序。当在代理对象上调用目标方法时，将对方法调用进行编码并将其分配给其实现invocationhandler接口的invoke方法。

实现invocationhandler接口步骤：

1. 定义含参构造方法，该参数为要代理的实例对象，目的是用于执行method.invoke()方法（也就是执行目标方法）

2. 实现接口的invoke()方法，该方法用于对目标方法的增强处理，比如记录日志等。该方法的返回值就是代理对象执行目标方法的返回值。具体参数：

   proxy 动态生成的代理对象

   method 目标方法的实例

   args 目标方法的参数

public class loghandler implements invocationhandler{
    private object target;
    
    public loghandler(object object){
        super();
        this.target =  object;
    }

    @override
    public object invoke(object proxy, method method, object[] args) throws throwable {
        //增强处理
        object o = method.invoke(target,args);
        //增强处理
        return o;
    }

}

通过调用proxy.newproxyinstance方法生成代理对象，具体参数有：

1. loader 目标类的类加载器
2. interfaces 目标类实现的接口
3. invocationhandler 调用处理程序的实现对象

public static void main(string[] args) {
    moveable move =  (moveable) proxy.newproxyinstance(car.class.getclassloader(), car.class.getinterfaces(), new loghandler(new car()));
    
    system.out.println("代理对象:"+move.getclass().getname());
    system.out.println("执行方法:"+move.move());
}

打印结果

代理对象:com.sun.proxy.$proxy0
执行方法:汽车行驶中

总结

jdk的动态代理只能代理实现了接口的类， 没有实现接口的类不能实现动态代理。

---

cglib的动态代理

引用cglib的依赖包

<dependency>
    <groupid>cglib</groupid>
    <artifactid>cglib-nodep</artifactid>
    <version>2.2</version>
</dependency>

为了方便思考它的原理，我把执行步骤按顺序写下

    public static void main(string[] args) {
        enhancer enhancer = new enhancer();
        //设置父类，被代理类（这里是car.class）
        enhancer.setsuperclass(car.class);
        //设置回调函数
        enhancer.setcallback(new methodinterceptor() {
            @override
            public object intercept(object obj, method method, object[] args, methodproxy proxy) throws throwable {
                //增强处理...
                object o= proxy.invokesuper(obj, args);//代理类调用父类的方法
                //增强处理...
                return o;
            }
        });
        //创建代理类并使用回调（用父类car去引用）
        car car = (car) enhancer.create();
        //执行目标方法
        system.out.println(car.move());
    }

方法拦截器

实现methodinterceptor接口的intercept方法后，所有生成的代理方法都调用这个方法。

intercept方法的具体参数有

1. obj 目标类的实例
2. method 目标方法实例（通过反射获取的目标方法实例）
3. args 目标方法的参数
4. proxy 代理类的实例

该方法的返回值就是目标方法的返回值。

总结

1. cglib的动态代理是针对类来实现代理。
2. 对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用。
3. 因为是通过继承实现，final类无法使用。

三：手写jdk动态代理源码

从上面可以看到jdk动态代理的核心代码在于proxy.newproxyinstance方法。

moveable m = (moveable)proxy.newproxyinstance(car.class,new invocationhandler());

实现原理

1. 声明一段源码，源码动态产生动态代理
2. 源码产生java文件，对java文件进行编译
3. 得到编译生成后的class文件
4. 把class文件load到内存之中，产生代理类对象返回即可。

下面附我手写的源码！

生产代理对象类，核心类！难点，思路都在这里~

public class proxy {

    /**
     * 生产代理对象
     * @param clazz
     * @param h
     * @return
     * @throws exception
     */
    public static object newproxyinstance(class clazz,invocationhandler h) throws exception{
        //代理类类名
        string cname = clazz.getname().substring(clazz.getname().lastindexof(".")+1) + "$proxy0";
        //手写代理类源码
        stringbuilder source = getsource(clazz, h, cname);
        //产生代理类的java文件
        string filename = thread.currentthread().getcontextclassloader().getresource("").getpath()
                + clazz.getpackage().getname().replaceall("\\.", "/") +"/"+cname+".java";
        system.out.println(filename);
        //把源码写入到文件中
        file file = new file(filename);
        fileutil.writestringtofile(file, source.tostring());
        //编译
        //拿到编译器
        javacompiler complier = toolprovider.getsystemjavacompiler();
        //文件管理者
        standardjavafilemanager filemgr =
                complier.getstandardfilemanager(null, null, null);
        //获取文件
        iterable units = filemgr.getjavafileobjects(filename);
        //编译任务
        compilationtask t = complier.gettask(null, filemgr, null, null, null, units);
        //进行编译
        t.call();
        filemgr.close();
        //load 到内存
        classloader cl = classloader.getsystemclassloader();
        class<?> c = cl.loadclass(clazz.getpackage().getname() + "."+cname);
        //获取构造函数constructor
        constructor<?> ctr = c.getconstructor(h.getclass());
        return ctr.newinstance(h);
    }

    /**
     * 手写代理类源码
     * @param clazz
     * @param h
     * @param cname
     * @return
     */
    private static stringbuilder getsource(class clazz, invocationhandler h, string cname) {
        //调用处理接口
        string handler = h.getclass().getname();
        //换行符号
        string line = "\r\n";
        string space = " ";
        //代理类源码
        stringbuilder source = new stringbuilder();
        //包声明
        source.append("package" + space + clazz.getpackage().getname() + ";").append(line);
        //获取类的名称
        source.append(modifier.tostring(clazz.getmodifiers()) + space + "class" + space + cname + space);
        //继承接口
        source.append("implements" + space);
        class[] interfaces = clazz.getinterfaces();
        for (int i = 0; i < interfaces.length; i++) {
            source.append(interfaces[i].getname());
            if (i != interfaces.length - 1) {
                source.append(",");
            }
        }
        source.append("{").append(line);
        //声明变量
        source.append("private " + handler + " h;").append(line);
        //构造方法
        source.append("public " + cname + "(" + handler + " h){").append(line);
        source.append("this.h=h;").append(line).append("}").append(line);
        //实现所有方法
        method[] methods = clazz.getdeclaredmethods();
        for (method method : methods) {
            //获取方法返回类型
            class returntype = method.getreturntype();
            //获取方法上的所有注释
            annotation[] annotations = method.getdeclaredannotations();
            for (annotation annotation : annotations) {
                //打印注释类型
                source.append("@" + annotation.annotationtype().getname()).append(line);
            }
            //打印方法声明
            source.append(modifier.tostring(method.getmodifiers()) + " " + returntype.getname() + " " + method.getname() + "(");
            //获取方法的所有参数
            parameter[] parameters = method.getparameters();
            //参数字符串
            stringbuilder args = new stringbuilder();
            for (int i = 0; i < parameters.length; i++) {
                //参数的类型，形参（全是arg123..）
                source.append(parameters[i].gettype().getname() + " " + parameters[i].getname());
                args.append(parameters[i].getname());
                if (i != parameters.length - 1) {
                    source.append(",");
                    args.append(",");
                }
            }
            source.append("){").append(line);
            //方法逻辑
            source.append("object obj=null; \n try {").append(line);
            source.append("class[] args = new class[]{" + args + "};").append(line);
            source.append(method.class.getname()+" method = " + clazz.getname() + ".class.getmethod(\"" + method.getname() + "\",args);").append(line);
            source.append("obj = h.invoke(this,method,args);").append(line);
            source.append("} catch (exception e) {\n" + "e.printstacktrace();\n" + "}catch (throwable throwable) {\n" +
                    "throwable.printstacktrace();\n" + "}").append(line);
            //方法结束
            source.append("return (obj!=null)?("+returntype.getname()+")obj:null;\n}").append(line);
        }
        //类结束
        source.append("}");
        return source;
    }


}

单元测试

    public static void main(string[] args) throws exception {
        moveable m = (moveable) proxy.newproxyinstance(car.class, new timehandler(new car()));
        string s = m.move();
        system.out.println(s);
    }

测试结果

/d:/idea/workspace/myjdkproxy/target/classes/cn/zyzpp/client/car$proxy0.java
开始记录时间
汽车行驶中....
耗时：481毫秒！
success

我只测试了部分，有bug在所难免啦~~~！

项目地址：github 既然看到这里了，不如在下面点个赞吧!

---