JAVA的代理(proxy)模式

　　代理(proxy)模式: 是一种设计模式, 提供了间接对目标对象进行访问的方式. 即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的功能上,增加额外的功能补充,即扩展目标对象的功能. 有的时候也可以使用代理模式, 在不修改他人代码的情况下, 增强功能(对方法进行扩展)

　　举例: 老板的助理, 明星的经纪人等, 这里的助理和经纪人都可以看做是代理对象, 而老板和明星就是目标对象, 别人通过联系助理和经纪人可以达到相同的目的, 通俗一点的解释就是在操作一个目标对象或对象中的方法时，不是直接操作这个对象，而是通过一个代理对象来操作这个实际的目标对象

　　关键词: 目标对象, 代理对象. (代理对象就是对目标对象的扩展, 并会调用目标对象)

　　图示:

　　

 

 

 　　代理分类: 静态代理 和 动态代理以及Cglib代理

　　 注意: 接下来所有的代理模式示例都将以CURD操作为基础, 只是演示代理模式的方式, 不做真正的数据库操作!!!

　1.静态代理

　　说明: 静态代理在使用的时候, 需要定义目标接口,被代理对象(子类, 也就是目标对象)与代理对象都需要一起实现相同的这个目标接口.

 　   代码示例: 

　　目标接口: ICurd.java

package demo.java.jiangkd.design_pattern.proxy.staticProxy.demo;

/**
 * 定义目标接口
 * 
 * @author jiangkd
 * @date 2020/06/04
 */
public interface ICurd {

    void add();
    
    void delete();
    
    void update();
    
    void find();
}

　　目标对象: CurdImpl.java

package demo.java.jiangkd.design_pattern.proxy.staticProxy.demo;

/**
 * 目标对象, 实现父接口
 * 
 * @author jiangkd
 * @date 2020/06/04
 */
public class CurdImpl implements ICurd {

    @Override
    public void add() {
        System.out.println("CurdImpl执行了add操作");
    }

    @Override
    public void delete() {
        System.out.println("CurdImpl执行了delete操作");
    }

    @Override
    public void update() {
        System.out.println("CurdImpl执行了update操作");
    }

    @Override
    public void find() {
        System.out.println("CurdImpl执行了find操作");
    }
}

　　代理对象: Proxy.java

package demo.java.jiangkd.design_pattern.proxy.staticProxy.demo;

/**
 * 定义代理对象
 * 
 * @author jiangkd
 * @date 2020/06/04
 */
public class Proxy implements ICurd {

    private ICurd curd;

    public Proxy(ICurd curd) {
        this.curd = curd;
    }

    @Override
    public void add() {
        // 扩展, 执行目标对象之前的行为
        System.out.println("执行add操作之前 ...");
        // 执行真正的目标对象的方法
        curd.add();
        // 扩展, 执行目标对象之后的行为
        System.out.println("执行add操作之后 ...");
    }

    @Override
    public void delete() {
　　　　　// 类似add方法
    }

    @Override
    public void update() {
　　　　　// 类似add方法
    }

    @Override
    public void find() {
　　　　　// 类似add方法
    }
}

　　测试类: ProxyTest.java

package demo.java.jiangkd.design_pattern.proxy.staticProxy.demo;

import org.junit.Test;

public class ProxyTest {

    @Test
    public void test() {
        // 创建目标对象
        CurdImpl curdImpl = new CurdImpl();
        // 创建代理对象, 代理目标对象
        Proxy proxy = new Proxy(curdImpl);
        // 执行代理对象的add方法
        proxy.add();
    }
}

　　结果输出:

　　

执行add操作之前 ...
CurdImpl执行了add操作
执行add操作之后 ...

　　静态代理总结: 

　　　　1. 可以做到在不修改目标对象的功能前提下,对目标功能扩展.(执行目标对象方法的前后的输出就是扩展, 可以改为其他方法的执行, 这里为了演示只是输出)

　　　　2. 缺点: 因为代理对象需要与目标对象实现一样的接口, 所以如果都采用这种方式, 久而久之会发现有很多的代理类, 很繁琐, 加入你有两个目标接口, 都需要代理, 那么你就会产生两个对应的目标对象和代理对象, 如果是20个呢, 简直要崩溃呀!!! 而且一旦目标接口改变方法, 例如添加新的方法, 那么目标对象和代理对象都需要相应的进行添加方法, 维护麻烦, 所以, 解决这个问题的方案就是动态代理!!!

　2.动态代理

 　　动态代理特点: 

　　　　1. 代理对象不需要实现目标接口

　　　　2. 代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

　　　　3. 动态代理也叫作JDK动态代理

　　JDK动态代理了解: 

　　　　1. 代理类所在包:java.lang.reflect.Proxy

　　　　2. JDK实现代理只需要使用Proxy的静态方法newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:　　

static Object newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h )

　　　　　接收的三个参数依次为: 　　　　　

　　　　　　　　ClassLoader loader: 指定当前目标对象使用类加载器,获取加载器的方法是固定的

　　　　　　　　Class[] interfaces: 目标对象实现的接口的类型,使用泛型方式确认类型

　　　　　　　　InvocationHandler h: 事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

　　　　代码示例:

　　目标接口和目标对象依然同上面的静态代理, 这里不再展示, 不同是这里的代理对象不需要定义类来实现目标接口, 而是实现

JDK的代理类接口MyInvocationHandler中的invoke方法来动态的生成代理对象

　　　　代理对象: MyInvocationHandler.java, 实现JDK的代理类接口 

package demo.java.jiangkd.design_pattern.proxy.dynamicProxy.jdk.demo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 实现jdk自带的动态代理类接口并重写invoke方法
 * 
 * @author jiangkd
 * @date 2020/06/04
 */
public class MyInvocationHandler implements InvocationHandler {

    /**
     * 持有需要被代理的真实目标对象
     */
    private Object obj;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 扩展:执行代理之前的操作
        System.out.println("代理之前 ...");
　　　　　// 注意: 这里传入的参数是持有的目标对象obj和参数args
        Object invoke = method.invoke(obj, args);
        // 扩展:执行代理之后的操作
        System.out.println("代理之后 ...");

        return invoke;
    }
}

　　测试: ProxyTest.java

package demo.java.jiangkd.design_pattern.proxy.dynamicProxy.jdk.demo;

import java.lang.reflect.Proxy;

import org.junit.Test;

public class ProxyTest {

    @Test
    public void test() {
        // 定义目标对象
        CurdImpl curdImpl = new CurdImpl();
        // 执行静态方法获取代理对象, 注意三个参数的获取方式, 也有其他写法, 但是变的都是表面而已, 实际类型都是一样的
        ICurd curd = (ICurd)Proxy.newProxyInstance(curdImpl.getClass().getClassLoader(),
            curdImpl.getClass().getInterfaces(), new MyInvocationHandler(curdImpl));
        //
        curd.add();
    }
}

　　测试结果输出:

　　　　同静态代理输出一样(懒得贴了)

　　总结:
　　　　代理对象不需要实现接口而是执行静态方法newProxyInstance来获取的, 但是目标对象一定要实现接口,否则不能用动态代理

　3.Cglig代理

　　上面的静态代理和动态代理模式都是要求目标对象实现一个接口(所谓的目标接口), 但是有时候目标对象只是一个单独的对象, 并没有实现任何的接口, 这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理

　　Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展. Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)

　　Cglib子类代理实现方法:

　　　　1.需要引入cglib的jar文件,但是如果是Spring项目, 那么核心包中已经包括了Cglib功能,所以直接引入spring-core-3.2.5.jar即可. 否则需要cglib-nodep-3.2.4.jar(版本自己视情况而定)

　　　　2.引入功能包后,就可以在内存中动态构建子类

　　　　3.目标对象的方法如果为final/static,那么就不会被代理(本人测试过static方法, 如果采用代理对象调用static方法, 会报出警告, 推荐使用类直接调用, 而且执行了也不会执行代理扩展的方法, 只会执行自身的方法)

　　　　4. 需要一个代理类, 实现接口MethodInterceptor中的invoke方法, 然后还需要有一个生成代理对象的方法

　　代码示例:

　　没有目标接口, 只是一个类, 作为目标对象

package demo.java.jiangkd.design_pattern.proxy.dynamicProxy.cglib.demo;

/**
 * 单纯的一个类, 作为目标对象
 * 
 * @author jiangkd
 * @date 2020/06/04
 */
public class CurdService {

    public void add() {
        System.out.println("CurdService -> add");
    }

    public String delete() {
        System.out.println("CurdService -> delete");
        return "delete";
    }

    public static void update() {
        System.out.println("CurdService -> update");
    }
}

　　代理类: MyMethodInterceptor.java 需要实现MethodInterceptor接口中的invoke方法

package demo.java.jiangkd.design_pattern.proxy.dynamicProxy.cglib.demo;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * cglib代理类, 用来获取代理对象
 * 
 * @author jiangkd
 * @date 2020/06/04
 */
public class MyMethodInterceptor implements MethodInterceptor {

    /**
     * 持有目标对象
     */
    private Object obj;

    public MyMethodInterceptor(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //
        System.out.println("before ...");
        Object invoke = method.invoke(obj, args);
        System.out.println("返回:" + invoke);
        System.out.println("after ...");
        return invoke;
    }

    /**
     * 创建代理对象的方法
     * 
     * @return
     */
    public Object getProxyObj() {
        //
        Enhancer enhancer = new Enhancer();
        // 设置父类, 就是目标对象类
        enhancer.setSuperclass(obj.getClass());
        // 设置回调, 就是当前代理类
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }
}

　　测试类: ProxyTest.java

package demo.java.jiangkd.design_pattern.proxy.dynamicProxy.cglib.demo;

import org.junit.Test;

public class ProxyTest {

    @Test
    public void test() {
        // 目标对象
        CurdService curdService = new CurdService();
        // 获取代理对象
        CurdService proxyObj = (CurdService)new MyMethodInterceptor(curdService).getProxyObj();
        // 
        proxyObj.add();
        // 静态方法, 不会通过代理, 报出警告, 推荐下面的写法
        proxyObj.update();
        // 直接正常调用, 不使用代理
        CurdService.update();
    }
}

　　测试输出:

　　　不妨自己写一个代理, 测试一下看看啊(好吧, 其实就是我懒得贴了)