java静态代理模式和动态代理模式（深入源码）

代理模式介绍

定义

代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

举个生活中的例子: 比如我是一家火锅店的老板,为了提高火锅店的知名度,我想找个明星给我代言,宣传一下我的火锅店,可是我没有办法直接接触到明星,这时候就需要一个中介来协调这件事,我们知道明星都会有经济人,这个经济人就充当了中介的作用,他联系我同时联系明星,但我和明星之间没有解除,这个就类似代理模式.代理概念可以解释为:在出发点到目的地之间有一道中间层,意为代理

为什么使用代理模式

中介隔离：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
开闭原则，增加功能代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

代理模式实现原理

代理模式主要包含三个角色，即抽象主题角色(Subject)、委托类角色(被代理角色，Proxied)以及代理类角色(Proxy)，如上图所示：
抽象主题角色:可以是接口，也可以是抽象类；
委托类角色：真实主题角色，业务逻辑的具体执行者；
代理类角色：内部含有对真实对象RealSubject的引用，负责对真实主题角色的调用，并在真实主题角色处理前后做预处理和后处理。

代理模式应用场景

SpringAop、日志收集、权限控制、过滤器、RPC远程调用

代理模式创建的方式

静态代理和动态代理两种方法,接下来我们详细看看这两种方式。

静态代理

静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。
所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。
一句话，自己手写代理类就是静态代理。

基于接口实现

基于接口方式的实现,要求被代理的类必须实现接口,同样作为代理类也要实现一样的接口,来代理被代理类，这里我们以下订单为例子,说一下基于接口模式的静态代理,如何实现

定义公共接口 :

public interface OrderService {
    /*
       共同抽象的方法 下订单
     */
    void order();
}

被代理的真实对象:

public class OrderServiceImpl implements OrderService {
    @Override
    public void order() {
        System.out.println("执行业务逻辑");
    }
}

代理对象

public class OrderServiceProxy implements OrderService {
    /*
       被代理对象
     */
    private OrderService orderService;

    public OrderServiceProxy(OrderService orderService){
        this.orderService = orderService;
    }

    /*
      实现静态代理的方式
     */
    @Override
    public void order() {
        System.out.println("打印日志");
        orderService.order(); //执行业务逻辑方法
    }
}

测试类:

public class Client {
   public static void main(String[] args) {
       OrderServiceProxy proxy = new OrderServiceProxy(new OrderServiceImpl());
       proxy.order();
   }
}
/*
打印日志
执行业务逻辑
*/

在代理模式中,我们客户并不直接去访问真实的对象(被代理对象),我们去访问代理,对用下单这个操作,在代理中,我们除了处理下单的业务逻辑,同样的我们可以做一下其它的扩展,类似日志记录,权限控制等等…

接口继承方式实现

除了实现公共的接口来实现代理,同样我们也可以通过继承被代理类的方式,通过java中继承等特性来实现代理,这时候被代理的真实对象,没有实现接口

真实角色(被代理的角色)

public class OrderServiceImpl2  {
    public void order() {
        System.out.println("执行业务逻辑");
    }
}

代理角色:

public class OrderServiceProxy2 extends OrderServiceImpl {
    @Override
    public void order() {
        System.out.println("执行日志等操作2");
        super.order();
    }
}

测试类:

public class Client2 {
    public static void main(String[] args) {
        //继承方式的静态代理
        OrderServiceProxy2 proxy2 = new OrderServiceProxy2();
        proxy2.order();
    }
}
/*
执行日志等操作2
执行业务逻辑
*/

静态代理总结:
1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.
2.缺点:

因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

如何解决静态代理中的缺点呢?答案是可以使用动态代理方式

动态代理

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。
动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成 。

JDK动态代理

JDK的动态代理使用Java的反射技术生成动态代理类，只能代理实现了接口的类， 没有实现接口的类不能实现动态代理。jdk动态代理类似与静态代理中实现接口的方式,代理类与被代理类有着共同的接口 我们还是举下单的例子,来说明jdk动态代理

接口 :

public interface OrderService {
    /*
       共同抽象的方法
     */
    void order();
}

真实角色 :

public class OrderServiceImpl implements OrderService {
    @Override
    public void order() {
        System.out.println("执行业务逻辑");
    }
}

动态代理类 :
创建一个代理类JdkInvocationHandler 实现java.lang.reflect.InvocationHandler接口，重写invoke方法

public class JdkInvocationHandler implements InvocationHandler {
    /*
      被代理类对象（目标代理对象）
     */
    private Object target;
    public JdkInvocationHandler(Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("业务扩展....日志记录....proxy:"+proxy.getClass().toString());
        //java的反射机制执行方法,执行被代理对象的方法
        Object result  = method.invoke(target,args);
        return result;
    }
    /*
      使用jdk动态代理创建代理类
     */
    public <T> T getProxy(){
       return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
}

建立测试类 :

public class Client3 {
     public static void main(String[] args) {
        //使用jdk动态代理
        // 保存生成的代理类的字节码文件
         System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
         OrderService proxy = new JdkInvocationHandler(new OrderServiceImpl()).getProxy();
         proxy.order();
    }
} 
/*
业务扩展....日志记录....proxy:class com.sun.proxy.$Proxy0
执行业务逻辑
*/

由于设置
sun.misc.ProxyGenerator.saveGeneratedFiles 的值为true,所以代理类的字节码内容保存在了项目根目录下，文件名为$Proxy0.class

源码分析
这里查看JDK1.8_251的源码，学习JDK动态代理的实现原理
大概流程
1、为接口创建代理类的字节码文件 (class文件)
2、使用ClassLoader将字节码文件加载到JVM
3、创建代理类实例对象，执行对象的目标方法

我们查看一下代理类的class文件的关键代码 ：$Proxy0.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import 代理模式.service.OrderService;

public final class $Proxy0 extends Proxy implements OrderService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void order() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("代理模式.service.OrderService").getMethod("order");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}
   

可看到

1、代理类继承了Proxy类并且实现了要代理的接口，由于java不支持多继承，所以JDK动态代理不能代理类
2、重写了equals、hashCode、toString
3、有一个静态代码块，通过反射或者代理类的所有方法
4、通过invoke执行代理类中的目标方法order

通过观察生成的代理类的字节码文件,我们发现代理类同样是和真实角色实现同样的接口OrderService，同时继承Proxy，接下来我们看一下Proxy类中的newProxyInstance方法来查看一下jdk如何动态的创建代理类

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
            throws IllegalArgumentException
    {
        // 判断InvocationHandler是否为空，若为空，抛出空指针异常
        Objects.requireNonNull(h);

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

        /*
         * 生成接口的代理类的字节码文件
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * 使用自定义的InvocationHandler作为参数，调用构造函数获取代理类对象实例
         */
        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);
        }
    }

newProxyInstance方法调用getProxyClass0方法生成代理类的字节码文件。

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        // 限定代理的接口不能超过65535个
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        // 如果缓存中已经存在相应接口的代理类，直接返回；否则，使用ProxyClassFactory创建代理类
        return proxyClassCache.get(loader, interfaces);
    }

其中缓存使用的是WeakCache实现的，此处主要关注使用ProxyClassFactory创建代理的情况。ProxyClassFactory是Proxy类的静态内部类，实现了BiFunction接口，实现了BiFunction接口中的apply方法。

当WeakCache中没有缓存相应接口的代理类，则会调用ProxyClassFactory类的apply方法来创建代理类。

private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 代理类前缀
        private static final String proxyClassNamePrefix = "$Proxy";
        // 生成代理类名称的计数器
        private static final AtomicLong nextUniqueNumber = new AtomicLong();
        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
                 * 校验类加载器是否能通过接口名称加载该类
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                            intf + " is not visible from class loader");
                }
                /*
                 * 校验该类是否是接口类型
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                            interfaceClass.getName() + " is not an interface");
                }
                /*
                 * 校验接口是否重复
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                            "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // 代理类包名
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * 非public接口，代理类的包名与接口的包名相同
             */
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // public代理接口，使用com.sun.proxy包名
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * 为代理类生成名字
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 真正生成代理类的字节码文件的地方
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
            try {
                // 使用类加载器将代理类的字节码文件加载到JVM中
                return defineClass0(loader, proxyName,
                        proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

在ProxyClassFactory类的apply方法中可看出真正生成代理类字节码的地方是ProxyGenerator类中的generateProxyClass，该类未开源，但是可以使用IDEA、或者反编译工具jd-gui来查看。

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        // 是否要将生成代理类的字节码文件保存到磁盘中
        if (saveGeneratedFiles) {
            // ....
        }
        return var4;
    }

CGLIB动态代理

CGLIB介绍
Cglib是一个强大的，高性能，高质量的代码生成类库。它可以在运行期扩展JAVA类与实现JAVA接口。其底层实现是通过ASM字节码处理框架来转换字节码并生成新的类。大部分功能实际上是ASM所提供的，Cglib只是封装了ASM，简化了ASM操作，实现了运行期生成新的class。

CGLIB原理
运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势植入横切逻辑。

Cglib优缺点
优点：JDK动态代理要求被代理的类必须实现接口，当需要代理的类没有实现接口时Cglib代理是一个很好的选择。另一个优点是Cglib动态代理比使用java反射的JDK动态代理要快
缺点：对于被代理类中的final方法，无法进行代理，因为子类中无法重写final函数

public class CglibMethodInterceptor implements MethodInterceptor {

    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
         System.out.println(">>>cglib开始日志收集");
         Object result =  methodProxy.invokeSuper(obj,args);
         return result;
    }
}

被代理对象

public class OrderServiceImpl2  {

    public void order() {
        System.out.println("执行业务逻辑");
    }
}

Test类

public class Client4 {
    public static void main(String[] args) {
        CglibMethodInterceptor interceptor = new CglibMethodInterceptor();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderServiceImpl2.class);
        enhancer.setCallback(interceptor);
        OrderServiceImpl2  orderServiceImpl2 = (OrderServiceImpl2) enhancer.create();
        orderServiceImpl2.order();
    }
}
/*
>>>cglib开始日志收集
执行业务逻辑
*/