java 动态代理（二）

Java中的动态代理

      java中的动态代理是如何工作的

       java动态代理是一种通过反射机制在运行时动态创建代理对象的机制。动态代理主要通过两个核心的类来实现：java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler

        什么是Proxy类

          类是实现动态代理的主要类，他提供了静态方法newProxyInstance(),该方法用户创建代理对象。newProxyInstance()方法接受三个参数：ClassLoader loader、Class[] interfaces和InvocationHandler h。其中，ClassLoader用于指定代理类的ClassLoader，interfaces用于指定代理类需要实现的接口，InvocationHandler用于指定代理类中的调用处理程序。

 Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),new DemoInvvocationHandler(target)
                );

          在创建对象时，newProxyInstance()方法会动态生成一个代理类，并返回代理类的实例。这个类实现了制定的接口，并将接口中所有的方法转发给制定的

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

        //首先检查InvocationHandler对象是否为null，然后，他克隆接口阵列，以保证原始阵列不会被修改
        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);
            }
             //获取代理类的构造函数，并使用制定的InnocationHandler创建该类的新实例，如果构造方法不是公共的，则该方法使用则该方法使用PrivilegedAction使其可访问
            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);
        }
    }

             什么是InvocationHandler接口

            它定义了一个方法invoke,用户处理对象上的方法调用，当一个方法被调用时，代理对象会把调用转发给他关联的InvocationHandler实例的invoke方法来处理。

InvocationHandler接口有一个方法invoke(Object proxy, Method method, Object[] args)，其中proxy是代理对象，method是被调用的方法对象，args是被调用方法的参数。该方法返回一个Object，即方法调用的结果。

在invoke方法中，可以通过对method对象的分析和处理，实现对代理对象方法的增强、过滤、记录

等功能。例如，可以在invoke方法中打印方法的调用信息，统计方法的执行时间等

   @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("====>方法执行前");
        Object result=method.invoke(this.target);
        System.out.println(" 执行结果："+result);
        System.out.println("<=======方法执行后");
        return result;
    }

       

    @CallerSensitive
    public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

动态代理的应用

       Aop（面向切面编程的实现）

      实现原理：

     常见的实现，我们根据其作用的不同时间阶段进行分类，有这样两种：

编译期间的静态织入，又称为编译时增强。织入（Weaving），指的是将切面代码和源业务代码链接起来的过程。AspectJ 就是这样一个面向切面的 Java 语言扩展，称呼其为语言的“扩展”，就是因为它扩展了 Java 语言的语法，需要特定的编译器来把 AspectJ 的代码编译成 JVM 可识别的 class 文件。

运行期间的动态代理，又称为运行时增强。这种方式是在程序运行时，依靠预先创建或运行时创建的代理类来完成切面功能的。比如 JDK 基于接口的动态代理技术，或 CGLib 基于类的代理对象生成技术就属于这一种。

Spring AOP 默认支持的是后者——运行期间的动态代理。至于具体实现，通常来说，我们应该优先考虑使用 JDK 的动态代理技术；但是如果目标类没有实现接口，我们只能退而求其次，使用 CGLib。

       1.定义切面逻辑

       2.创建代理对象

      3.将切面逻辑注入代理对象

      4、应用aOP

      首先需要定义切面逻辑，急需要在目标方法执行前或者执行后的操作，

       远程方法Rpc的实现

      prc框架也是一种代理模式，通过远程代理，将网络通信，数据编码等细节隐藏起来，客户段在使用RPCF服务的时候，就像使用本地函数一样，无需了解跟服务器交互的细节，除夕之外，RPC

服务的开发者只需要开发业务逻辑，就像开发本地函数一样，不需要关注客户端的交互使用。

       动态代理在框架中的使用