代理设计模式

bisnow_
264 阅读6分钟

代理设计模式

传送门

  • 模拟计算面试时间
  • 创建一个接口
//面试
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方法，实现动态代理
avatar
文章
阅读
粉丝