• 在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

• 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
  意图：为其他对象提供一种代理以控制对这个对象的访问。

JDK 自带的动态代理

• java.lang.reflect.Proxy:生成动态代理类和对象；
• java.lang.reflect.InvocationHandler（处理器接口）：可以通过invoke方法实现对真实角色的代理访问。
• 每次通过 Proxy 生成的代理类对象都要指定对应的处理器对象。

实现

  我们将创建一个 BaseService接口和实现了 BaseService接口的实体类。Invocation是一个处理器类，通过Invocation来的invoke方法来执行或补充真实类的需求。ProxyFactory是一个代理类工厂，通过Proxy类来生成动态代理类和对象。

步骤一

创建一个接口，实现这个接口的类才能被动态代理

/**
 * 只有被需要被监控的行为才有资格在这里声明
 */
public interface BaseService {
    void eat();
    void wc();
}

步骤二

创建实现接口的实体类。

public class Person implements BaseService {
    @Override
    public void eat() { //主要业务，代理模式要求开发人员只关心主要业务
        System.out.println("使用筷子吃饭。。。");
    }
    @Override
    public void wc() {
        System.out.println("测试重力是否存在。。。");
    }
}

步骤三

创建实现了InvocationHandler 接口的处理器类

public class Invocation implements InvocationHandler {
    private BaseService obj;   //具体被监控对象
    public Invocation(BaseService param){
        obj=param;
    }
    /**
     * 在被监控的行为将要执行时，会被JVM拦截。被监控行为（方法）和行为实现方（类实例）会作为参数输送invoke
     *          通知JVM，这个被拦截方法是如何与当前次要业务方法绑定实现
     *
     * @param proxy     将辅助监控行为实现方（类实例）的代理对象作为proxy
     * @param method    被监控行为（方法）封装成Method类型对象
     * @param args      被监控行为（方法）运行时接收所有的实参封装到Object[]
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //0.局部变量，接受主要业务方法执行完毕后的返回值
        Object value;
        //1.确认被拦截的行为
        String methodName = method.getName();
        //2.根据别拦截的行为不同，决定主要业务与次要业务如何绑定执行
        if ("eat".equals(methodName)) { //饭前要洗手
            wash();  //洗手
            value = method.invoke(this.obj, args);//吃饭
        }else{
            value =  method.invoke(this.obj,args);   //厕所
            wash();  //洗手
        }
        return value;   //返回到被拦截方法需要调用的地方
    }
    //次要业务
    public void wash(){
        System.out.println("--------洗手---------");
    }
}

步骤四

创建一个代理类工厂，通过Proxy类来生成动态代理类和对象。

public class ProxyFactory {
    /**
     * JDK动态代理模式下，代理对象的数据类型，应该由监控行为来描述
     * 参数：Class文件，监控类。
     */
    public static BaseService Builder(Class clazz) throws IllegalAccessException, InstantiationException {
        //1.创建被监控实例对象
        BaseService obj = (BaseService) clazz.newInstance();
        //2.创建一个通知（处理器）对象
        InvocationHandler adviser = new Invocation(obj);
        //3.想JVM申请负责监控obj对象指定行为的监控对象（代理对象）
        /**
         * loader:被监控对象隶属的类文件在我们内存中真实地址
         * interfaces:被监控对象隶属的类文件实现接口
         * h:监控对象发现类实例要执行被监控行为，应该由哪一个通知对象进行辅助
         */
        BaseService $proxy = (BaseService)
                Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), adviser);
        return $proxy;
    }
}

步骤五

测试类

public class TestMain {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        //Person mike = new Person();
        BaseService mike=ProxyFactory.Builder(Person.class);   //返回的是一个代理对象  不是mike
        mike.eat();
        mike.wc();
    }
}

测试结果.png