动态代理

最新推荐文章于 2022-10-03 20:02:01 发布
最新推荐文章于 2022-10-03 20:02:01 发布
阅读量93 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/chenbkit/blog/1942206
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

动态代理

JDK原生动态代理

jdk动态只能代理接口，所以我们只能代理实现了接口的类或者接口

public interface ProxyInterface throws SQLException {
    String proxyTest(String s);
}
public class ProxyInterfaceImpl implements ProxyInterface {
    @Override
    public String proxyTest(String s) throws SQLException {
        System.out.println(s);
        return s+"  Hello world";
    }
}

定义一个实现InvocationHandler接口的类

方法调用会被转发到该类的invoke()方法中，你可以在该方法中增加处理逻辑


public class TestInvocationHandler implements InvocationHandler {

    private  Object proxyObject;

    public TestInvocationHandler(Object proxyObject) {
        this.proxyObject = proxyObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before method");
        Object o= null;
        try {
            o = method.invoke(proxyObject,args);
        }  catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
        System.out.println("after method");
        return o;
    }
}

利用Proxy生成代理类


public class JdkProxyInstance {

    /**
     * 
     * @param proxyObject 被代理类
     * @param proxyInterface  代理接口
     * @return
     */
    public static   Object instance(Object proxyObject,Class ... proxyInterface){
       return Proxy.newProxyInstance(JdkProxyInstance.class.getClassLoader(),proxyInterface,new TestInvocationHandler(proxyObject));
    }
}


public class ProxyTest {

    @Test
    public void jdkProxyTest(){
        ProxyInterface proxyInterface=new ProxyInterfaceImpl();

        proxyInterface= (ProxyInterface)JdkProxyInstance.instance(proxyInterface,ProxyInterface.class);

        String result=proxyInterface.proxyTest("chenbk");

        System.out.println(result);

    }

}

生成代理类的方法
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler handler)

loader 指定代理类的类加载器
interfaces 代理对象需要实现的接口数组
handler 方法调用的实际处理者，代理对象的方法调用都会转发到这里

我们可以在handler的invoke方法中加入代码逻辑，例如日志打印、安全检查等

对于从Object中继承的方法，JDK Proxy会把hashCode()、equals()、toString()这三个非接口方法转发给InvocationHandler，其余的Object方法则不会转发。

查看JDK代理生成的Java类

jdk代理在运行时生成字节码，我们可以在将生成的字节码保存到文件中，然后利用反编译工具查看Java代码


public class ProxyGeneratorUtil {


    public static void writeJdkProxyClassFile(String path,Class ... clazzs)throws IOException{
        byte[] classFile=ProxyGenerator.generateProxyClass("ProxyTest",clazzs);
        Files.write(Paths.get(path),classFile);

    }
    
    @Test
    public  void createJdkProxyClass(){
        try {
          ProxyGeneratorUtil.writeJdkProxyClassFile("D:\\test\\ProxyTest.class",ProxyInterface.class);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

生成的类大概就是这个样子

import com.chenbk.utils.proxy.ProxyInterface;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class ProxyTest extends Proxy
  implements ProxyInterface
{
  private static Method m1;
  private static Method m3;
  private static Method m2;
  private static Method m0;

  public ProxyTest(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  
  public final String proxyTest(String paramString)
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m3, new Object[] { paramString });
    }
    catch (Error|SQLException|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

 // 省略了equal()、toString()、hashCode() 方法

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

public class Proxy implements java.io.Serializable {

    private static final long serialVersionUID = -2222568056686623797L;

    /** ***省略代码 */
  
    /**
     * the invocation handler for this proxy instance.
     * @serial
     */
    protected InvocationHandler h;

    /**
     * Constructs a new {@code Proxy} instance from a subclass
     * (typically, a dynamic proxy class) with the specified value
     * for its invocation handler.
     *
     * @param  h the invocation handler for this proxy instance
     *
     * @throws NullPointerException if the given invocation handler, {@code h},
     *         is {@code null}.
     */
    protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }
    /** ***省略代码 */
}

我们可以看到生成的类继承了Proxy,实现了我们我们需要代理的接口，实际上JDK代理只是生成了一个实现我们指定接口的类，该类的构造方法，需要传入一个InvocationHandler，初始化父类的h实例变量,在proxyTest方法中会将调用转发到h的invoke()方法中，由于Java只支持单继承，所以Jdk代理只能代理接口,

异常抛出处理

通过上面的程序，我们已经知道，方法会被转发到InvocationHandler的invoke()方法中，如果在调用invoke()方法中抛出了受检查的的异常，并且这个受检查的异常没有在方法中声明，就会被UndeclaredThrowableException包装并抛出

	try
    {
      return (String)this.h.invoke(this, m3, new Object[] { paramString });
    }
    catch (Error|SQLException|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }

然后在invoke()方法中，我们是利用反射去调用方法，当方法抛出异常时，会被反射包装成InvocationTargetException在抛出，这样当代理类处理时，会发现异常不会是，方法声明的异常，然后在被UndeclaredThrowableException包装

		try {
            o = method.invoke(proxyObject,args);
        }  catch (InvocationTargetException e) {
            throw e.getTargetException();
        }

我们可以将InvocationTargetException异常捕获，然后抛出真的异常

CGLIB动态代理

CGLIB是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承方式实现代理。

定义一个实现了MethodInterceptor接口的类，方法会被转发到该类的intercept()方法


public class TestMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("beford method");
        Object object=methodProxy.invokeSuper(o,objects);
        System.out.println("after method");
        return object;
    }
}

生成代理对象

public class CglibProxyInstance {

    public static Object instance(Class clazz){
        Enhancer enhancer=new Enhancer();
        enhancer.setCallback(new TestMethodInterceptor());
        enhancer.setSuperclass(clazz);
        return enhancer.create();
    }
}


public class ProxyTest {

    @Test
    public void cglibProxyTest(){
        ProxyInterfaceImpl proxyInterface  =(ProxyInterfaceImpl)CglibProxyInstance.instance(ProxyInterfaceImpl.class);
        String result=proxyInterface.proxyTest("chenbk");
        System.out.println(result);
    }

}

对代理对象进行方法调用都会转发到TestMethodInterceptor的intercept()方法，我们可以在intercept()方法中写代码逻辑

对于从Object中继承的方法，CGLIB代理也会进行代理，如hashCode()、equals()、toString()等，但是getClass()、wait()等方法不会，因为它是final方法，CGLIB无法代理。final类型不能有子类，所以CGLIB也不能代理final类型。

查看生成的Java类代码


public static final String DEBUG_LOCATION_PROPERTY = "cglib.debugLocation";

public class ProxyGeneratorUtil {

    public static void writeCglibProxyClassFile(String path,Class  clazz){
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, path);
        CglibProxyInstance.instance(clazz);
    }

    @Test
    public  void createCglibProxyClass(){
        ProxyGeneratorUtil.writeCglibProxyClassFile("D:\\test\\ProxyTest1",ProxyInterfaceImpl.class);
    }
}

设置系统变量cglib.debugLocation,指定生成的字节码要保存的文件目录，当生成代理对象时会自动将字节码保存到指定的目录


package com.chenbk.utils.proxy;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyInterfaceImpl$$EnhancerByCGLIB$$296efbd extends ProxyInterfaceImpl
  implements Factory
{
  private boolean CGLIB$BOUND;
  private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
  private static final Callback[] CGLIB$STATIC_CALLBACKS;
  private MethodInterceptor CGLIB$CALLBACK_0;
  private static final Method CGLIB$proxyTest$0$Method;
  private static final MethodProxy CGLIB$proxyTest$0$Proxy;
  private static final Object[] CGLIB$emptyArgs;
  private static final Method CGLIB$finalize$1$Method;
  private static final MethodProxy CGLIB$finalize$1$Proxy;
  private static final Method CGLIB$equals$2$Method;
  private static final MethodProxy CGLIB$equals$2$Proxy;
  private static final Method CGLIB$toString$3$Method;
  private static final MethodProxy CGLIB$toString$3$Proxy;
  private static final Method CGLIB$hashCode$4$Method;
  private static final MethodProxy CGLIB$hashCode$4$Proxy;
  private static final Method CGLIB$clone$5$Method;
  private static final MethodProxy CGLIB$clone$5$Proxy;
	/** ***省略代码 */
	
  final String CGLIB$proxyTest$0(String paramString)
  {
    return super.proxyTest(paramString);
  }

  public final String proxyTest(String paramString)
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
    if (tmp17_14 != null)
      return (String)tmp17_14.intercept(this, CGLIB$proxyTest$0$Method, new Object[] { paramString }, CGLIB$proxyTest$0$Proxy);
    return super.proxyTest(paramString);
  }
	/** ***省略代码 */
  static
  {
    CGLIB$STATICHOOK1();
  }
}

可以看到，当代理对象的方法调用时，会将调用先转发到MethodInterceptor的intercept()方法中

转载于:https://my.oschina.net/chenbkit/blog/1942206

weixin_33919950
关注
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
Java动态代理的异常处理问题
12-22
在使用Java动态代理时出现了一个很棘手的问题，实现类里抛出了一个自定义异常，但外面捕获不到。 　　虽然使用 printStack 可以输出调试信息，但通过 getMessage 获取不到提示，因为项目需求是捕捉到同一种自定义异常的不同异常情况，通过 getMessage 获取异常提示反馈给用户，但因为使用了动态代理所以出现了异常捕获不到的情况。 　　具体原因是因为我们通过动态代理终捕获到的异常时经过加工了的，也是捕获的已不再是开始我们希望抛出的异常，加工抛出的异常有两种： 　　java.lang.reflect.UndeclaredThrowableException 　　java.
Dynamic Proxy的异常处理
解惑
08-11 288
现在越来越感觉Dynamic Proxy是个好东西，不过发现异常处理还是得注意下，因为调用实际的代码返回的异常都会被包一次成为InvocationTargetException，所以如果你想让原本的异常继续往上抛，那么必须捕获异常并且得到targetException然后再抛出去：         try {             result = targetMethod.invoke(t...
秒懂 Java 的三种代理模式
weixin_57907028的博客
07-30 284
前言 代理(Proxy)模式是一种结构型设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。 这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。 这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需要修改，可以通过代理的方式来扩展该方法。 代理模式大致有三种角色： Real Subject：真实类，也就是被代理类、委托类。用来真正完成业务服务功能； Proxy：代理类，将自身的请求用 Real Subject 对应
Spring之AOP底层源码解析
c243311364的博客
04-20 242
前奏：cglib的反向代理 public static void main(String[] args) { UserService target = new UserService(); Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(UserService.class); enhancer.setCallbacks(new Callback[]{new MethodInterceptor() { @Ove
Cglib源码分析 invoke和invokeSuper的差别
z69183787的专栏
06-20 1186
Cglib的实例 本文重在源码的分析，Cglib的使用不再复述。 //被代理类 public class InfoDemo { public void welcome (String person){ System.out.println("welcome :" + person); } } public class CglibInfoProxy implements MethodInterceptor { private Object target; ...
qt qtableview动态代理
09-14
然而，QTableView的功能可以进一步增强，通过实现动态代理（Dynamic Proxy）来扩展其交互性。动态代理允许我们在表格的单元格内嵌入其他UI元素，比如QSpinBox、QCheckBox或QComboBox，从而提供更丰富的用户交互体验...
java + 动态代理 + 动态代理实际应用场景
04-28
1：静态代理出现的实际背景，静态代理时如何演化成动态代理 2： 动态代理demo 举例实际应用场景（载入数据库驱动的时候，使用AIDL与系统Servic进行通信） 3: 动态代理使用到基础理论：ClassLoader 加载.class字节码...
Spring CGLlB动态代理实现过程解析
08-25
"Spring CGLlB动态代理实现过程解析" Spring CGLIB动态代理是Spring框架中的一种动态代理机制，它通过CGLIB（Code Generation Library）生成代理类来实现动态代理。CGLIB是一个高性能的开源代码生成包，能够在运行...
设计模式之代理模式—动态代理（重点是cglib的两大注意事项）
qq_36608921的博客
09-03 423
这些什么设计模式啊，什么这样那样的原理啊，网上真的一大堆，我都在怀疑我为什么要写这些文章，明明别人写得更好，这一篇文章点进来了的朋友们请移步：https://cloud.tencent.com/developer/article/1461796，我实在不想写了，一个月总有那么几天心情不好，蛋疼。 这里还是重点说两个东西吧，对于使用cglib方式时，要注意以下两个方面（当然无法代理final类就...
cglib动态代理
热门推荐
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
Spring进阶（十）之动态代理详解
weixin_56644618的博客
10-03 1091
jdk动态和cglib动态代理（重点）！！！
CGLIB动态代理之intercept函数刨析
qq_41854763的博客
12-12 3787
网上搜CGLIB动态代理，几乎所有的博文都只给了示例代码而缺少对代码的解释说明（特别是关键的intercept函数），看完实在是云里雾里。所以，这篇博文将带你从源码的角度来理解intercept函数。 前言 关于如何使用CGLIB创建动态代理，网上已经有很多资料，这里就不再赘述。本文将使用如下代码进行分析，如果你还看不懂下面的代码，请先自行搜索资料看懂后再继续后面的内容。 import net.sf.cglib.core.DebuggingClassWriter; import net.sf.cglib.
CGLib动态代理的介绍及用法（单回调、多回调、不处理、固定值、懒加载）
Difffate的技术随笔
04-24 7696
前面介绍了代理模式，讲了动态代理常见的实现方式，包含了JDK的动态代理和CGLib的动态代理。本文将介绍下CGLib动态代理及几种用法。CGLib（Code Generation Library）是一个高效的代码生成库，底层实现是使用asm来转换字节码生成类。在生成代理类的场景中，由于JDK动态代理必须要求源对象有实现接口，而实际场景中，并不是所有类都有实现接口，因此使用CGLib可以用在未实
基础篇：深入解析JAVA反射机制
潜行前行的专栏
09-27 2871
JAVA反射机制,JDK动态代理。Class\Constructor\Method\Field
Spring学习笔记:使用代理实现AOP
渐入佳境Coder
10-08 230
AOP基础知识Spring AOP 即 Aspect-oriented programming，面向切面编程，是作为面向对象编程的一种补充，专门用于处理系统中分布于各个模块（不同方法）中的交叉关注点的问题。简单地说，就是一个拦截器（ interceptor ）拦截一些处理过程。例如，当一 个method 被执行，Spring AOP 能够劫持正在运行的 method ，在 method 执行前或者后
Spring框架复习10-AOP（番外）cglib动态代理
05-08 115
第一步：编写原始类（这里不需要实现接口，cglib的原理是通过继承实现的） public class GoodDao { public void save(){ System.out.println("保存商品"); } } 第二步：编写动态代理类 public class CglibProxy { public GoodDao createP...
cglib原理解析
03-29 2361
先放上示例代码： //Person.java public class Person { public void sayHello() { System.out.println("Hello!"); } } //Test.java import org.objectweb.asm.ClassWriter; import net.sf.cglib.proxy....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值