浅谈代理模式

在这里我们先看下百度上对代理模式的定义

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需修改,可以通过代理的方式来扩展该方法,举个例子来说明代理的作用:假设我们想邀请一位明星,那么并不是直接联系明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子

Java中的代理模式

在Java的设计思想中，代理模式应用到了很多领域，Rpc(远程过程调用)就是一个很好的例子，在java中，总共有5种代理模式方法

今天我只学了前面两种，静态代理和基于JDK的动态代理

静态代理

静态代理是代理类在编译期间就创建好了，不是编译器生成的代理类，而是手动创建的类。在编译时就已经将接口，被代理类，代理类等确定下来。软件设计中所指的代理一般是指静态代理，也就是在代码中显式指定的代理。

下面我们用一个简单的demo来演示静态代理:小翔喜欢网购，有事没事就喜欢上淘宝，最近想给老爸买一件衣服，但是摸了摸自己的口袋发现钱不够，刚好此时网店有优惠卷，小翔刚好领了一张，于是就拿着优惠券去买衣服，在这个场景下，使用优惠券买东西就是一个代理的过程，这个过程减少了小翔买东西所花的开销

我们假设有一个买东西的接口

package org.example.designpattern.Proxy.Statics;
/**
 *  买东西的接口
 */
public interface Shopping {
    void Buy();
}

现在小翔要去买东西，所以他要使用这个接口并且实现

package org.example.designpattern.Proxy.Statics;

// 买衣服接口
public class Client implements Shopping{
    @Override
    public void Buy() {
        System.out.println("小翔买了衣服");
    }
}

那么怎么去实现代理类呢？我们只需要去implements委托类的父类，然后重写父类方法

package org.example.designpattern.Proxy.Statics;

// 代理类
public class StaticProxy implements Shopping{
    private Shopping shopping;

    public StaticProxy(Shopping shopping) {
        this.shopping = shopping;
    }
    @Override
    public void Buy() {
        System.out.println("免费领了一张优惠卷!");
        shopping.Buy();
    }
}

接下来就可以去执行这个行为了

package org.example.designpattern.Proxy.Statics;

// 小翔用优惠卷买东西
public class StaticProxyTest {
    public static void main(String[] args) {
        Client client = new Client();
        StaticProxy service = new StaticProxy(client);
        service.Buy();
    }
}

免费领了一张优惠卷!
小翔买了衣服

Process finished with exit code 0

这就是静态代理，静态代理是代理类在代码运行前已经创建好，并生成class文件，现在我们看下动态代理，动态代理是代理类在程序运行时创建的代理模式。

动态代理类的代理类并不是事先定义好的，而是在运行时根据我们在代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。 想想你有100个静态代理类，现在有一个需求，每个代理类都需要新增一个处理逻辑，你需要打开100个代理类在每个代理方法里面新增处理逻辑吗？ 有或者代理类有5个方法，每个方法都需要新增一个处理逻辑， 你需要在每个方法都手动新增处理逻辑吗？ 想想就挺无趣的。动态代理类帮你一键搞定。

动态代理

动态代理类涉及到的核心角色

• 委托类和代理类实现的公共接口(Person.java)
• 实现公共接口的具体委托类(SoftwareEngineer.java)
• InvocationHandler接口被Proxy类回调处理，一般实现 InvocationHandler 接口的类具有委托类引用，接口方法 invoke 中添加公共代码并调用委托类的接口方法。(PersonInvocationHandler.java)
• JDK提供生成动态代理类的核心类Proxy ( JDK 提供的Proxy.java)

JDK的核心代理类Proxy和InvocationHandler接口

这个类Proxy定义了生成JDK动态代理类的方法 getProxyClass，生成动态代理类，该生成的动态代理类继承Proxy类，(重要特性) ，并实现公共接口。

InvocationHandler这个接口是被动态代理类回调的接口，我们所有需要增加的针对委托类的统一处理逻辑都增加到invoke方法里面，在调用委托类接口方法之前或之后进行一些逻辑处理的修改与补充

首先去定义一个公共类，表示一个人的行为(公共接口)

package org.example.designpattern.Proxy.dynamic;
// 公共接口，表示一个人的行为
public interface Person {
    void goWorking(String name,String dst);
    String GetName();
    void SetName(String name);
}

下面，我们让这个软件工程师类去实现这个公共类的方法(委托类)

package org.example.designpattern.Proxy.dynamic;

// 程序员类
public class SoftEngineer implements Person{
    private String name;
    @Override
    public void goWorking(String name, String dst) {
        System.out.println( name + "去" + dst + "工作");
    }

    @Override
    public String GetName() {
        return name;
    }

    @Override
    public void SetName(String name) {
        this.name = name;
    }
}

下面是代理类的实现过程

package org.example.designpattern.Proxy.dynamic;

// 代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class DynamicProxy implements InvocationHandler {

    private Object target;

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

    /**
     * 获取被代理接口实例对象
     * @param <T>
     * @return
     */
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(target, args);
        System.out.println("after");
        return result;
    }
}

接下来去测试一下

package org.example.designpattern.Proxy.dynamic;

import java.lang.reflect.Proxy;

// 测试类
public class Test {
    public static void main(String[] args) {
        Person p = new DynamicProxy(new SoftEngineer()).getProxy();
        p.goWorking("james","school");
    }
}

before
james去school工作
after

Process finished with exit code 0

JDK动态代理特点总结

• 生成的代理类：$Proxy0 extends Proxy implements Person，我们看到代理类继承了Proxy类，Java的继承机制决定了JDK动态代理类们无法实现对 类 的动态代理。所以也就决定了java动态代理只能对接口进行代理
• 每个生成的动态代理实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行
• 代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖； 二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被调用处理器分派到委托类执行

欢迎关注我的weixin公众号“James的黑板报”，原创技术文章第一时间推送。