设计模式——代理模式之动态代理源码分析JDK1.8（一）

    代理模式其本质是，对于需要调用的方法，在其原由逻辑上进行修改，或者说是在原有方法的基础上前后都加上log日志，或者是对原有方法的结果进行二次处理等等。

其结构图如下

Subject

     目标接口，定义RealSubject和Proxy的共同接口，

RealSubject

   具体的实现接口类，实现目标接口的功能

Proxy

   调用具体的实现接口类，并在具体实现类的基础上，调用其他相关方法。

静态代理方法

静态代理的实现，我们在原来方法上，添加了前后各打印一条数据

public interface Subject {
    void request();
}

具体方法调用

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("具体方法实现");
    }
}

代理类方法实现

public class StaticProxy implements Subject {
    private Subject subject;

    public StaticProxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        System.out.println("-------start-------------");
        subject.request();
        System.out.println("-------end----------------");
    }
}

测试代码

public class Test {
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        StaticProxy proxy = new StaticProxy(subject);
        proxy.request();
    }
}

执行结果

-------start-------------
具体方法实现
-------end----------------

以上就是静态代理的具体实现，接下来来看jdk提供的的动态代理实现方法

接口不发生变化

public interface Subject {
    void request();
}

具体接口的实现也不变

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("hello!");
    }
}

主要是代理类，这个时候继承的是jdk给我们提供的InvocationHandler

public class DynamicProxy implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before invoke");
         method.invoke(target,args);
        System.out.println("after invoke");
        return null;
    } 
}

接下来是测试类

public class TestProxy {
    public static void main(String[] args) {
        DynamicProxy proxy = new DynamicProxy();
        Subject service =(Subject) proxy.bind(new RealSubject());
        service.request();
    }
}

执行结果

before invoke
hello!
after invoke

对于动态代理我们可以在调用的时候，传递进去任何一个接口的显现类，都会在具体实现类的基础上，增加上我们代理类的逻辑

关于动态代理的实现，其主要是涉及到的就是Proxy类和InvocationHandler这个接口，我们分别来看下，对于InvocationHandlerl接口

public interface InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

这个接口只提供了一个抽象发法用来实现，子类在实现的时候，需要将具体实现类对象传递进去，然后再用反射调用具体实现类的方法，同时可以增加其他的业务逻辑。

Proxy类当中提供的方法，我们这里是用到newProxyInstance来创建对象的，我们来看下源码实现，基于JDK1.8

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        // handler的非空判断
        Objects.requireNonNull(h);

        //将代理类的接口复制出来一份
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * 根据classLoader和接口数组生成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);
        }
    }

上面的代码是创建代理类对象的具体实现，我们来看下大概的流程

1、根据传递进来的ClassLoader，以及我们的代理对象的父接口数组，来动态创建二进制的class文件，然后根据创建好的Class二进制文件，获取到创建的动态类的Class对象。

2、获取到动态创建的代理的构造方法，这个构造方法的参数就是定好的，传递进去的InvocationHandler，这个是动态代理约束好的，生成的字节码中，构造方法参数就是InvocationHandler

3、判断构造方法的访问修饰符，如果不是public的，将其设置成可以访问的

4、根据传递进来的具体的Handler对象和我们上面的构造方法对象，生成一个动态代理类的对象。

上面就是整个动态代理对象的生成过程，接下来我们来看getProxyClass0方法实现

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

注释写的很清楚，如果当前的这个接口数组已经存在，就返回缓存当中的副本，否则的话，就会通过ProxyClassFactory去创建一个Class对象。我们来看下ProxyClassFactory是如何创建一个Class对象的吧

其实就是WeakCache这个对象当中会在get取不到值时，去生成一个值放入进去，这里不做详细分析

WeakCache<>(new KeyFactory(), new ProxyClassFactory());

ProxyClassFactory是Proxy的一个静态内部类，主要就是用来根据classLoader和接口数组来生成Class对象的。下面我就贴出其主要用来创建Class对象的代码

 @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
               
                Class<?> interfaceClass = null;
                try {
                    //根据接口的全限定名获取到接口的Class对象
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                // 如果两次的Class对象不一致，直接抛出异常，说明当前classloader
                // 加载出来接口的Class对象和接口在项目当中的Class对象不一致，其实是命名空间不同，直接抛出异常
                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");
                }
                /*
                 * 判断我们的set集合当中是否已经有重复的接口，如果是抛出异常
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
           //下面这个循环主要是判断非pulic的接口是不是在同一个包内
            
            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");
                    }
                }
            }

            //如果是公共的接口，我们就设置其全限定名为 com.sun.proxy.$Proxy0
            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

           
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 这段代码就是根绝代理类的全限定名，接口数组，访问修饰符，生成代理类的字节码
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
              
               // 根据生成的字节码，创建Class对象，并返回，实现方法为native
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
               
                throw new IllegalArgumentException(e.toString());
            }
        }

可以看到这段代码就是设置好需要生成的类的类名，然后调用ProxyGenerator.generateProxyClass来生成代理类的字节码，接下来我们来看下这个类的实现

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        

         //中间省略掉一部分代码
        return var4;
    }

这个类当中的生成代码的核心部分就是通过构建好的ProxyGenerator对象，调用其 generateClassFile()方法

private byte[] generateClassFile() {

        //将object类当中的 hashcode，equals，toString方法放在了动态代理类当中
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);
        Class[] var1 = this.interfaces;
        int var2 = var1.length;

        int var3;
        Class var4;
        
        //遍历父接口数据
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];

            //获取每个接口当中的方法
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;

            //遍历接口当中的方法，将接口当中的方法都添加至动态代理类当中
            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                this.addProxyMethod(var8, var4);
            }
        }

        Iterator var11 = this.proxyMethods.values().iterator();

        //检查代理类当中的返回类型
        List var12;
        while(var11.hasNext()) {
            var12 = (List)var11.next();
            checkReturnTypes(var12);
        }

        Iterator var15;
        try {
            // 将构造方法添加至代理类当中的方法集合中
            this.methods.add(this.generateConstructor());
            var11 = this.proxyMethods.values().iterator();

            //遍历代理类当中的方法，此处使用两层循环，是因为方法签名相同的，可能有多个方法
            while(var11.hasNext()) {
                var12 = (List)var11.next();
                var15 = var12.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                    this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                    this.methods.add(var16.generateMethod());
                }
            }
            // 将静态代码块添加进去
            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var10) {
            throw new InternalError("unexpected I/O Exception", var10);
        }

        if(this.methods.size() > '\uffff') {
            throw new IllegalArgumentException("method limit exceeded");
        } else if(this.fields.size() > '\uffff') {
            throw new IllegalArgumentException("field limit exceeded");
        } else {
                /**
                 * 省略部分代码
                 **/
                return var13.toByteArray();
            } catch (IOException var9) {
                throw new InternalError("unexpected I/O Exception", var9);
            }
        }
    }

这部分就是根据父接口生成字节码，我们调用ProxyGenerator.generateProxyClass方法，然后根据我们的RealSubject对象生成一个代理类到本地。

 byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", RealSubject.class.getInterfaces());
        String path = "C:\\Users\\Administrator\\Desktop\\com\\RealSubject.class";
        try(FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("代理类class文件写入成功");
        } catch (Exception e) {
            System.out.println("写文件错误");
        }

打开生成好的RealSubject.class文件

可以看到动态生成了一个$Proxy0的代理类，继承自Proxy类，实现了我们的Subject接口，其构造方法是传递了一个InvocationHandler参数

同时实现了equals，hashCode，toString三个方法，以及我们自己定义的接口当中的方法，我们主要看接口当中定义的request方法如何实现

这里我们可以清楚地看到，调用的InvocationHandler实现类当中的invoke方法，m3就是我们自定类当中定义的方法

到这里为止，我们就可以清楚地看到为什么在调用request方法的时候，会调用DynamicProxy当中的我们自己实现的invoke方法，因为传递过去的就是我们自己的InvokationHandler对象。动态代理类的构造方法生成之后，传递进去的就是我们调用

Proxy.newProxyInstance()这个方法传递的自己的实现类