java动态代理之jdk动态代理详解

最新推荐文章于 2024-06-28 19:51:08 发布
最新推荐文章于 2024-06-28 19:51:08 发布
阅读量622 收藏 2
点赞数 4
分类专栏： spring 文章标签： java 代理模式 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36109477/article/details/122017941
版权

java动态代理概念

Java静态代理中代理类的.class文件在程序运行期间已存在，并且目标类和代理类都需要实现同一个接口，每个目标类的增强都需要有一个对应的代理类，代码的复用性低。

Java动态代理需要解决的就是这个痛点，通过反射的方式动态创建目标类的代理类来实现功能的增强。动态代理将目标类和增强类分开，实现了解耦，提高了代码复用性，也不需要创建目标类对应的代理类，而是根据不同的实现方式动态地生成其代理类。

Java动态代理有两种：jdk动态代理和cglib动态代理。
篇幅有限，下文先介绍jdk动态代理。

jdk动态代理

jdk动态代理必须实现接口。

需要动态代理的接口

package com.teasir.spring.proxyjdk;

/*
* 目标接口
* */
public interface PersonService {
    public void save();
}

需要代理的目标实现类

package com.teasir.spring.proxyjdk;

public class PersonServiceImpl implements PersonService {
    @Override
    public void save() {
        System.out.println("save some information");
    }

}

增强类

package com.teasir.spring.proxyjdk;

/**
 * 增强类：为方法开启事务
 * */
public class MyTransaction {
    public void begin() {
        System.out.println("开启事务");
    }

    public void commit() {
        System.out.println("提交事务");
    }
}

创建一个实现InvocationHandler接口的类，实现invoke方法，调用增强类方法实现对目标类方法的增强。

每次生成动态代理实现类都需要实现一个处理器接口。

package com.teasir.spring.proxyjdk;

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

public class PersonServiceInterceptor implements InvocationHandler {
    //目标类
    private Object target;
    //增强类
    private MyTransaction myTransaction;


    //构造器注入目标类和增强类
    public PersonServiceInterceptor(Object target, MyTransaction myTransaction) {
        this.target = target;
        this.myTransaction = myTransaction;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.myTransaction.begin();
        Object retObj = method.invoke(this.target, args);
        this.myTransaction.commit();
        return retObj;
    }
}

通过Proxy的静态方法newProxyInstance创建一个动态代理实例。

package com.teasir.spring.proxyjdk;

import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {
        //目标类
        Object object=new PersonServiceImpl();
        //增强类
        MyTransaction myTransaction=new MyTransaction();
        //生成动态代理对象
        PersonServiceInterceptor interceptor=new PersonServiceInterceptor(object,myTransaction);
        PersonService personService= (PersonService) Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),interceptor);
        personService.save();
    }
   
   
}

测试结果

开启事务
save some information
提交事务

jdk动态代理的实现过程

为什么调用动态代理类personService的save()最后会调用PersonServiceInterceptor的invoke()方法呢？

查看源码可以看到起关键作用的位置是动态生成的字节码文件：

//生成字节码

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

生成字节码代码改造如下：

package com.teasir.spring.proxyjdk;

        import sun.misc.ProxyGenerator;
        import javax.security.auth.Subject;
        import java.io.File;
        import java.io.FileNotFoundException;
        import java.io.FileOutputStream;
        import java.io.IOException;
        import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {
        //目标类
        Object object=new PersonServiceImpl();
        //增强类
        MyTransaction myTransaction=new MyTransaction();
        //生成动态代理对象
        PersonServiceInterceptor interceptor=new PersonServiceInterceptor(object,myTransaction);
        PersonService personService= (PersonService) Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),interceptor);
        personService.save();
        // 将生成的字节码保存到本地，
        createProxyClassFile();
    }

    private static void createProxyClassFile() {
        String name = "ProxySubject";
        byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{PersonService.class});
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(name + ".class");
            System.out.println((new File("hello")).getAbsolutePath());
            out.write(data);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != out) try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


}

定义方法生成字节码文件并通过反编译查看动态代理生成的字节码文件，可以看出最后生成的动态代理实例继承Proxy并且实现了PersonService

接口，当该实例调用save方法时，最后会调用PersonServiceInterceptor的invoke()方法。

反编译代码

import com.teasir.spring.proxyjdk.PersonService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class ProxySubject extends Proxy
  implements PersonService
{
  private static Method m1;
  private static Method m3;
  private static Method m2;
  private static Method m0;

  public ProxySubject(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 void save()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    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);
    }
  }

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

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("com.teasir.spring.proxyjdk.PersonService").getMethod("save", new Class[0]);
      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());
    }
  }
}

jdk动态代理实现过程总结

1、定义目标类接口、定义增强类（比如事务类）；

2、定义目标类实现目标类接口，定义一个自定义处理器类实现InvocationHandler接口并实现invoke方法；

3、通过Proxy.newProxyInstance(类加载器,类的接口,自定义处理器)来创建动态代理实例;

创建动态代理实例原理：通过反射生成对应的.class字节码文件来创建动态代理实例。

4、动态代理实例调用目标类的方法，从生成的字节码反编译可以看出，每次调用目标类的方法时同时会调用InvocationHandler接口并实现invoke方法从而完成方法功能的增强。

反编译工具下载：

链接: https://pan.baidu.com/s/1y2syXFmn44u9axKvOiQx1w
提取码: r2m9

相关文章

Java静态代理详解
Java反射机制详解
spring动态代理之cglib动态代理
参考文章

https://caoju.blog.csdn.net/article/details/90714295

https://blog.csdn.net/litianxiang_kaola/article/details/85335700

https://blog.csdn.net/jiankunking/article/details/52143504

https://blog.csdn.net/laijunfeng816/article/details/79241925

tea-Sir
关注
专栏目录
【java】JDK动态代理
九师兄
01-14 655
JDK动态代理所用到的在程序调用到时才由JVM真正创建，。我们需要做的，。JDK的动态代理需要实现接口，并重写方法。并且被代理的类必须有接口，来看具体的例子： 2.2 自定义InvocationHandler 2.3 测试类 3.JDK动态代理原理分析 在类中，通过实现并重写方法，实现了对类的动态代理。但是这里大家一定会有一个疑问，在测试类中通过获取了代理类的实例，但是当调用方法时，却会调用的方法，要解开这个谜题，就需要了解一下代理类是如何生成、生成的代理类是什么样子的、是如何被实例化的。打开MyInv
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
热门推荐
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
JDK动态代理详解
weixin_34362790的博客
12-23 119
2019独角兽企业重金招聘Python工程师标准>>> ...
Java JDK动态代理
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
09-25 1195
本篇文章主要讲解的是什么是JAVA JDK版本的动态代理，如何使用JAVA JDK版本的动态代理。对于JAVA JDK版本的动态代理的原理不会过多的描述。本篇文章旨在如果使用JDK动态代理。例如：由于客户端不想活着不能直接访问一个对象，此时可以通过一个称为代理的第三者来实现简介访问对象，这个过程为一个代理。更加生活化的实例是：例如：代购，如：在当地买不到某件商品，又或者因为当地的这件商品的价格比其他地区的贵，所以托人或者机构在其他地区购买该商品，并携带回来。/**
（Java笔记）JDK动态代理
张松的博客
06-14 831
动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的.java源文件——>jdk运行期间动态创建class字节码并加载JVM——>代理对象在程序运行的过程中动态在内存构建，可以灵活的进行业务功能的切换。......
Java——JDK动态代理
m0_73671382的博客
04-03 7433
动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的，java源文件。动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。动态代理的实现方式常用的有两种：使用JDK代理，与通过CGLlB动态代理。
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
Java 动态代理详解（学习资料）
06-17
JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象，而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...
深入理解动态代理：JDK动态代理与CGLIB动态代理
最新发布
qq_40254606的博客
06-28 950
动态代理是一种在运行时创建代理对象的技术，通过代理对象来控制对原对象的访问，能够在不修改原对象的情况下添加额外的功能。JDK动态代理：基于Java反射机制，只能代理实现了接口的类。CGLIB动态代理：基于字节码生成技术，可以代理没有实现接口的类。// 抽象主题接口动态代理在Java中提供了一种灵活而强大的机制，能够在运行时为目标对象添加额外的功能。JDK动态代理和CGLIB动态代理各有优势和适用场景，开发者可以根据具体需求选择合适的代理机制。希望这篇文章对你理解动态代理有所帮助。
Java静态代理，jdk动态代理，cglib动态代理的区别
weixin_32629733的博客
11-28 336
Java静态代理和动态代理 1.代理模式 给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问。代理模式是一种结构型设计模式。 代理模式角色分为 3 种： 抽象角色：一般是一个接口或者抽象类，定义了一些公共方法； 真实角色：真正实现业务逻辑的类，也是被代理的角色； 代理角色：用来代理和封装真实主题 真实角色和代理角色必须实现同一个抽象角色的接口。 2.静态代理 所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和真实主题角色的关系在运行前就确定了。 2.1 lol代练解释静态代理 以一个
java的jdk动态代理
qq_41551345的博客
02-29 146
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException loader:　　 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象...
JDK动态代理：不仅要学会用，更要掌握其原理
人生就是一个不断学习的过程
03-01 1910
微信搜索：码农StayUp 主页地址：https://gozhuyinglong.github.io 源码分享：https://github.com/gozhuyinglong/blog-demos JDK动态代理是指：代理类实例在程序运行时，由JVM根据反射机制动态的生成。也就是说代理类不是用户自己定义的，而是由JVM生成的。 由于其原理是通过Java反射机制实现的，所以在学习前，要对反射机制有一定的了解。传送门：Java反射机制：跟着代码学反射 下面是本篇讲述内容： 1. JDK动态代理的核心类..
Java-JDK动态代理
zhxingqi的博客
10-19 6096
介绍:我们需要掌握的程度动态代理(理解) 基于反射机制掌握的程度:1.什么是动态代理?2.动态代理能够做什么?后面我们在用Spirng和Mybatis的时候,要理解怎么使用的.代理,在我们日常生活之中就有体现,代购,中介,换ip,商家等等.比如有一家美国的大学,可以对全世界招生.留学中介(代理 )留学中介(代理):帮助这家美国的学校招生,中介是学校的代理中介是代替学校完成招生功能代理特点中介和代理他们要做的事情是一致的:招生中介是学校代理,学校是目标。
java jdk的动态代理
李习的博客
02-18 515
把被代理对象塞到InvocationHandler中 代理类访问接口，转到InvocationHandler的invoke方法 InvocationHandler的invoke方法对方法进行加强，并调用被代理对象的方法。 package com.tom.tom.proxy; public interface SmsService { String send(String message); } package com.tom.tom.proxy.impl; import com.tom.to
java-jdk动态代理
HAHA
11-24 232
JDK 动态代理 基于接口的代理，基于java.lang.reflect.Proxy 接口 public interface ILoginService { void login(String userName,String password); } 实现类 public class LoginService implements ILoginService { @Overrid...
java JDK动态代理
weixin_69420643的博客
03-30 155
动态代理是一种编程技术，它允许在运行时创建一个实现了给定接口的代理对象。代理对象可以拦截方法调用并在调用前后执行额外的逻辑，比如记录日志、验证参数等等。动态代理通常使用反射机制来实现，因此不需要手动编写大量的代理类。动态代理是基于Java反射机制实现的。在Java中，所有的类都有一个Class对象，我们可以通过这个对象获取类的信息，比如类名、方法名、构造函数等等。在动态代理中，我们通过反射机制来创建代理对象，并拦截方法调用。
Java动态代理详解：JDK与Cglib实现
JDK动态代理是通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口实现的。代理类在运行时动态生成，无需预先编写源代码。创建动态代理的基本步骤如下： 1. 创建一个实现`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值