深度剖析java中JDK动态代理机制

摘要

相比于静态代理,动态代理避免了开发人员编写各个繁锁的静态代理类,只需简单地指定一组接口及目标类对象就能动态的获得代理对象。

代理模式

使用代理模式必须要让代理类和目标类实现相同的接口,客户端通过代理类来调用目标方法,代理类会将所有的方法调用分派到目标对象上反射执行,还可以在分派过程中添加"前置通知"和后置处理(如在调用目标方法前校验权限,在调用完目标方法后打印日志等)等功能。

使用动态代理的五大步骤

1.通过实现InvocationHandler接口来自定义自己的InvocationHandler;

2.通过Proxy.getProxyClass获得动态代理类

3.通过反射机制获得代理类的构造方法,方法签名为getConstructor(InvocationHandler.class)

4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入

5.通过代理对象调用目标方法

动态代理的使用

例1(方式一)

public class MyProxy {

  public interface IHello{

    void sayHello();

  }

  static class Hello implements IHello{

    public void sayHello() {

      System.out.println("Hello world!!");

    }

  }

  //自定义InvocationHandler

  static class HWInvocationHandler implements InvocationHandler{

    //目标对象

    private Object target;

    public HWInvocationHandler(Object target){

      this.target = target;

    }

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

      System.out.println("------插入前置通知代码-------------");

      //执行相应的目标方法

      Object rs = method.invoke(target,args);

      System.out.println("------插入后置处理代码-------------");

      return rs;

    }

  }

  public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc  eption, InstantiationException {

    //生成$Proxy0的class文件

    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

    //获取动态代理类

    Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);

    //获得代理类的构造函数,并传入参数类型InvocationHandler.class

    Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);

    //通过构造函数来创建动态代理对象,将自定义的InvocationHandler实例传入

    IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));

    //通过代理对象调用目标方法

    iHello.sayHello();

  }

}

输出:

------插入前置通知代码-------------
Hello world!!
------插入后置处理代码-------------

Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象,其方法签名为:newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h),如下例:

(方式二)

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

    //生成$Proxy0的class文件

    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

    IHello ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), //加载接口的类加载器

        new Class[]{IHello.class},   //一组接口

        new HWInvocationHandler(new Hello())); //自定义的InvocationHandler

    ihello.sayHello();

  }

输出结果一样.

下面以newProxyInstance方法为切入点来剖析代理类的生成及代理方法的调用

(为了篇幅整洁去掉了次要的代码)

public static Object newProxyInstance(ClassLoader loader,

                     Class<!--?-->[] interfaces,

                     InvocationHandler h)

      throws IllegalArgumentException

  {

    if (h == null) {  //如果h为空直接抛出异常,所以InvocationHandler实例对象是必须的

      throw new NullPointerException();

    }

    //对象的拷贝,暂不知道这里拷贝下的意义是啥?

    final Class<!--?-->[] intfs = interfaces.clone();

    //一些安全的权限检查

    final SecurityManager sm = System.getSecurityManager();

    if (sm != null) {

      checkProxyAccess(Reflection.getCallerClass(), loader, intfs);

    }

    //产生代理类

    Class<!--?--> cl = getProxyClass0(loader, intfs);

    //获取代理类的构造函数对象

    //参数constructorParames为常量值:private static final Class<!--?-->[] constructorParams = { InvocationHandler.class };

    final Constructor<!--?--> cons = cl.getConstructor(constructorParames);

    final InvocationHandler ih = h;

    //根据代理类的构造函数对象来创建代理类对象

    return newInstance(cons, ih);

  }

这段代码就是对代理类对象的创建,就是对例1中34~38行封装,其中getProxyClass0就是生成代理类的方法

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

  }

看看ProxyClassFactory是怎样生成代理类的?

private static final class ProxyClassFactory

    implements BiFunction<classloader, class<?="">[], Class<!--?-->>

  {

    //统一代理类的前缀名都以$Proxy开关

    private static final String proxyClassNamePrefix = "$Proxy";

    //使用唯一的编号给作为代理类名的一部分,如$Proxy0,$Proxy1等

    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) {

        //验证指定的类加载器(loader)加载接口所得到的Class对象(interfaceClass)是否与intf对象相同

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

        }

        //验证该Class对象是不是接口

        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;  

      /*验证你传入的接口中是否有非public接口,只要有一个接口是非public的,那么这些接口都必须在同一包中

      这里的接口修饰符直接影响到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成

      的代理类的路径,往下看!!*/

      for (Class<!--?--> intf : interfaces) {

        int flags = intf.getModifiers();

        if (!Modifier.isPublic(flags)) {

          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包下如果报java.io.FileNotFoundException: com\sun\proxy\$Proxy0.c         lass (系统找不到指定的路径。)的错误,就先在你项目中创建com.sun.proxy路径*/      

        proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";

      }

       //将当前nextUniqueNumber的值以原子的方式的加1,所以第一次生成代理类的名字为$Proxy0.class

      long num = nextUniqueNumber.getAndIncrement();

      //代理类的完全限定名,如com.sun.proxy.$Proxy0.calss,

      String proxyName = proxyPkg + proxyClassNamePrefix + num;

      //生成代理类字节码文件       

      byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

        proxyName, interfaces);

      try {

        return defineClass0(loader, proxyName,

                  proxyClassFile, 0, proxyClassFile.length);

      } catch (ClassFormatError e) {

        throw new IllegalArgumentException(e.toString());

      }

    }

  }</class<?></classloader,>

而生成代理类字节码文件又主要通过ProxyGenerate的generateProxyClass(proxyName,interfaces)

public static byte[] generateProxyClass(final String var0, Class[] var1) {

    ProxyGenerator var2 = new ProxyGenerator(var0, var1);

    //生成代理类字节码文件的真正方法

    final byte[] var3 = var2.generateClassFile();

    //保存文件

    if(saveGeneratedFiles) {

      AccessController.doPrivileged(new PrivilegedAction() {

        public Void run() {

          try {

            FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");

            var1.write(var3);

            var1.close();

            return null;

          } catch (IOException var2) {

            throw new InternalError("I/O exception saving generated file: " + var2);

          }

        }

      });

    }

    return var3;

  }

层层调用后,最终generateClassFile才是真正生成代理类字节码文件的方法,注意开头的三个addProxyMethod方法是只将Object的hashcode,equals,toString方法添加到代理方法容器中,代理类除此之外并没有重写其他Object的方法,所以除这三个方法外,代理类调用其他方法的行为与Object调用这些方法的行为一样不通过Invoke

private byte[] generateClassFile() {

    /addProxyMethod系列方法就是将接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),

     其中方法签名作为key,proxyMethod作为value*/

    /*hashCodeMethod方法位于静态代码块中通过Object对象获得,hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),

     相当于从Object中继承过来了这三个方法equalsMethod,toStringMethod*/  

    this.addProxyMethod(hashCodeMethod, Object.class);  -->

    this.addProxyMethod(equalsMethod, Object.class);

    this.addProxyMethod(toStringMethod, Object.class);

    int var1;

    int var3;

     //获得所有接口中的所有方法,并将方法添加到代理方法中

    for(var1 = 0; var1 < this.interfaces.length; ++var1) {

      Method[] var2 = this.interfaces[var1].getMethods();      

      for(var3 = 0; var3 < var2.length; ++var3) {

        this.addProxyMethod(var2[var3], this.interfaces[var1]);

      }

    }

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

    List var8;

    while(var7.hasNext()) {

      var8 = (List)var7.next();

      checkReturnTypes(var8);  //验证具有相同方法签名的的方法的返回值类型是否一致,因为不可能有两个方法名相同,参数相同,而返回值却不同的方法

    };

  //接下来就是写代理类文件的步骤了

    Iterator var11

    try {

       //生成代理类的构造函数

      this.methods.add(this.generateConstructor());

      var7 = this.proxyMethods.values().iterator();

      while(var7.hasNext()) {

        var8 = (List)var7.next();

        var11 = var8.iterator();

        while(var11.hasNext()) {

          ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();

          /将代理字段声明为Method,10为ACC_PRIVATE和ACC_STATAIC的与运算,表示该字段的修饰符为private static

           所以代理类的字段都是private static Method XXX*/

          this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));

          //生成代理类的代理方法

          this.methods.add(var4.generateMethod());

        }

      }

      //为代理类生成静态代码块,对一些字段进行初始化

      this.methods.add(this.generateStaticInitializer());

    } catch (IOException var6) {

      throw new InternalError("unexpected I/O Exception");

    }

    if(this.methods.size() > '\uffff') { //代理方法超过65535将抛出异常

      throw new IllegalArgumentException("method limit exceeded");

    } else if(this.fields.size() > '\uffff') {  //代理类的字段超过65535将抛出异常

      throw new IllegalArgumentException("field limit exceeded");

    } else {

     //这里开始就是一些代理类文件的过程,此过程略过

      this.cp.getClass(dotToSlash(this.className));

      this.cp.getClass("java/lang/reflect/Proxy");

      for(var1 = 0; var1 < this.interfaces.length; ++var1) {

        this.cp.getClass(dotToSlash(this.interfaces[var1].getName()));

      }

      this.cp.setReadOnly();

      ByteArrayOutputStream var9 = new ByteArrayOutputStream();

      DataOutputStream var10 = new DataOutputStream(var9);

      try {

        var10.writeInt(-889275714);

        var10.writeShort(0);

        var10.writeShort(49);

        this.cp.write(var10);

        var10.writeShort(49);

        var10.writeShort(this.cp.getClass(dotToSlash(this.className)));

        var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));

        var10.writeShort(this.interfaces.length);

        for(var3 = 0; var3 < this.interfaces.length; ++var3) {

          var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName())));

        }

        var10.writeShort(this.fields.size());

        var11 = this.fields.iterator();

        while(var11.hasNext()) {

          ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();

          var12.write(var10);

        }

        var10.writeShort(this.methods.size());

        var11 = this.methods.iterator();

        while(var11.hasNext()) {

          ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();

          var13.write(var10);

        }

        var10.writeShort(0);

        return var9.toByteArray();

      } catch (IOException var5) {

        throw new InternalError("unexpected I/O Exception");

      }

    }

  }

addProxyMethod方法剖析

private void addProxyMethod(Method var1, Class var2) {

    String var3 = var1.getName(); //方法名

    Class[] var4 = var1.getParameterTypes();  //方法参数类型数组

    Class var5 = var1.getReturnType();  //返回值类型 

    Class[] var6 = var1.getExceptionTypes();  //异常类型

    String var7 = var3 + getParameterDescriptors(var4);  //方法签名

    Object var8 = (List)this.proxyMethods.get(var7);  //根据方法签名却获得proxyMethods的Value

    if(var8 != null) {  //处理多个代理接口中重复的方法的情况

      Iterator var9 = ((List)var8).iterator();

      while(var9.hasNext()) {

        ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();

        if(var5 == var10.returnType) {

          /*归约异常类型以至于让重写的方法抛出合适的异常类型,我认为这里可能是多个接口中有相同的方法,而这些相同的方法抛出的异常类           型又不同,所以对这些相同方法抛出的异常进行了归约*/

          ArrayList var11 = new ArrayList();

          collectCompatibleTypes(var6, var10.exceptionTypes, var11);

          collectCompatibleTypes(var10.exceptionTypes, var6, var11);

          var10.exceptionTypes = new Class[var11.size()];

          //将ArrayList转换为Class对象数组

          var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);

          return;

        }

      }

    } else {

      var8 = new ArrayList(3);

      this.proxyMethods.put(var7, var8);

    }   

    ((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));

    /*24~27行的意思就是如果var8为空,就创建一个数组,并以方法签名为key,proxymethod对象数组为value添加到proxyMethods*/

  }

InvocationHandler的作用

在动态代理中InvocationHandler是核心,每个代理实例都具有一个关联的调用处理程序(InvocationHandler)。对代理实例调用方法时,将对方法调用进行编码并将其指派到它的调用处理程序(InvocationHandler)的 invoke 方法。所以对代理方法的调用都是通InvocationHadler的invoke来实现中,而invoke方法根据传入的代理对象,方法和参数来决定调用代理的哪个方法

invoke方法签名:invoke(Object Proxy,Method method,Object[] args)

 $Proxy0.class

来看看例1(MyProxy)的代理类是怎样的?

public final class $Proxy0 extends Proxy implements IHello {  //继承了Proxy类和实现IHello接口

  //变量,都是private static Method XXX

  private static Method m3;  

  private static Method m1;

  private static Method m0;

  private static Method m2;

  //代理类的构造函数,其参数正是是InvocationHandler实例,Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的

  public $Proxy0(InvocationHandler var1) throws {

    super(var1);

  }

  //接口代理方法

  public final void sayHello() throws {

    try {

      super.h.invoke(this, m3, (Object[])null);

    } catch (RuntimeException | Error var2) {

      throw var2;

    } catch (Throwable var3) {

      throw new UndeclaredThrowableException(var3);

    }

  }

  //以下Object中的三个方法

  public final boolean equals(Object var1) throws {

    try {

      return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();

    } catch (RuntimeException | Error var3) {

      throw var3;

    } catch (Throwable var4) {

      throw new UndeclaredThrowableException(var4);

    }

  }

  public final int hashCode() throws {

    try {

      return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();

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

    }

  }

  //对变量进行一些初始化工作

  static {

    try { 

      m3 = Class.forName("com.mobin.proxy.IHello").getMethod("sayHello", new Class[0]);

      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});

      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);

    } catch (NoSuchMethodException var2) {

      throw new NoSuchMethodError(var2.getMessage());

    } catch (ClassNotFoundException var3) {

      throw new NoClassDefFoundError(var3.getMessage());

    }

  }

}

以上就是对代理类如何生成,代理类方法如何被调用的分析!在很多框架都使用了动态代理如Spring,HDFS的RPC调用等等,分析过程中收获很多,如果想深入的了解JDK动态代理机制一定要深入到源码去剖析!!希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • java 代理机制的实例详解

    java 代理机制的实例详解 前言: java代理分静态代理和动态代理,动态代理有jdk代理和cglib代理两种,在运行时生成新的子类class文件.本文主要练习下动态代理,代码用于备忘.对于代理的原理和机制,网上有很多写的很好的,就不班门弄斧了. jdk代理 实例代码 import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; publi

  • Java CGLib动态代理机制(全面解析)

    一.首先说一下JDK中的动态代理: JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的 但是,JDK中所要进行动态代理的类必须要实现一个接口,也就是说只能对该类所实现接口中定义的方法进行代理,这在实际编程中具有一定的局限性,而且使用反射的效率也并不是很高. 二.使用CGLib实现: 使用CGLib实现动态代理,完全不受代理类必须实现接口的限制,而且CGLib底层采用ASM字节码生成框架,使用字节码技术生成代理类,比使用Java反射效率要高.唯一需要注意的

  • 深入理解java动态代理机制

    retrofit是一个解耦性非常高的网络请求框架,最近在研究的时候发现了动态代理这个非常强大且实用的技术,这篇文章将作为retrofit的前置知识,让大家认识:动态代理有哪些应用场景,什么是动态代理,怎样使用,它的局限性在什么地方? 动态代理的应用场景 1. AOP-面向切面编程,程序解耦 简言之当你想要对一些类的内部的一些方法,在执行前和执行后做一些共同的的操作,而在方法中执行个性化操作的时候--用动态代理.在业务量庞大的时候能够降低代码量,增强可维护性. 2. 想要自定义第三放类库中的某些方

  • java 代理模式及动态代理机制深入分析

    java 代理模式及动态代理机制深入分析 代理设计模式 代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问.代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理. 代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问.在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用. 代理模式一般涉及到的角色有: 抽象角色:声明真实对象和代理对象的共同接口: 代理角色:代理对象角色内

  • Java动态代理机制详解_动力节点Java学院整理

    class文件简介及加载 Java编译器编译好Java文件之后,产生.class 文件在磁盘中.这种class文件是二进制文件,内容是只有JVM虚拟机能够识别的机器码.JVM虚拟机读取字节码文件,取出二进制数据,加载到内存中,解析.class 文件内的信息,生成对应的 Class对象: class字节码文件是根据JVM虚拟机规范中规定的字节码组织规则生成的.具体class文件是怎样组织类信息的,可以参考 此博文:深入理解Java Class文件格式系列.或者是Java虚拟机规范. 下面通过一段代

  • 深度剖析java中JDK动态代理机制

    摘要 相比于静态代理,动态代理避免了开发人员编写各个繁锁的静态代理类,只需简单地指定一组接口及目标类对象就能动态的获得代理对象. 代理模式 使用代理模式必须要让代理类和目标类实现相同的接口,客户端通过代理类来调用目标方法,代理类会将所有的方法调用分派到目标对象上反射执行,还可以在分派过程中添加"前置通知"和后置处理(如在调用目标方法前校验权限,在调用完目标方法后打印日志等)等功能. 使用动态代理的五大步骤 1.通过实现InvocationHandler接口来自定义自己的Invocati

  • Java中JDK动态代理的超详细讲解

    目录 1. 什么是动态代理? 2.动态代理的实现方式有几种? 3. JDK动态代理 4. CGLB动态代理 5.动态代理的效率 6.为什么要使用动态代理呢? 7. JDK动态代理详细使用介绍 总结 1. 什么是动态代理? 动态代理是通过创建代理对象,在不改变原有代码的基础上,给程序增加新的功能,实现了程序的功能增强. 2.动态代理的实现方式有几种? JDK动态代理 CGLB动态代理 3. JDK动态代理 使用了JDK中的InvocationHandler接口,Method类和Proxy类.JDK

  • 详解Java的Proxy动态代理机制

    一.Jvm加载对象 在说Java动态代理之前,还是要说一下Jvm加载对象的过程,这个依旧是理解动态代理的基础性原理: Java类即源代码程序.java类型文件,经过编译器编译之后就被转换成字节代码.class类型文件,类加载器负责读取字节代码,并转换成java.lang.Class对象,描述类在元数据空间的数据结构,类被实例化时,堆中存储实例化的对象信息,并且通过对象类型数据的指针找到类. 过程描述:源码->.java文件->.class文件->Class对象->实例对象 所以通过

  • 浅析Java中的动态代理

    目录 代理常见功能 代理模式的组成 代理模式分类 动态代理实现的技术 JDK 代理的实现步骤 CGLIB 代理实现步骤 代理常见功能 日志代理 数据库访问的事务代理 代理模式的组成 抽象主题:通过接口或抽象类定义核心业务方法. 真实主题:实现了接口的实现类,是实施代理的具体对象.即代理最终代理的是具体的实现类类而不是接口. 代理:具有与代理对象相同的方法,可以控制和扩展被代理对象的功能,也是使用代理对象的根据目的. 代理对象 = 增强代码 + 目标对象(原对象) 代理模式分类 静态代理:代理类与

  • Java中反射动态代理接口的详解及实例

    Java语言中反射动态代理接口的解释与演示 Java在JDK1.3的时候引入了动态代理机制.可以运用在框架编程与平台编程时候捕获事件.审核数据.日志等功能实现,首先看一下设计模式的UML图解: 当你调用一个接口API时候,实际实现类继承该接口,调用时候经过proxy实现. 在Java中动态代理实现的两个关键接口类与class类分别如下: java.lang.reflect.Proxy java.lang.reflect.InvocationHandler 我们下面就通过InvocationHan

  • Java实现JDK动态代理的原理详解

    目录 概念 案例 静态代理 JDK动态代理模式 原理分析 真相大白 概念 代理:为控制A对象,而创建出新B对象,由B对象代替执行A对象所有操作,称之为代理.一个代理体系建立涉及到3个参与角色:真实对象(A),代理对象(B),客户端. 其中的代理对象(B)起到中介作用,连通真实对象(A)与客户端,如果进一步拓展,代理对象可以实现更加复杂逻辑,比如对真实对象进行访问控制. 案例 需求:员工业务层接口调用save需要admin权限,调用list不需要权限,没权限调用时抛出异常提示. 静态代理 /**

  • 深度剖析Java中的内存原型及工作原理

    本文主要通过分析Java内存分配的栈.堆以以及常量池详细的讲解了其的工作原理. 一.java虚拟机内存原型 寄存器:我们在程序中无法控制栈:存放基本类型的数据和对象的引用,但对象本身不存放在栈中,而是存放在堆中堆:存放用new产生的数据静态域:存放在对象中用static定义的静态成员常量池:存放常量非RAM存储:硬盘等永久存储空间. 二.常量池(constant pool) 常量池指的是在编译期被确定,并被保存在已编译的.class文件中的一些数据.除了包含代码中所定义的各种基本类型(如int.

  • 十分钟理解Java中的动态代理

    若代理类在程序运行前就已经存在,那么这种代理方式被成为 静态代理 ,这种情况下的代理类通常都是我们在Java代码中定义的. 通常情况下, 静态代理中的代理类和委托类会实现同一接口或是派生自相同的父类. 一.概述 1. 什么是代理 我们大家都知道微商代理,简单地说就是代替厂家卖商品,厂家"委托"代理为其销售商品.关于微商代理,首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁,也就是说,"委托者"对我们来说是不可见的;其次,微商代理主要以朋友圈的人为目标客户,这就

  • java 中动态代理机制的实例讲解

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

  • Java动态代理机制的实例详解

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

随机推荐