代理设计模式8--代理模式探索

一、定义

        代理模式：为目标对象提供一种代理以控制对目标对象的访问。在某些情况下，一个对象不适合或者不能直接引用目标对象（比如包访问权限的类），而代理对象可以在客户端和目标对象之间起到中介的作用。

        代理类就像秘书一样,为老板代理一些琐碎的事情，管事的还是老板。

   为目标对象创建一个代理，以控制对它的直接访问。

二、分类

        静态代理，JDK动态代理，Cglib动态代理。

三、静态代理

        优点：静态代理本质上就是创建一个类的包装类，所以不用修改被代理的对象。

        缺点：如果被代理的对象加了一个方法，那么代理类也要同步加一个方法。

        下面是一个简单的例子

//被代理的对象或者说是委托对象，实现了接口
public class Subject implements Operation{
    @Override
    public void function() {
        System.out.println("主体操作");
    }
}
//代理的对象，与委托对象实现了相同的接口
class Proxy implements Operation{
    //持有委托对象的引用
    private Subject subject;
    //使用构造函数接收
    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void function() {
        System.out.println("增强操作，如 日志，安全，事务，缓存");
        subject.function();
        System.out.println("后置处理，如记录操作时间");
    }
}

四、JDK动态代理

        优点：JDK动态代理把代理方法的处理都集中到了InvocationHandler这个类的实现中，所以方便统一增加类似于切面的功能，比如记录时间，增加日志、缓存等。

        缺点：JDK动态代理只能代理接口的实现

        运行时：根据我们在Java代码中的“指示”，动态的生成了相关类

        下面是一个简单的例子

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;
    }

    public Object getInstance(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //前置增强
        System.out.println("增强操作，如 日志，安全，事务，缓存");
        //调用被代理对象的业务方法
        Object result = method.invoke(target,args);
        System.out.println("后置增强，用于记录数据,或者记录时间，将数据存到全局map中等");
        return result;
    }

    public static void main(String[] args) {
        //业务实现类实现了Operatino接口
        Operation subject = new Subject();
        //创建动态代理对象
        DynamicProxy proxy = new DynamicProxy(subject);
        //创建代理实例对象
        Operation proxyInstance = (Operation)proxy.getInstance();
        //调用代理对象的方法，包裹了真实对象的方法
        proxyInstance.function();
    }
}

五、Cglib动态代理

        如果目标没有实现接口，那么可以用cglib动态代理。cglib是针对类来实现代理的，它生成目标类的一个子类作为代理类。

   Cglib动态代理的缺点就是不能对final修饰的类进行代理，final修饰的类不能生成子类。

        下面是一个简单的例子

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
    //被代理的对象，或者是说是真实对象，委托对象
    private Object target;
    public CglibProxy(Object target) {
        this.target = target;
    }

    public Object getInstance() {
        //创建代理对象的工厂
        Enhancer enhancer = new Enhancer();
        //设置代理对象的父类是当前的真实对象
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法，当调用代理对象的时候，让真实对象去操作
        enhancer.setCallback(this);
        // 创建代理对象，并返回
        return enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, 
                         MethodProxy methodProxy) throws Throwable {
        //前置增强
        System.out.println("增强操作，如 日志，安全，事务，缓存");
        Object result = method.invoke(target,args);
        System.out.println("后置增强");
        return result;
    }

    public static void main(String[] args) {
        Temp temp = new Temp();
        CglibProxy proxy = new CglibProxy(temp);
        Temp tempInstance = (Temp)proxy.getInstance();
        tempInstance.login();
        /**
         * 运行结果：
         * 增强操作，如 日志，安全，事务，缓存
         * 临时登录
         * 后置增强，用于记录数据,或者记录时间，将数据存到全局map中等
         */
    }
}

六、增强工具类例子

        在类中添加抽象方法，让子类去继承它，实现其它增强的方法。这有点像拦截器的感觉了。重写invoke方法，父类的用super.invoke()方法回调。

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

public abstract class DynamicProxy implements InvocationHandler{
    //被代理的对象的引用，或者说是委托对象，也很称它为真实对象
    private Object target;

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

    //前处理
    public abstract Object prehandle();
    //后处理
    public abstract Object posthandle();

    public Object getInstance(){
        /**
         * 参数1：类加载器
         * 参数2：被代理对象所实现的接口，我们动态生成的代理类也将实现这些接口
         * 参数3：使用哪个调用处理器的invoke方法，当前就使用这个类的实例对象的invoke方法
         *
         */
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    /**
     *
     * @param proxy   生成的代理对象的引用
     * @param method  代理对象调用的方法
     * @param args    参数数组
     * @return        调用此方法的结果
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        prehandle();
        //调用被代理对象的业务方法
        Object result = method.invoke(target, args);
        posthandle();
        return result;
    }
}

深度好文：

        谈谈JAVA的代理模式认识 一——为什么使用代理模式

        java的动态代理机制详解

        代理模式（Proxy Pattern），静态代理 VS 动态代理

 

分割线--------------------------------------------------------------------------------------------

下一篇：代理设计模式9--使用AOP风格的代理模式

刻意练习

        （1）一句话描述代理设计模式

        （2）静态代理模式的优点与缺点

        （3）JDK动态代理的缺点

        （4）JDK动态代理的优点

        （5）一般代理Controller，为什么用Cglib代理，而不用Jdk动态代理

        （6） Cglib动态代理的一个比较常见的缺陷