Spring 4.0 学习日记（7） ---动态代理

最新推荐文章于 2022-03-14 09:30:32 发布

大萌萌德

最新推荐文章于 2022-03-14 09:30:32 发布

阅读量442

点赞数

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/u011685720/article/details/76167196

版权

spring 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

写在前面

引用自http://blog.csdn.net/luanlouis/article/details/24589193

class文件简介及加载

这里写图片描述

这个过程就是编译器编译java之后产生只有JVM虚拟机才能识别的机器码保存在.class文件中然后虚拟机读取字节码文件取出二进制数据加载到内存中并且解析.class文件中的信息产生对应的class对象

在运行期的代码中生成二进制字节码

这里写图片描述
由于JVM通过字节码的二进制信息加载类的，那么，如果我们在运行期系统中，遵循Java编译系统组织.class文件的格式和结构，生成相应的二进制数据，然后再把这个二进制数据加载转换成对应的类，这样，就完成了在代码中，动态创建一个类的能力了。

在运行时期可以按照Java虚拟机规范对class文件的组织规则生成对应的二进制字节码。当前有很多开源框架可以完成这些功能，如ASM，Javassist。

其实这些都是底层的实现主要对应实现动态代理中Proxy类中的一个方法

    newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
    返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

上述方法的参数 ClassLoader

对于ClassLoader JavaTM Platform Standard Ed. 6 里的解释是

public abstract class ClassLoader extends Object

ClassLoader 类是一个抽象类。如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。
每个 Class 对象都包含一个对定义它的 ClassLoader 的引用。

ClassLoader 类使用委托模型来搜索类和资源。每个 ClassLoader 实例都有一个相关的父类加载器。需要查找类或资源时，ClassLoader 实例会在试图亲自查找类或资源之前，将搜索类或资源的任务委托给其父类加载器。

所以在实现newProxyInstance的时候 ClassLoader应该是一个加载类引用的实例关于newProxyInstance后面说明

代理的基本构成

代理模式上，基本上有Subject角色，RealSubject角色，Proxy角色。其中：Subject角色负责定义RealSubject和Proxy角色应该实现的接口；RealSubject角色用来真正完成业务服务功能；Proxy角色负责将自身的Request请求，调用realsubject 对应的request功能来实现业务功能，自己不真正做业务。

这里写图片描述

上面的这幅代理结构图是典型的静态的代理模式：
当在代码阶段规定这种代理关系，Proxy类通过编译器编译成class文件，当系统运行时，此class已经存在了。这种静态的代理模式固然在访问无法访问的资源，增强现有的接口业务功能方面有很大的优点，但是大量使用这种静态代理，会使我们系统内的类的规模增大，并且不易维护；并且由于Proxy和RealSubject的功能本质上是相同的，Proxy只是起到了中介的作用，这种代理在系统中的存在，导致系统结构比较臃肿和松散。
为了解决这个问题，就有了动态地创建Proxy的想法：在运行状态中，需要代理的地方，根据Subject 和RealSubject，动态地创建一个Proxy，用完之后，就会销毁，这样就可以避免了Proxy 角色的class在系统中冗杂的问题了。
下面以一个代理模式实例阐述这一问题：
将车站的售票服务抽象出一个接口TicketService,包含问询，卖票，退票功能，车站类Station实现了TicketService接口，车票代售点StationProxy则实现了代理角色的功能，类图如下所示。

这里写图片描述

InvocationHandler 接口

仔细思考代理模式中的代理Proxy角色。Proxy角色在执行代理业务的时候，无非是在调用真正业务之前或者之后做一些“额外”业务。

这里写图片描述

有上图可以看出，代理类处理的逻辑很简单：在调用某个方法前及方法后做一些额外的业务。换一种思路就是：在触发（invoke）真实角色的方法之前或者之后做一些额外的业务。那么，为了构造出具有通用性和简单性的代理类，可以将所有的触发真实角色动作交给一个触发的管理器，让这个管理器统一地管理触发。这种管理器就是Invocation Handler。

在静态代理中，代理Proxy中的方法，都指定了调用了特定的realSubject中的对应的方法：
在上面的静态代理模式下，Proxy所做的事情，无非是调用在不同的request时，调用触发realSubject对应的方法；更抽象点看，Proxy所作的事情；在Java中方法（Method）也是作为一个对象来看待了，

动态代理工作的基本模式就是将自己的方法功能的实现交给 InvocationHandler角色，外界对Proxy角色中的每一个方法的调用，Proxy角色都会交给InvocationHandler来处理，而InvocationHandler则调用具体对象角色的方法。如下图所示：

这里写图片描述

在这种模式之中：代理Proxy 和RealSubject 应该实现相同的功能，这一点相当重要。（我这里说的功能，可以理解为某个类的public方法）

在面向对象的编程之中，如果我们想要约定Proxy 和RealSubject可以实现相同的功能，有两种方式：

a.一个比较直观的方式，就是定义一个功能接口，然后让Proxy 和RealSubject来实现这个接口。
b.还有比较隐晦的方式，就是通过继承。因为如果Proxy 继承自RealSubject，这样Proxy则拥有了
RealSubject的功能，Proxy还可以通过重写RealSubject中的方法，来实现多态。

所以

InvocationHandler 是代理实例的调用处理程序 实现的接口。

说白了就是代理实例实现了接口 InvocationHandler下的invoke(Object proxy, Method method, Object[] args) 方法这个invoke 就是上述解释中类似于归纳了所有方法的触发器或者说调用处理程序
invoke方法根据代理类传递给自己的method参数来区分是什么方法。

对于方法invoke(Object proxy, Method method, Object[] args)的参数一共三个

Obejct proxy - 在其上调用方法的代理实例 这里和静态代理有些不同 静态代理的实例实现的还是所有委托方法的接口并在实现方法之上添加了很多其他的方法  动态代理的实例实现的是InvocationHandler 接口!!!!

method - 对应于在代理实例上调用的接口方法的 Method 实例。 Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。  就是自定义接口中定义的所有需要实现的所有方法

args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。 暂时我没用到 理解不多

JDK的动态代理创建机制—-通过接口

比如现在想为RealSubject这个类创建一个动态代理对象，JDK主要会做以下工作：

1.   获取 RealSubject上的所有接口列表；
2.   确定要生成的代理类的类名，默认为：com.sun.proxy.$ProxyXXXX ；
3.   根据需要实现的接口信息，在代码中动态创建 该Proxy类的字节码；
4 .  将对应的字节码转换为对应的class 对象；
5.   创建InvocationHandler 实例handler，用来处理Proxy所有方法调用；
6.   Proxy 的class对象 以创建的handler对象为参数，实例化一个proxy对象

动态代理类的特点

1.继承自 java.lang.reflect.Proxy，实现了 Rechargable,Vehicle 这两个ElectricCar实现的接口；
2.类中的所有方法都是final 的；
3.所有的方法功能的实现都统一调用了InvocationHandler的invoke()方法。

大致如下

这里写图片描述

PS
1）包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；
2）类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；
3）类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。
4）类继承关系：该类的继承关系如图：
这里写图片描述

由图可见，Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。

代理类实例的特点

每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。

在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行，此外，值得注意的是，代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。

当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。

代理的一组接口de特点

首先，要注意不能有重复的接口，以避免动态代理类代码生成时的编译错误。
其次，这些接口对于类装载器必须可见，否则类装载器将无法链接它们，将会导致类定义失败。
再次，需被代理的所有非 public 的接口必须在同一个包中，否则代理类生成也会失败。
最后，接口的数目不能超过 65535，这是 JVM 设定的限制。

动态代理实现需要的接口和方法

java.lang.reflect.Proxy：这是 Java 动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
Proxy 的静态方法

// 方法 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)

关于此方法的三个参数
1.ClassLoader 上面已经解释过了
2.Class[] interfaces 代理类要实现的接口列表
3.指派方法调用的调用处理程序 其实就是每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象

java.lang.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。

InvocationHandler 的核心方法

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
Object invoke(Object proxy, Method method, Object[] args)

实现代理的方法

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

动态代理对象创建过程

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); 

// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 

// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 

// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下

简化的动态代理对象创建过程

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..); 

// 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, 
     new Class[] { Interface.class }, 
     handler );

代理类的构造方法

// 由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用
private Proxy() {} 

// 由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用
protected Proxy(InvocationHandler h) {this.h = h;} 
//注意这里的参数的InvocationHandler h  后面的例子会用到

Proxy静态方法newProxyInstance

public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException { 
    // 检查 h 不为空，否则抛异常
    if (h == null) { 
        throw new NullPointerException(); 
    } 

    // 获得与指定类装载器和一组接口相关的代理类类型对象
    Class cl = getProxyClass(loader, interfaces); 

    // 通过反射获取构造函数对象并生成代理类实例
    try { 
        Constructor cons = cl.getConstructor(constructorParams); 
        return (Object) cons.newInstance(new Object[] { h }); 
    } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); 
    } catch (IllegalAccessException e) { throw new InternalError(e.toString()); 
    } catch (InstantiationException e) { throw new InternalError(e.toString()); 
    } catch (InvocationTargetException e) { throw new InternalError(e.toString()); 
    } 
}

以上就是所有需要了解的知识点了

然后看个小栗子

自定义的接口类

package com.wow.DynamicProxy;

public interface ProxyInterFace {

    public void getProxyInfo(String  name);

    public void getProxyId(int i);
}

实现接口的类

package com.wow.DynamicProxy;

public class ProxyOriginal implements ProxyInterFace{

    @Override
    public void getProxyInfo(String name) {
         System.out.println("------getProxyInfo------");  
    }

    @Override
    public void getProxyId(int i) {
         System.out.println("------getProxyId------");  
    }

}

中介类 (必须实现InvocationHandler接口)

package com.wow.DynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyDynamic implements InvocationHandler{
    private Object target;

    public ProxyDynamic() {
        super();        
    }

    public ProxyDynamic(Object target) {
        super();    
        this.target = target;//参见代理类的构造方法的参数 实现InvocationHandler的类对象
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        if("getProxyInfo".equals(method.getName())
                &&"getProxyId".equals(method.getName())){
            System.out.println("---" + method.getName() + "---");
            System.out.println("---" + method.getName() + "---");
            System.out.println("------------");
            return method.invoke(target, args);
        }else
        return method.invoke(target, args);
    }

}

动态生成代理类

package com.wow.DynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class ProxyImp {

    public static void main(String[] args) {
        //获取接口的实现类
        ProxyInterFace proInterface = new ProxyOriginal();
        //设置一个来自代理传过来的方法调用请求处理器，处理所有的代理对象上的方法调用  
        InvocationHandler invocationHandler = new ProxyDynamic(proInterface);
        //获取对应的ClassLoader  
        ClassLoader classLoader = proInterface.getClass().getClassLoader(); 
        //获取ProxyOriginal 所实现的所有接口
        Class[] interfaces = proInterface.getClass().getInterfaces();   
        /*根据上面提供的信息，创建代理对象 在这个过程中，  
        a.JDK会通过根据传入的参数信息动态地在内存中创建和.class 文件等同的字节码 
        b.然后根据相应的字节码转换成对应的class，  
        c.然后调用newInstance()创建实例 */
        Object obj = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        //获取对象
        ProxyInterFace pro = (ProxyInterFace) obj;
        pro.getProxyId(100);
        pro.getProxyInfo("小龙虾");

    }
}

写在后面

一个典型的动态代理创建对象过程可分为以下四个步骤：
1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);
2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入
Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。
生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）

PS 其实这个就是自己学Spring的时候自己的笔记思路有点乱然后这笔记也是参考了很多亲的博客恩就这样

大萌萌德

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring 4.0 学习日记（7） ---动态代理

写在前面引用自http://blog.csdn.net/luanlouis/article/details/24589193class文件简介及加载这个过程就是编译器编译java之后产生只有JVM虚拟机才能识别的机器码保存在.class文件中然后虚拟机读取字节码文件取出二进制数据加载到内存中并且解析.class文件中的信息产生对应的class对象在运行期的代码中生成二进制字节码
复制链接

扫一扫

专栏目录