代理模式

简介

代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

代理模式的主要优点有：

代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性

其主要缺点是：

代理模式会造成系统设计中类的数量增加
在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
增加了系统的复杂度；

情景模拟

老板要你编写加减乘除的代码

interface ICalc {
    int add(int a, int b);

    int sub(int a, int b);

    int mul(int a, int b);

    int div(int a, int b);
}

class CalcImpl implements ICalc {

    @Override
    public int add(int a, int b) {
        int r = a + b;
        return r;
    }

    @Override
    public int sub(int a, int b) {
        int r = a - b;
        return r;
    }

    @Override
    public int mul(int a, int b) {
        int r = a * b;
        return r;
    }

    @Override
    public int div(int a, int b) {
        int r = a / b;
        return r;
    }
}

代码写完后，老板又要你在加减乘除的方法中添加日志的功能，即每一个方法调用前和调用后都打印出日志。

对上述代码进行修改

interface ICalc {
    int add(int a, int b);

    int sub(int a, int b);

    int mul(int a, int b);

    int div(int a, int b);
}

class CalcImpl implements ICalc {

    @Override
    public int add(int a, int b) {
        System.out.println("进入了add方法，参数是：" + a + "," + b);
        int r = a + b;
        System.out.println("add方法的结果是：" + r);
        return r;
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("进入了add方法，参数是：" + a + "," + b);
        int r = a - b;
        System.out.println("sub方法的结果是：" + r);
        return r;
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("进入了add方法，参数是：" + a + "," + b);
        int r = a * b;
        System.out.println("mul方法的结果是：" + r);
        return r;
    }

    @Override
    public int div(int a, int b) {
        System.out.println("进入了add方法，参数是：" + a + "," + b);
        int r = a / b;
        System.out.println("div方法的结果是：" + r);
        return r;
    }
}

缺陷：

代码在重复
如果需求再次变化，比如使用英文输出，就又要改很多地方
代码急剧膨胀，业务核心代码与非核心业务代码耦合
需求要求加入开方，立方。。。又要进行添加日志功能

动态代理

为了解决上述问题我们可以使用动态代理设计模式。

学习jdk中动态代理的API

public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,InvocationHandler h)

第一个参数ClassLoader loader：

我们都知道，要实例化一个对象，是需要调用类的构造器的，在程序运行期间第一次调用构造器时，就会引起来的加载。加载类的时候，就是JVM拿着ClassLoader去加载类的字节码，只有字节码被加载到了内存中，才能进一步去实例化出类的对象。

简单来说，就是只要涉及实例化类的对象的操作，就一定要加载类的字节码，而加载类的字节码就一定要使用类加载器。我们使用动态代理的API来创建一个类的对象，这是一种很不常见的实例化类的方式，尽管很不常见，但毕竟设计实例化类的对象，那就一定需要加载类的字节码，也就一定要类加载器，所以我们需要手动的把类加载器传入。

Proxy.newProxyInstance(ProxyPattern.class.getClassLoader(),null,null);		// ProxyPattern类是自己定义的类，表示这个类的类加载器

第二个参数Class<?>[] interfaces：

我们已经知道了Proxy.newProxyInstance()这行代码是用来实例化一个对象的，实例化对象，就一定是实例化某一个类的对象，问题是，到底是哪个类呢？这个类在哪类？字节码又在哪？

这个类，其实不在硬盘上，而是在内存中。是由动态动态动态代理中动态生产的，如下图。这个在内存中直接生成的字节码，会去自动实现Proxy.newProxyInstance()方法中的第二个参数，所指定的接口。所以，利用动态代理生成的代理对象，就能转化成指定的接口的类型。

ICalc proxyICalc = (ICalc) Proxy.newProxyInstance(ProxyPattern.class.getClassLoader(), new Class[]{ICalc.class}, null);

第三个参数InvocationHandler h：

public interface InvocationHandler {}

由``InvocationHandler `源码可知该参数是一个接口，所以我们肯定需要一个类实现该接口，然后作为参数传入。

定义一个类，并实现该接口，重写invoke方法

class MyHandle implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 	  {
        return null;
    }
}

我们已经知道，代理对象proxyICalc所属的类，实现了ICalc接口，所以，这个代理对象就拥有了add，sub，mul，div方法。我们就可以通过代理对象来调用这些方法。关键点来了，注意，我们我们对代理对象任何方法的调用都不会进入到真正的实现方法中去。也就是ICalc接口中去，而是会进入第三个参数的invoke方法中去。

我们发现代理生成的对象调用add方法，是进入了invoke方法中去的，而且传入的参数method值就是我们调用的add方法，这个时候我们就可以想，既然没有进入真正的方法，那我们完全可以在invoke方法中调用真正的add方法，然后再在invoke方法中添加日志等非核心业务功能，这样问题不就解决了吗。

在下面的代码中，通过反射调用真正的add()方法时，需要告知是哪个类的方法，所以需要关联目标对象。

class MyHandle implements InvocationHandler {

    // 关联真正的对象，此时这里真正的对象为Icalc
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入了invoke方法");
        System.out.println("进入的对象是：" + proxy.getClass().getName());
        System.out.println("调用的方法是：" + method.getName());
        System.out.println("参数是：" + Arrays.asList(args).toString());

        // 通过反射调用method的真实方法
        Object result = method.invoke(target, args);
        return result;
    }
}

public class ProxyPattern {
    public static void main(String[] args) {
        // 目标对象，真实对象
        ICalc iCalc = new CalcImpl();

        // 创建代理对象
        // 参数：类加载器，接口
        // 代理生成的类的接口
        // 实现了InvocationHandler接口的类
        ICalc proxyICalc = (ICalc) Proxy.newProxyInstance(ProxyPattern.class.getClassLoader(), new Class[]{ICalc.class}, new MyHandle(iCalc));
        int result = proxyICalc.add(1, 2);
        System.out.println(result);
    }
}

这就是jdk的代理模式。

posted @ 2021-03-26 12:58 nuoxin 阅读(70) 评论(0) 收藏举报

刷新页面返回顶部

Loading

nuoxin

代理模式

代理模式

简介

情景模拟

动态代理

学习jdk中动态代理的API

公告