阅读 27

代理设计模式

代理设计模式

传送门

  • 模拟计算面试时间
  • 创建一个接口
//面试
public interface InterView {
    void chatting();
}
复制代码
  • 真实对象实现接口
public class Persion implements InterView{
    @Override
    public void chatting() {
        System.out.println("is chatting ...");
        try {
            //模拟面试时间
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码
  • 用Thread.sleep()模拟面试的时间,那么我如果想知道这个时间怎么做
public class Persion implements InterView{
    @Override
    public void chatting() {
        Long start = System.currentTimeMillis();
        System.out.println("is chatting ...");
        try {
            //模拟面试时间
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Long end = System.currentTimeMillis();
        System.out.println("chatting time: " + (end - start) );
    }
}
复制代码
  • 很简单,在方法的前后捕捉当前时间,相减就出来了
  • 如果这个方法来自三方库没有改动源码的权限,怎么办

  • 我们可以使用继承,重写他的方法
public class Persion2 extends Persion {
    @Override
    public void chatting() {
        long start = System.currentTimeMillis();
        super.chatting();
        long end = System.currentTimeMillis();
        System.out.println("chatting time : " + (end - start));
    }
}
复制代码
  • 我们也可以使用聚合(注入),同时也实现面试的接口
public class Person3 implements InterView {

    private Person person;

    public Person3(Person person){
        this.person = person;
    }

    @Override
    public void chatting() {
        long start = System.currentTimeMillis();
        person.chatting();
        long end = System.currentTimeMillis();
        System.out.println("chatting time : " + (end - start));
    }
}
复制代码
  • 这两种方法都可以实现计算面试时间,哪种好点呢
  • 我们继续增加需求,如果我还要在面试前后做记录(打印日志)呢,很简单,继承person2,并在前后添加打印日志即可
  • 如果我要改变执行顺序呢,先获取时间,再打印日志呢,可以再用一个继承类,重写方法,这样会导致无限扩增
  • 那前面提到的聚合(注入)不会有这样的问题吗,只要稍微改一下就可以,把注入的Person修改为InterView接口
public class Person3 implements InterView {

    private InterView interView;
    
    public Person3(InterView interView){
        this.interView = interView;
    }

    @Override
    public void chatting() {
        long start = System.currentTimeMillis();
        interView.chatting();
        long end = System.currentTimeMillis();
        System.out.println("chatting time : " + (end - start));
    }
}
复制代码
  • 为了看的更清楚,将P3改为PersonProxy,用于获取方法执行时间代理的意思,同时新建PersonLogProxy代理类用于打印日志
public class PersonLogProxy implements Interview {
    private Interview interview;

    public PersonLogProxy(Interview interview) {
        this.interview = interview;
    }

    @Override
    public void chatting() {
        System.out.println("chatting start...");
        interview.chatting();
        System.out.println("chatting end...");
    }
}
复制代码
  • 如果要先记录日志,再获取面试时间,可以这样做
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        PersonLogProxy p1 = new PersonLogProxy(person);
        PersonProxy p2 = new PersonProxy(p1);
        p2.chatting();
    }

}
复制代码
  • 如果需求变更,反过来,可以这样做
public class Test {
    public static void main(String[] args) {
        PersonProxy p3 = new PersonProxy(person);
        PersonLogProxy p4 = new PersonLogProxy(p3);
        p4.chatting();

    }
}
复制代码

这里会出现一个问题,从表现来看,聚合可以实现灵活的执行顺序,而继承不可以,为什么

image

  • 继承其实是一种包裹关系,如果要改变顺序,则需要创建新的模板来实现
  • 由于聚合对象和代理对象哦都是先了interView接口,类似继承的包裹关系,可以通过传入不同的interview来改变
  • 这是利用了java多态特性,其实所有的设计模式都或多或少的用到多态

静态代理

在上面的PersonTimeProxy的chatting方法,我们直接调用了interview().chatting,换而言之,PersonProxy代理传入的interview对象,这就是典型的静态代理实现

  • 问题: 如果需要对所有方法都执行这样的操作,同样的代码至少需要重复多少次,同时也多少次创建代理类
    • 如果溶蚀代理多各类,依然导致类无限扩展
    • 如果类中有多个方法,需要反复实现
  • 是否可以用同一个代理类来代理任意对象呢,甚至代理的逻辑也可以自定义

动态代理

jdk动态代理

  • 可以传入任意对象,即动态生成代理对象
  • 可以传入任意方法

image

  • 其实就是通过jdk自带的Proxy.newProxyInstance()方法动态生成代理类,动态编译,在通过反射创建对象并加载到内存中

  • 可以查看一下Proxy->newProxyInstance()的源码,代理类的动态创建通过InvocationHandler自定义

  • 我们可以看一下源码中的InvocationHandler接口

import java.lang.reflect.Method;

/**
 * proxy:指定动态生成的代理类
 * method:接口中传入的所有方法对象
 * args:当前传入方法的参数
 */
public interface InvocationHandler {
    void invoke(Object proxy, Method method,Object[] args);
}

复制代码

使用:

  • 实现InvocationHandler接口
public class MyInvocationHandler implements InvocationHandler {

    //被代理对象,object类型
    private Object target;

    public MyInvocationHandler(Object target){
        this.target = target;
    }

    /**
    *proxy:指定动态生成的代理类,
    *method:接口中传入的对象的所有方法
    *当前传入方法的参数
    */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("chatting start ...");
        Object returnValue = method.invoke(target, args);
        System.out.println("chatting end");
        return returnValue;
    }

}
复制代码
  • 测试
public class DynamicProxyTest {

    public static void main(String[] args) {
        Person person = new Person();
        MyInvocationHandler handler = new MyInvocationHandler(person);
        /**
         * 第一个参数指定代理类的类加载器,这里传入当前测试类加载器
         * 第二个参数是代理类需要实现的接口的实例类
         * 第三个参数是invocation handler,用来处理方法的调用,这里传入自己实现的handler
         */
        InterView proxyObject = (InterView) Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader()
                , person.getClass().getInterfaces(),
                handler);

        proxyObject.chatting();
    }
}
复制代码

此时,整个方法的调用栈变成了这样

image

  • 简而言之就是:

    • 真实的业务类需要实现业务接口,代理类通过反射获取真实业务对象的类加载器,从而在内存中创建一个真实的代理对象(静态代理手动扩展那个),代理类需要实现invocationhandler接口,重写invoke方法,invoke方法三个参数,分别是代理的接口,代理的方法,和方法参数,在该方法里对真实的方法进行包装,实现动态代理
  • 和静态代理的区别:静态代理是自己去创建代理类对象,动态代理本质是在内存中根据传入的参数,动态的生成一个代理类对象,通过生成的class文件反编译可以看到


cglib 动态代理

cglib是针对类来实现代理的,原理是针对指定的业务类生成一个子类,并覆盖其中的业务方法,实现代理,因为用的是继承,所以不能代理final修饰的类

  • 实现MethodInterceptor接口,创建代理类
public class PersonCglib implements MethodInterceptor {

    //业务对象
    private Object target;
    public Object getInstance(Object target){
        this.target = target;
        //创建增强器
        Enhancer enhancer = new Enhancer();
        //指定要代理的类(指定生成子类的父类)
        enhancer.setSuperclass(this.target.getClass());
        //设置回调,对于代理类上所有方法的调用,都会调用callback,所以callback则需要实现intercept()方法进行拦截
        enhancer.setCallback(this);
        //包含三个步骤
        //生成源代码
        //编译成class文件
        //加载到jvm中,创建实例并返回
        return enhancer.create();
    }

    //实现方法回调
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("chatting start");
        //这个obj对象是cglib给我们new出来的
        //cglib new出来的对象是被代理对象的子类(继承了被代理类),继承相当于间接持有父类的引用
        methodProxy.invokeSuper(o,objects);
        System.out.println("chatting end");
        return null;
    }
}
复制代码
  • 使用
public static void main(String[] args) {
        Person person = new Person();
        PersonCglib cglib = new PersonCglib();
        InterView interView = (InterView) cglib.getInstance(person);

        interView.chatting();
    }
复制代码
  • 基于字节码,动态的创建需要代理的子类
  • 创建一个原本的业务对象,创建一个代理类对象,在代理类对象中实现MethodInterceptor接口,通过传入原本的业务对象,设置要继承的父类对象,并设置回调,返回一个增强对象,代理类对象实现intercept方法,传入参数是被代理对象,拦截的方法,拦截的参数,原有业务类指向的代理对象,每次调用业务方法都会回调intercept方法,实现动态代理