• Java--动态代理


    本文转载+个人理解

     一、引言

      在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于 Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是 java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾。

    二、概述  

      在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的:

    InvocationHandler:

    InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 
    
    Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance

    the method invocation is encoded and dispatched to the invoke method of its invocation handler.

    每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用 一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法:

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

    我们看到这个方法一共接受三个参数,那么这三个参数分别代表什么呢?

    Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    
    proxy:  指代我们所代理的那个真实对象
    method:  指代的是我们所要调用真实对象的某个方法的Method对象
    args:  指代的是调用真实对象某个方法时接受的参数

    如果不是很明白,等下通过一个实例会对这几个参数进行更深的讲解。

    接下来我们来看看Proxy这个类:

    Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods. 

    Proxy这个类的作用就是用来动态创建一个代理对象的类,它提供了许多的方法,但是我们用的最多的就是 newProxyInstance 这个方法:

    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h) 
    throws IllegalArgumentException
    Returns an instance of a proxy class for the specified interfaces that dispatches method invocations 
    to the specified invocation handler.

    这个方法的作用就是得到一个动态的代理对象,其接收三个参数,我们来看看这三个参数所代表的含义:

     
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 

    throws IllegalArgumentException loader:  一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载 interfaces:  一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,
          那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了。
          这个就是动态代理的一个核心,通过参数传递,实现相关接口。
    h:  一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上
     

    三、实例

      首先我们定义了一个Subject类型的接口,为其声明了两个方法:

    1 public interface Subject
    2 {
    3     public void rent();
    4     
    5     public void hello(String str);
    6 }

    接着,定义了一个类来实现这个接口,这个类就是我们的真实对象,RealSubject类:

     1 public class RealSubject implements Subject
     2 {
     3     @Override
     4     public void rent()
     5     {
     6         System.out.println("I want to rent my house");
     7     }
     8     
     9     @Override
    10     public void hello(String str)
    11     {
    12         System.out.println("hello: " + str);
    13     }
    14 }

    下一步,我们就要定义一个动态代理类了,前面说个,每一个动态代理类都必须要实现 InvocationHandler 这个接口,因此我们这个动态代理类也不例外:

     1 public class DynamicProxy implements InvocationHandler
     2 {
     3     // 这个就是我们要代理的真实对象
     4     private Object subject;
     5     
     6     //    构造方法,给我们要代理的真实对象赋初值
     7     public DynamicProxy(Object subject)
     8     {
     9         this.subject = subject;
    10     }
    11     
    12     @Override
    13     public Object invoke(Object object, Method method, Object[] args)
    14             throws Throwable
    15     {
    16         //  在代理真实对象前我们可以添加一些自己的操作
    17         System.out.println("before rent house");
    18         
    19         System.out.println("Method:" + method);
    20         
    21         //    当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
    22         method.invoke(subject, args);
    23         
    24         //  在代理真实对象后我们也可以添加一些自己的操作
    25         System.out.println("after rent house");    
    27         return null;
    28     }
    29 
    30 }

    最后,来看看我们的Client类:

    public class Client
    {
        public static void main(String[] args)
        {
            //    我们要代理的真实对象
            Subject realSubject = new RealSubject();
    
            //    我们要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法的
            InvocationHandler handler = new DynamicProxy(realSubject);
    
            /*
             * 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数
             * 第一个参数 handler.getClass().getClassLoader() ,
          * 我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象 * 第二个参数realSubject.getClass().getInterfaces(),我们这里为代理对象提供的接口是真实对象所实现的接口,
                      表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了 * 第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
    */ Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(),
               realSubject.getClass().getInterfaces(), handler); System.out.println(subject.getClass().getName()); subject.rent(); subject.hello(
    "world"); } }

    输出结果:

    $Proxy0
    before rent house Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent() I want to rent my house after rent house before rent house Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String) hello: world after rent house

     结果分析:

      我们首先来看看 $Proxy0 这东西,我们看到,这个东西是由 System.out.println(subject.getClass().getName()); 这条语句打印出来的,那么为什么我们返回的这个代理对象的类名是这样的呢?

    Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
                    .getClass().getInterfaces(), handler);

    为什么我们这里可以将其转化为Subject类型的对象?原 因就是在newProxyInstance这个方法的第二个参数上,我们给这个代理对象提供了一组什么接口,那么我这个代理对象就会实现了这组接口,这个 时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个,因为这里的接口是Subject类型,所以就可以将其转化为Subject类型了。但是如果被代理的对象没有实现任何的接口,该如何处理???? ---源码中解释: interfaces the list of interfaces for the proxy class to implement.

    同时我们一定要记住,通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象,它并不是我们的InvocationHandler类型,也不是我们定义的那组接口的类型,而是在运 行是动态生成的一个对象,并且命名方式都是这样的形式,以$开头,proxy为中,最后一个数字表示对象的标号

      

      这样一来,通过生成的新的代理对象调用被代理对象的方法,

        return a proxy instance with the specified invocation handler of a   proxy class that is defined by the specified class loader  and     that implements the specified interfaces。

    四、动态代理的作用

      1、方法增强,从上面的实例中我们可以看出在执行被代理对象的方法前后我们都可以执行一些我们想要的动作,来增强原来的方法。

      2、用作远程调用,比如现在有Java接口,这个接口的实现部署在其它服务器上,在编写客户端代码的时候,没办法直接调用接口方法,因为接口是不能直接生成对象的,这个时候就可以考虑代理模式(动态代理)了,通过Proxy.newProxyInstance代理一个该接口对应的InvocationHandler对象,然后在InvocationHandler的invoke方法内封装通讯细节就可以了。具体的应用,最经典的当然是Java标准库的RMI。

                                                    了解更多

    五、补充

      1、在Procxy中的静态方法:

      // 方法 1: 该方法用于获取指定代理对象所关联的调用处理器

      static InvocationHandler getInvocationHandler(Object proxy)

      // 方法 2:该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象

      static Class getProxyClass(ClassLoader loader, Class[] interfaces)

      // 方法 3:该方法用于判断指定类对象是否是一个动态代理类

      static boolean isProxyClass(Class cl)

      // 方法 4:该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例

      static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

      2、Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用,它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。每次生成动态代理类对象时都需要指定一个类装载器对象,就是上面方法4的第一个参数,由他来对生成的动态代理对象进行加载。

      

  • 相关阅读:
    201771010135 杨蓉庆《面对对象程序设计(java)》第十五周学习总结
    201771010135 杨蓉庆/张燕/杨玲《面对对象程序设计(java)》第十四周学习总结
    201771010135 杨蓉庆/张燕《面对对象程序设计(java)》第十三周学习总结
    团队作业6—复审与事后分析
    团队作业6——Alpha阶段项目复审
    团队作业6——事后分析
    团队作业5——测试与发布(Alpha版本)
    团队作业4-项目汇总
    团队作业4-Day7
    团队作业4-Day6
  • 原文地址:https://www.cnblogs.com/plxx/p/4652552.html
Copyright © 2020-2023  润新知