当前位置: 首页 > 编程笔记 >

Java 动态代理与CGLIB详细介绍

龚承嗣
2023-03-14
本文向大家介绍Java 动态代理与CGLIB详细介绍,包括了Java 动态代理与CGLIB详细介绍的使用技巧和注意事项,需要的朋友参考一下

静态代理模式

因为需要对一些函数进行二次处理,或是某些函数不让外界知道时,可以使用代理模式,通过访问第三方,间接访问原函数的方式,达到以上目的。

interface Hosee{
  String sayhi();
}

class Hoseeimpl implements Hosee{

  @Override
  public String sayhi()
  {
    return "Welcome oschina hosee's blog";
  }

}

class HoseeProxy implements Hosee{

  Hosee h;

  public HoseeProxy(Hosee h)
  {
    this.h = h;
  }

  @Override
  public String sayhi()
  {
    System.out.println("I'm proxy!");
    return h.sayhi();
  }

}


public class StaticProxy
{

  public static void main(String[] args)
  {
    Hoseeimpl h = new Hoseeimpl();
    HoseeProxy hp = new HoseeProxy(h);
    System.out.println(hp.sayhi());
  }

}

1.1 静态代理的弊端

如果要想为多个类进行代理,则需要建立多个代理类,维护难度加大。

仔细想想,为什么静态代理会有这些问题,是因为代理在编译期就已经决定,如果代理哪个发生在运行期,这些问题解决起来就比较简单,所以动态代理的存在就很有必要了。

2.动态代理

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

interface HoseeDynamic
{
  String sayhi();
}

class HoseeDynamicimpl implements HoseeDynamic
{
  @Override
  public String sayhi()
  {
    return "Welcome oschina hosee's blog";
  }
}

class MyProxy implements InvocationHandler
{
  Object obj;
  public Object bind(Object obj)
  {
    this.obj = obj;
    return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
        .getClass().getInterfaces(), this);
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable
  {
    System.out.println("I'm proxy!");
    Object res = method.invoke(obj, args);
    return res;
  }
}

public class DynamicProxy
{
  public static void main(String[] args)
  {
    MyProxy myproxy = new MyProxy();
    HoseeDynamicimpl dynamicimpl = new HoseeDynamicimpl();
    HoseeDynamic proxy = (HoseeDynamic)myproxy.bind(dynamicimpl);
    System.out.println(proxy.sayhi());
  }
}

类比静态代理,可以发现,代理类不需要实现原接口了,而是实现InvocationHandler。通过

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
        .getClass().getInterfaces(), this);

来动态生成一个代理类,该类的类加载器与被代理类相同,实现的接口与被代理类相同。

通过上述方法生成的代理类相当于静态代理中的代理类。

这样就实现了在运行期才决定代理对象是怎么样的,解决了静态代理的弊端。

当动态生成的代理类调用方法时,会触发invoke方法,在invoke方法中可以对被代理类的方法进行增强。

通过动态代理可以很明显的看到它的好处,在使用静态代理时,如果不同接口的某些类想使用代理模式来实现相同的功能,将要实现多个代理类,但在动态代理中,只需要一个代理类就好了。

除了省去了编写代理类的工作量,动态代理实现了可以在原始类和接口还未知的时候,就确定代理类的代理行为,当代理类与原始类脱离直接联系后,就可以很灵活地重用于不同的应用场景中。

2.1 动态代理的弊端

代理类和委托类需要都实现同一个接口。也就是说只有实现了某个接口的类可以使用Java动态代理机制。但是,事实上使用中并不是遇到的所有类都会给你实现一个接口。因此,对于没有实现接口的类,就不能使用该机制。

而CGLIB则可以实现对类的动态代理

2.2 回调函数原理

上文说了,当动态生成的代理类调用方法时,会触发invoke方法。

很显然invoke方法并不是显示调用的,它是一个回调函数,那么回调函数是怎么被调用的呢?

上述动态代理的代码中,唯一不清晰的地方只有

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
        .getClass().getInterfaces(), this);

跟踪这个方法的源码,可以看到程序进行了验证、优化、缓存、同步、生成字节码、显示类加载等操作,前面的步骤并不是我们关注的重点,而最后它调用了

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
        proxyName, interfaces);

该方法用来完成生成字节码的动作,这个方法可以在运行时产生一个描述代理类的字节码byte[]数组。

在main函数中加入

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

加入这句代码后再次运行程序,磁盘中将会产生一个名为”$Proxy().class”的代理类Class文件,反编译(反编译工具我使用的是 JD-GUI )后可以看见如下代码:

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

public final class $Proxy0 extends Proxy
 implements HoseeDynamic
{
 private static Method m1;
 private static Method m3;
 private static Method m0;
 private static Method m2;

 public $Proxy0(InvocationHandler paramInvocationHandler)
  throws 
 {
  super(paramInvocationHandler);
 }

 public final boolean equals(Object paramObject)
  throws 
 {
  try
  {
   return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 public final String sayhi()
  throws 
 {
  try
  {
   return (String)this.h.invoke(this, m3, null);
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 public final int hashCode()
  throws 
 {
  try
  {
   return ((Integer)this.h.invoke(this, m0, null)).intValue();
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 public final String toString()
  throws 
 {
  try
  {
   return (String)this.h.invoke(this, m2, null);
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 static
 {
  try
  {
   m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
   m3 = Class.forName("HoseeDynamic").getMethod("sayhi", new Class[0]);
   m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
   m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
   return;
  }
  catch (NoSuchMethodException localNoSuchMethodException)
  {
   throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
  }
  catch (ClassNotFoundException localClassNotFoundException)
  {
   throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
 }
}

动态代理类不仅代理了显示定义的接口中的方法,而且还代理了java的根类Object中的继承而来的equals()、hashcode()、toString()这三个方法,并且仅此三个方法。

可以在上述代码中看到,无论调用哪个方法,都会调用到InvocationHandler的invoke方法,只是参数不同。

2.3 动态代理与静态代理的区别

Proxy类的代码被固定下来,不会因为业务的逐渐庞大而庞大;

可以实现AOP编程,这是静态代理无法实现的;

解耦,如果用在web业务下,可以实现数据层和业务层的分离。

动态代理的优势就是实现无侵入式的代码扩展。 静态代理这个模式本身有个大问题,如果类方法数量越来越多的时候,代理类的代码量是十分庞大的。所以引入动态代理来解决此类问题

3. CGLIB

cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

class CGlibHosee
{
  public String sayhi()
  {
    return "Welcome oschina hosee's blog";
  }
}

class CGlibHoseeProxy
{
  Object obj;

  public Object bind(final Object target)
  {
    this.obj = target;
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(obj.getClass());
    enhancer.setCallback(new MethodInterceptor()
    {
      @Override
      public Object intercept(Object obj, Method method, Object[] args,
          MethodProxy proxy) throws Throwable
      {
        System.out.println("I'm proxy!");
        Object res = method.invoke(target, args);
        return res;
      }
    });
    return enhancer.create();
  }

}

public class CGlibProxy
{
  public static void main(String[] args)
  {
    CGlibHosee cGlibHosee = new CGlibHosee();
    CGlibHoseeProxy cGlibHoseeProxy = new CGlibHoseeProxy();
    CGlibHosee proxy = (CGlibHosee) cGlibHoseeProxy.bind(cGlibHosee);
    System.out.println(proxy.sayhi());
  }
}

cglib需要指定父类和回调方法。当然cglib也可以与Java动态代理一样面向接口,因为本质是继承。

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

 类似资料:
  • 本文向大家介绍spring cglib 与 jdk 动态代理,包括了spring cglib 与 jdk 动态代理的使用技巧和注意事项,需要的朋友参考一下 1. 概述 JDK动态代理是利用java反射机制 生成一个实现接口的匿名类, 在调用具体方法前调用InvocationHandler来处理 Cglib动态代理是 利用asm开源包 把被代理类的class文件加载进来 通过修改其字节码生成子类来处

  • 本文向大家介绍Java JDK动态代理的基本原理详细介绍,包括了Java JDK动态代理的基本原理详细介绍的使用技巧和注意事项,需要的朋友参考一下 JDK动态代理详解 本文主要介绍JDK动态代理的基本原理,让大家更深刻的理解JDK Proxy,知其然知其所以然。明白JDK动态代理真正的原理及其生成的过程,我们以后写JDK Proxy可以不用去查demo,就可以徒手写个完美的Proxy。下面首先来个

  • 本文向大家介绍详细分析java 动态代理,包括了详细分析java 动态代理的使用技巧和注意事项,需要的朋友参考一下  1、动态代理的特点:       字节码随用随创建,随用随加载 2、作用:       不修改源码的基础上对源码进行加强 3、分类: (1)基于接口的动态代理:         涉及到的类:Proxy,由JDK官方提供,使用Proxy类中的newProxyInstance方法创建对

  • 我的问题与“代理内部的自我调用问题”有关,但不是我的问题。(我已经找到了该问题的一些解决方案,例如这里所描述的)。我还找到了为什么会发生这种情况的基本解释,这里 1)根据我现在对代码外观的描述,您会怎么做来避免从上下文中获取bean?我不想将每个服务分成两个类,以避免自调用问题。我想要一种方法来使aspectJ和预授权工作如所描述的那样。2)我不明白为什么CGLIB以它的方式实现代理。所以假设我有

  • 本文向大家介绍浅谈Java代理(jdk静态代理、动态代理和cglib动态代理),包括了浅谈Java代理(jdk静态代理、动态代理和cglib动态代理)的使用技巧和注意事项,需要的朋友参考一下 一、代理是Java常用的设计模式,代理类通过调用被代理类的相关方法,并对相关方法进行增强。加入一些非业务性代码,比如事务、日志、报警发邮件等操作。 二、jdk静态代理 1、业务接口 2、业务实现类 3、代理类

  • 本文向大家介绍详解Java JDK动态代理,包括了详解Java JDK动态代理的使用技巧和注意事项,需要的朋友参考一下   今天来看看Java的另一种代理方式——JDK动态代理   我们之前所介绍的代理方式叫静态代理,也就是静态的生成代理对象,而动态代理则是在运行时创建代理对象。动态代理有更强大的拦截请求功能,因为可以获得类的运行时信息,可以根据运行时信息来获得更为强大的执(骚)行(操)力(作)。