设计模式-代理模式

代理模式(Proxy)

代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。

被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象

代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴) 。

静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

接口类

1
2
3

public interface ITeacherDao {
    void teach();
}

创建目标对象和代理对象

//目标对象
public class TeacherDao implements ITeacherDao {

    @Override
    public void teach() {
        System.out.println("老师授课中");
    }
}

//代理对象，静态代理
public class TeacherDaoProxy implements ITeacherDao {


    private ITeacherDao target; //目标对象，通过接口来聚合

    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    @Override
    public void teach() {
        System.out.println("代理对象开始代理。。。");
        target.teach();
        System.out.println("提交。。。。");
    }
}

创建调用类

public class Client {

    public static void main(String[] args) {
        //创建目标对象
        TeacherDao teacherDao = new TeacherDao();

        //代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);

        //通过代理对象，调用被代理对象的方法
        teacherDaoProxy.teach();
    }
}
/*代理对象开始代理。。。
老师授课中
提交。。。。*/

静态代理的优缺点

优点：

真实角色类（业务类）只需要关注业务逻辑本身，这是代理模式的共有优点；
代理类可以在调用业务类的处理方法之前和之后做一些增强性的操作，比如记录日志、管理事务等，这也是代理模式共有的优点。

缺点：

代理类和业务类实现了相同的接口，并且实现了相同的方法，代码冗余。如果接口增加一个方法，所有的代理类和所有的实现类都需要增加这个方法的实现，不易维护；
代理对象只能代理同一种类型的对象，如果要对多种类型的对象进行代理，就要写多个代理类，这就会大大增加类文件的数量，不适合在大规模程序中使用。

动态代理

JDK动态代理

动态代理的代理类是在程序运行的时候由Java反射机制动态生成的。我们在上面静态代理的例子中，代理类是自己定义好的，在程序运行之前就已经编译完成。我们先来看下如何实现JDK的动态代理。

Java的 java.lang.reflect 包下提供了一个Proxy类和一个InvocationHandler接口，JDK动态代理的实现主要依靠这两个对象实现。

接口和目标对象的创建如上

创建代理类

public class ProxyHandler implements InvocationHandler {

    //维护一个目标对象
    private Object target;

    //初始化target
    public ProxyHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoke "  + method.getName());
        Object invoke = method.invoke(target, args);
        System.out.println("After invoke " + method.getName());
        return invoke;
    }
}

代理类调用

public class Client {
    public static void main(String[] args) {
        //创建被代理对象
        ITeacherDao teacherDao = new TeacherDao();

        InvocationHandler handler = new ProxyHandler(teacherDao);

        ITeacherDao proxy = (ITeacherDao) Proxy.newProxyInstance(
                teacherDao.getClass().getClassLoader(),
                teacherDao.getClass().getInterfaces(),
                handler);

        System.out.println(proxy.getClass());
        proxy.teach();

    }
}

/*
class com.sun.proxy.$Proxy0
Before invoke teach
老师授课中
After invoke teach
*/

//Proxy.newProxyInstance()
//1. ClassLoader loader ： 指定当前目标对象使用的类加载器, 获取加载器的方法固定
//2. Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
//3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 会把当前执行的目标对象方法作为参数传入,也可以用匿名内部类。

动态代理底层实现

通过实现 InvocationHandler 接口创建自己的调用处理器；
通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

Proxy类的静态方newProxyInstance源码

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     * 获取接口的代理类
     */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

有一行比较关键的代码，通过getProxyClass0()方法生成代理类Proxy的Class对象。

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}

proxyClassCache.get 方法就是通过工厂动态生成代理类文件，并将其放到缓存中

总结

JDK为我们生成了一个“$Proxy0”的代理类，其中0代表编号，如果有多个代理类会依次递增。这个类继承了Proxy类，并且实现了我们定义的ITeacher接口，所以它会实现我们接口中定义的 teach 方法，在这个方法中，会调用 InvocationHandler 类中的 invoke 方法，通过上面分析我们知道，InvocationHandler 的 invoke 方法会通过反射调用被代理对象 target 的 method 方法，这就是代理类调用的真相。这个文件生成之后是放在内存中的，我们在创建代理类对象的时候，就是通过反射获得这个类文件的构造方法，然后创建代理实例。

我们可以把 InvocationHandler 看做一个中介类，中介类持有一个被代理对象，在invoke方法中调用了被代理对象的相应方法。

代理类调用自己方法时，通过自身持有的中介类对象来调用中介类对象的invoke方法，从而达到代理执行被代理对象的方法。也就是说，动态代理通过中介类实现了具体的代理功能。

CGLib动态代理

静态代理和JDK代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是Cglib代理

Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功

能扩展, 有些书也将Cglib代理归属到动态代理。

Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP，实现方法拦截
在AOP编程中如何选择代理模式：
- 目标对象需要实现接口，用JDK代理
- 目标对象不需要实现接口，用Cglib代理

5) Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

导入jar包

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

代理的类不能是final类
目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方

创建代理类

public class TeacherDao {

    public void teach() {
        System.out.println("老师授课中,cglib代理不需要实现接口");
    }
}

编写方法拦截器。这个拦截器实现了MethodInterceptor接口

public class ProxyFactory implements MethodInterceptor {

    //维护一个目标对象
    private Object target;

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

    //返回一个代理对象，是target对象的代理对象
    public Object getProxyInstance(){
        //1.创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(target.getClass());
        //3.设置回调函数
        enhancer.setCallback(this);
        //4.返回子类对象，即代理对象
        return enhancer.create();
    }

    //重写intercept方法，会调用目标对象的方法
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理开始");
        Object returnVal = method.invoke(target, objects);
        System.out.println("Cglib代理结束");
        return returnVal;
    }
}

编写测试

public class Client {

    public static void main(String[] args) {
        //创建目标对象
        TeacherDao target = new TeacherDao();
        //获取到代理对象，并且将目标对象传递给代理对象
        TeacherDao proxyInstance = (TeacherDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法，触发intecept 方法，从而实现 对目标对象的调用
        String res = proxyInstance.teach();

        System.out.println("res=" + res);
    }
}
/*
Cglib代理开始
 老师授课中  ， 我是cglib代理，不需要实现接口 
Cglib代理结束
res=hello
*/

CGLib动态代理原理

要实现CGLib的动态代理，我们必须要实现一个MethodInterceptor（方法拦截器）接口

1
2
3

public interface MethodInterceptor extends Callback {
    Object intercept(Object var1, Method var2, Object[] var3, MethodProxy var4) throws Throwable;
}

1.第一个参数表示增强的对象，也就是实现这个接口的类的一个对象。

2.第二个参数表示要被拦截的方法。

3.第三个参数表示要被拦截的方法的参数。

4.第四个参数表示要触发父类的方法对象。

另外一个比较重要的对象是Enhancer。通过上面的例子我们看到，我们的代理类是通过Enhancer的create()方法生成的：通过反射生成代理对象

JDK动态代理与CGLib动态代理的区别

JDK动态代理：代理类与委托类实现同一接口，主要是通过代理类实现InvocationHandler并重写invoke方法来进行动态代理的，在invoke方法中将对方法进行增强处理，只能够代理实现了接口的委托类，底层使用反射机制进行方法的调用。

CGLib动态代理：代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法，一个是与委托方法签名相同的方法，它在方法中会通过super调用委托方法；另一个是代理类独有的方法。在代理方法中，它会判断是否存在实现了MethodInterceptor接口的对象，若存在则将调用intercept方法对委托方法进行代理。不能对final类以及final方法进行代理，底层将方法全部存入一个数组中，通过数组索引直接进行方法。

参考

https://www.jianshu.com/p/9bcac608c714
https://baijiahao.baidu.com/s?id=1662496882632642298&wfr=spider&for=pc