JDK动态代理实现原理

最新推荐文章于 2024-07-23 21:45:09 发布
最新推荐文章于 2024-07-23 21:45:09 发布
阅读量140 收藏 4
点赞数 9
文章标签： java 代理模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjStudyJava/article/details/140460816
版权

  1. 静态代理模式我们不能满足开闭原则，其中的重复代码较多，且修改更新维护很不方便，我们想着能否不需要代理类直接生成代理对象，这样就可以解决一些静态代理的缺点

  2. 我们通过一个业务类和一个业务实现类来举例子代码如下:

    /**
 * 业务类
 *
 * @author Young Jun
 * @creat 2024-06-25-16:28
 */
public interface IService {
    String eat();

    String sleep();
}

    /**
 * @author Young Jun
 * @creat 2024-06-25-16:29
 * 业务实现类
 */
public class IServiceImpl implements IService {
    @Override
    public String eat() {
        return "吃他个三大碗米饭";
    }

    @Override
    public String sleep() {
        return "睡他个自然醒";
    }
}

  3. 我们现在想要动态的生成一个IServiceImpl的代理对象步骤如下:

    @Test
    public void test1() throws Exception /*这里异常我直接抛出了*/ {
        //目标对象
        IService service = new IServiceImpl();
        //通过getProxyClass()方法获取一个有IService.class信息且拥有构造器的Class类也就是代理对象的Class
        Class<?> proxyClass = Proxy.getProxyClass(service.getClass().getClassLoader(), service.getClass().getInterfaces());
        //通过代理对象的Class实例化通过构造器实例化(通过源码我们可以看到有一个有参构造器，其中的参数就是InvocationHandler)
        Constructor<?> constructor = proxyClass.getDeclaredConstructor(InvocationHandler.class);
        constructor.setAccessible(true);
        //传入参数(当然,可以用lambda表达式)(我们知道是IService所以可以强转)
        IService proxy =(IService) constructor.newInstance(new InvocationHandler() {
            //proxy代理对象
            //method代理方法
            //args 方法参数
            //这个方法就是用来给我做事的(它会拦截到代理对象执行方法，使其进入这个方法内)
            //这里面可以进行我们对目标方法的增强等一系列处理
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //比如我这里执行日志增强
                System.out.println("日志前置增强");
                //调用目标类的方法,这里就是反射的基础
                // (其中需要两个参数，一个是目标类对象,另一个是方法参数，上面有了所以直接用)
                Object result = method.invoke(service, args);
                System.out.println("日志后置增强");
                //返回方法执行结果
                return result;
            }
        });
        System.out.println(proxy.eat());
        System.out.println(proxy.sleep());
    }
//虽然解决了不需要代理类的问题，但是前置操作还是稍微烦锁了,且只能对一种接口的实现类进行加强
//接下来我们就需要改进一下代码

  4. 创建一个ProxyUtil工具类简化代码

    public class ProxyUtil {

    /**
     *
     * @param target 目标类(为了避免局限性我们直接将其类设为Object)
     * @return 返回代理对象
     */
    public static Object getProxy(Object target) throws Exception {
        //通过getProxyClass()方法获取一个有IService.class信息且拥有构造器的Class类也就是代理对象的Class
        Class<?> proxyClass = Proxy.getProxyClass(target.getClass().getClassLoader(), target.getClass().getInterfaces());
        //通过代理对象的Class实例化通过构造器实例化(通过源码我们可以看到有一个有参构造器，其中的参数就是InvocationHandler)
        Constructor<?> constructor = proxyClass.getDeclaredConstructor(InvocationHandler.class);
        constructor.setAccessible(true);
        //传入参数(当然,可以用lambda表达式)
        Object proxy = constructor.newInstance(new InvocationHandler() {
            //proxy代理对象
            //method代理方法
            //args 方法参数
            //这个方法就是用来给我做事的(它会拦截到代理对象执行方法，使其进入这个方法内)
            //这里面可以进行我们对目标方法的增强等一系列处理
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //比如我这里执行日志增强
                System.out.println("日志前置增强");
                //调用目标类的方法,这里就是反射的基础
                // (其中需要两个参数，一个是目标类对象,另一个是方法参数，上面有了所以直接用)
                Object result = method.invoke(target, args);
                System.out.println("日志后置增强");
                //返回方法执行结果
                return result;
            }
        });
        return proxy;
    }
}



//测试代码
@Test
    public void test2() throws Exception /*这里异常我直接抛出了*/ {
        //目标对象
        IService service = new IServiceImpl();
        //通过getProxyClass()方法获取一个有IService.class信息且拥有构造器的Class类也就是代理对象的Class
        IService proxy =(IService) ProxyUtil.getProxy(service);
        
        System.out.println(proxy.eat());
        System.out.println(proxy.sleep());
    }
//虽然解决了前置操作烦锁且不单单只能对一种接口的实现类进行加强,但是增强方法却只有一种，不符合实际，我可能有很多种增强的逻辑
//接下来我们就需要再改进一下代码

  5. 改进一下getProxy()方法，我们自己定义InvocationHandler接口的实现类对象可以是匿名内部类也可以是自定义类实现InvocationHandler接口并重写invoke()方法

    /**
     *
     * @param target 目标类对象
     * @param handler 执行处理器，拦截方法得拦截器
     * @return 返回代理对象
     * @throws Exception
     */
    public static Object getProxy(Object target,InvocationHandler handler) throws Exception {
        //通过getProxyClass()方法获取一个有IService.class信息且拥有构造器的Class类也就是代理对象的Class
        Class<?> proxyClass = Proxy.getProxyClass(target.getClass().getClassLoader(), target.getClass().getInterfaces());
        //通过代理对象的Class实例化通过构造器实例化(通过源码我们可以看到有一个有参构造器，其中的参数就是InvocationHandler)
        Constructor<?> constructor = proxyClass.getDeclaredConstructor(InvocationHandler.class);
        constructor.setAccessible(true);
        //传入参数
        Object proxy = constructor.newInstance(handler);
        return proxy;
    }

//测试代码
@Test
    public void test3() throws Exception /*这里异常我直接抛出了*/ {
        //目标对象
        IService service = new IServiceImpl();
        //通过getProxyClass()方法获取一个有IService.class信息且拥有构造器的Class类也就是代理对象的Class
        IService proxy =(IService) ProxyUtil.getProxy(service, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //记录时间方法增强
                System.out.println("记录开始时间...");
                Object result = method.invoke(service,args);
                System.out.println("记录结束时间时间...");
                return result;
            }
        });

        System.out.println(proxy.eat());
        System.out.println(proxy.sleep());
    }

//这样我们就可以自己自定义增强方法，更加灵活，但是我们感觉到getProxy()方法中的代码还是比较的繁琐，这个时候我们发现Proxy类中有一个静态方法newProxyInstance()

  6. 我们再次改造一下,使用现成的newProxyInstance()方法

    //现成的方法
@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
 //ClassLoader loader类加载器，加载目标类的加载器
 //Class<?>[] interfaces 目标类的接口Class类
 //InvocationHandler h 执行处理器，拦截目标方法
        
 
/**
     *
     * @param target 目标类对象
     * @param handler 执行处理器，拦截方法得拦截器
     * @return 返回代理对象
     * @throws Exception
     */
    public static Object getProxyWithProxyMethod(Object target,InvocationHandler handler) throws Exception {
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
        return proxy;
    }


//测试代码

@Test
    public void test4() throws Exception /*这里异常我直接抛出了*/ {
        //目标对象
        IService service = new IServiceImpl();
        //通过newProxyInstance()方法直接获取代理对象
        IService proxy =(IService) ProxyUtil.getProxyWithProxyMethod(service, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //对象属性增强
                System.out.println("对象属性填充...");
                Object result = method.invoke(service,args);
                return result;
            }
        });

        System.out.println(proxy.eat());
        System.out.println(proxy.sleep());
    }

//经过一系列的改进其实代码已经不错了,但是我们发现增强方法是硬编码，且总是匿名内部类会有重复代码重复代码，这时候又有的改了

  7. 利用面向对象思想讲增强方法封装到增强类中，且自定义一个InvocationHandler实现类

    1. 包结构如下:

  9. 在这里插入图片描述

    /**
 * @author Young Jun
 * @creat 2024-06-25-22:39
 * 事务增强类
 */
public class TransactionAdvice {

    public void before(){
        System.out.println("开启事务...");
    }

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

    /**
 * @author Young Jun
 * @creat 2024-06-25-22:41
 * 事务处理执行器
 */
public class TransactionHandler implements InvocationHandler {
    //事务增强类
    private TransactionAdvice transactionAdvice;
    //目标对象
    private Object target;
	//构造器注入属性
    public TransactionHandler(TransactionAdvice transactionAdvice, Object target) {
        this.transactionAdvice = transactionAdvice;
        this.target = target;
    }
    
	//重写invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //调用增强和目标方法
        transactionAdvice.before();
        Object result = method.invoke(target,args);
        transactionAdvice.after();
        return result;
    }
}

//proxy工具类中的getProxy方法

/**
     *
     * @param target 目标类对象
     * @return 返回代理对象
     * @throws Exception
     */
    public static Object getProxyWithProxyMethodAndMyHandler(Object target) throws Exception {
        //通过构造器设置增强类和目标类
        TransactionHandler transactionHandler = new TransactionHandler(new TransactionAdvice(), target);
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),transactionHandler);
        return proxy;
    }


//测试代码
@Test
    public void test5() throws Exception /*这里异常我直接抛出了*/ {
        @Test
    public void test5() throws Exception /*这里异常我直接抛出了*/ {
        //目标对象
        IService service = new IServiceImpl();
        //通过newProxyInstance()方法直接获取代理对象
        IService proxy = (IService) ProxyUtil.getProxyWithProxyMethodAndMyHandler(service);

        System.out.println(proxy.eat());
        System.out.println(proxy.sleep());
    }
    }
yjStudyJava
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java JDK动态代理实现原理实例解析
08-19
Java JDK动态代理实现原理实例解析 Java JDK动态代理实现原理实例解析是指通过Java JDK提供的代理机制来实现动态代理的原理和实例解析。动态代理是一种非常重要的设计模式，它可以在运行时生成代理类，从而实现了...
模拟JDK动态代理内部实现
04-11
在本文中，我们将深入探讨如何模拟JDK的动态代理内部实现。 首先，我们需要了解JDK动态代理的基础知识。Java中的动态代理通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口实现。`Proxy...
jdk动态代理实现原理
alibh的博客
12-06 1467
jdk动态代理实现原理
jdk动态代理的原理
不才不才不不才的博客
07-05 5851
通俗的讲，在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 携程或者淘宝上买。又比如，找保姆、找工作等都可以通过找58或boss等网站中介完成。在java中代理实现的方式有两种，一种是通过继承的方式，另一种是通过组合的方式去实现。 2.组合模式 组合模式有三个关键点： 三、jdk动态代理实现 四、jdk动态代理实现原理 jdk动
彻底搞懂JDK动态代理
Tan_xiong的博客
04-02 465
本文介绍了JDK动态代理的基本原理、创建步骤及其原理。动态代理提供了在运行时动态改变目标对象行为的能力，广泛应用于AOP编程、远程方法调用和测试框架等领域。虽然性能开销较大，但其简单易用
【深度思考】聊聊JDK动态代理原理
申城异乡人
04-17 922
JDK动态代理原理。
JDK动态代理的底层实现原理
06-19
JDK动态代理的底层实现原理
java-jdk动态代理的实现demo
09-18
Java JDK 动态代理是一种强大的特性，它允许我们在运行时创建代理类，这些代理类可以扩展或修饰已存在的接口实现。动态代理在很多场景下非常有用，比如日志记录、性能监控、事务管理等，这些功能可以在不修改原始...
JDK动态代理源码
11-30
在Java编程领域，JDK动态代理是一个非常重要的概念，它允许我们在...理解并掌握JDK动态代理的原理和用法，能够帮助我们更灵活地设计和实现程序，特别是在需要扩展或增强已有功能时，动态代理提供了一种优雅的解决方案。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1092
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 768
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 740
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1311
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
java算法day19
TOMOT77的博客
07-20 303
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
springboot之自动装配
weixin_50153914的博客
07-23 222
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1190
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 950
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
[Jenkins]jenkins-cli.jar调用用户token启动任务
最新发布
China_Yanhy的博客
07-23 545
jenkins-cli.jar调用用户token启动任务
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值