12AOP-jdk代理实现及特点

于 2024-06-18 11:28:20 发布
阅读量357 收藏 9
点赞数 7
分类专栏： spring 文章标签： java 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48254383/article/details/139768379
版权

模拟 jdk 动态代理

版本1.0
package com.butch.a12;

public class A12 {

    //目标类和代理类都需要实现的公共接口
    interface Foo{
        void foo();
    }

    //目标类
    static class Target implements Foo{
        @Override
        public void foo() {
            System.out.println("target foo");
        }

        public static void main(String[] args) {
            Foo foo = new $Proxy0();
            foo.foo();
        }
    }
}

package com.butch.a12;

//代理类
public class $Proxy0 implements A12.Foo {


    @Override
    public void foo() {
        //增强功能
        System.out.println("========before=========");
        //调用目标
        new A12.Target().foo();

    }
}

可以看到代码将增强的功能和目标方法调用写死到了代理中，可用性很差，版本二将增强和目标方法分离

版本2.0
package com.butch.a12;


public class A12 {

    //目标类和代理类都需要实现的公共接口
    interface Foo{
        void foo();
    }

    //目标类
    static class Target implements Foo {
        @Override
        public void foo() {
            System.out.println("target foo");
        }
    }
    //2.0解耦的关键接口
    interface InvocationHandler{
        void invoke();
    }

    public static void main(String[] args) {
        //2.0这里就必须通过有参构造器实例化invcationhandle,在实现的invoke方法中自定义增强逻辑,注意要使用我们自己定义接口
        Foo proxy = new $Proxy0(new InvocationHandler() {
            @Override
            public void invoke() {
                //增强功能
                System.out.println("========before=========");
                //调用目标
                new A12.Target().foo();

            }
        });
        proxy.foo();
    }
}

 

package com.butch.a12;


//代理类
public class $Proxy0 implements A12.Foo {

    //2.0增加InvocationHandler处理
    private A12.InvocationHandler h;

    //2.0通过有参构造器实例化
    public $Proxy0(A12.InvocationHandler h) {
        this.h = h;
    }


    @Override
    public void foo() {
        //2.0在这里调用 接口的代理方法
        h.invoke();
    }
}

理解一下InvocationHandler

  1. 在代理类中定义成员变量，类型为InvocationHandler，并且提供唯一构造器，参数为InvocationHandler

  2. 当要创建代理类对象的时，就必须通过带有InvocationHandler的构造器实例化，就必须重写接口的invoke

  3. 在invoke实现增强的逻辑，调用目标方法

  4. 当使用代理类对象调用目标方法，就是去执行实例化代理类时InvocationHandler的增强逻辑了

但是此时如果公共接口新增了一个方法，被调用的时候也需要增强，2.0版本明显不能满足需求

版本3.0
package com.butch.a12;


import java.lang.reflect.Method;

//代理类
public class $Proxy0 implements A12.Foo {


    //2.0增加InvocationHandler处理
    private A12.InvocationHandler h;

    //2.0通过有参构造器实例化
    public $Proxy0(A12.InvocationHandler h) {
        this.h = h;
    }


    @Override
    public void foo() {
        //3.0使用反射调用对应的方法，以增强不同的方法
        Method foo = null;
        try {
            foo = A12.Foo.class.getDeclaredMethod("foo");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        //2.0在这里调用 接口的代理方法
        h.invoke(foo,new Object[0]);
    }

    @Override
    public void bar() {
        //3.0使用反射调用对应的方法，以增强不同的方法
        Method bar = null;
        try {
            bar = A12.Foo.class.getDeclaredMethod("bar");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        //3.0增加方法
        h.invoke(bar,new Object[0]);
    }
}

package com.butch.a12;


import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class A12 {

    //目标类和代理类都需要实现的公共接口
    interface Foo{
        void foo();
        //3.0增加方法
        void bar();
    }

    //目标类
    static class Target implements Foo {
        //3.0增加方法
        @Override
        public void bar() {
            System.out.println("target bar");

        }

        @Override
        public void foo() {
            System.out.println("target foo");
        }
    }
    //2.0解耦的关键接口
    interface InvocationHandler{
        void invoke(Method method,Object[] objects);
    }

    public static void main(String[] args) {
        //2.0这里就必须通过有参构造器实例化invcationhandle,在实现的invoke方法中自定义增强逻辑,注意要使用我们自己定义接口
        Foo proxy = new $Proxy0(new InvocationHandler() {
            @Override
            public void invoke(Method method,Object[] Obj) {
                //增强功能
                System.out.println("========before=========");
                //调用目标
                try {
                    method.invoke(new Target(),Obj);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        });
        proxy.foo();
        proxy.bar();
    }
}

3.0使用到反射去调用对应的目标方法，很好的适配了不同方法的增强，4.0将新增返回结果的目标方法及代码的精简

版本4.0

  1. 处理返回参数，并抛出异常

  2. 将反射匹配调用目标方法放入静态代码块中

  3. 在InvocationHandler中 新增参数Object proxy

  4. 使用jdk提供的InvocationHandler替换，并且代理类继承proxy

package com.butch.a12;


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

public class A12 {

    //目标类和代理类都需要实现的公共接口
    interface Foo{
        void foo();
        //3.0增加方法
        //4.0将方法变为有返回值的
        int bar();
    }

    //目标类
    static class Target implements Foo {
        //3.0增加方法
        @Override
        public int bar() {
            System.out.println("target bar");
            return 100;

        }

        @Override
        public void foo() {
            System.out.println("target foo");
        }
    }
    //2.0解耦的关键接口
//    interface InvocationHandler{
//        //4.0解耦的接口新增返回参数
//        Object invoke(Object proxy,Method method,Object[] objects) throws Throwable;
//    }

    public static void main(String[] args) {
        //2.0这里就必须通过有参构造器实例化invcationhandle,在实现的invoke方法中自定义增强逻辑,注意要使用我们自己定义接口
        Foo proxy = new $Proxy0(new InvocationHandler() {
            @Override
            public Object invoke(Object proxy,Method method,Object[] Obj) throws Throwable {
                //增强功能
                System.out.println("========before=========");
                //调用目标
                //返回到代理类中
                return method.invoke(new Target(),Obj);
            }
        });
        proxy.foo();
        proxy.bar();
    }
}

package com.butch.a12;


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

//代理类
public class $Proxy0 extends Proxy implements A12.Foo {


    //2.0增加InvocationHandler处理
    private InvocationHandler h;

    //2.0通过有参构造器实例化
    //4.0
    public $Proxy0(InvocationHandler h) {
        super(h);
    }


    @Override
    public void foo() {
        //3.0使用反射调用对应的方法，以增强不同的方法
//        Method foo = null;
//        try {
//            foo = A12.Foo.class.getDeclaredMethod("foo");
//        } catch (NoSuchMethodException e) {
//            e.printStackTrace();
//        }
//        //2.0在这里调用 接口的代理方法
        try {
            h.invoke(this,foo,new Object[0]);
        } catch (RuntimeException | Error e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    @Override
    public int bar() {
        //3.0使用反射调用对应的方法，以增强不同的方法
//        Method bar = null;
//        try {
//            bar = A12.Foo.class.getDeclaredMethod("bar");
//        } catch (NoSuchMethodException e) {
//            e.printStackTrace();
//        }
        //3.0增加方法
        try {
            Object invoke = h.invoke(this,bar, new Object[0]);
            return (int)invoke;
        } catch (RuntimeException | Error e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    //4.0
    static Method foo;
    static Method bar;
    static {
        try {
            foo = A12.Foo.class.getMethod("foo");
            bar = A12.Foo.class.getMethod("bar");
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }
}
流程

  1. 初始化代理对象，需要通过构造器InvocationHandler，在重写方法中定义增强逻辑，然后根据反射方法参数调用代理方法

  2. 使用代理对象调用增强方法，回调到InvocationHandler的重写方法中，执行增强逻辑，执行代理的增强方法，进入代理类

  3. 通过反射调用，执行目标方法的增强方法

总结

jdk代理实现原理

  1. 方法重写可以增强逻辑，只不过这【增强逻辑】千变万化，不能写死在代理内部

  2. 通过接口回调将【增强逻辑】置于代理类之外

  3. 配合接口方法反射（是多态调用），就可以再联动调用目标方法

  4. 会用 arthas 的 jad 工具反编译代理类

  5. 限制⛔：代理增强是借助多态来实现，因此成员变量、静态方法、final 方法均不能通过代理实现

方法反射优化

package com.butch.a12;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

// 运行时请添加 --add-opens java.base/java.lang.reflect=ALL-UNNAMED --add-opens java.base/jdk.internal.reflect=ALL-UNNAMED
public class TestMethodInvoke {
    public static void main(String[] args) throws Exception {
        Method foo = TestMethodInvoke.class.getMethod("foo", int.class);
        for (int i = 1; i <= 17; i++) {
            show(i, foo);
            foo.invoke(null, i);
        }
        System.in.read();
    }

    // 方法反射调用时, 底层 MethodAccessor 的实现类
    private static void show(int i, Method foo) throws Exception {
        Method getMethodAccessor = Method.class.getDeclaredMethod("getMethodAccessor");
        getMethodAccessor.setAccessible(true);
        Object invoke = getMethodAccessor.invoke(foo);
        if (invoke == null) {
            System.out.println(i + ":" + null);
            return;
        }
        Field delegate = Class.forName("jdk.internal.reflect.DelegatingMethodAccessorImpl").getDeclaredField("delegate");
        delegate.setAccessible(true);
        System.out.println(i + ":" + delegate.get(invoke));
    }

    public static void foo(int i) {
        System.out.println(i + ":" + "foo");
    }
}

  1. 前 16 次反射性能较低

  2. 第 17 次调用会生成代理类，优化为非反射调用

  3. 会用 arthas 的 jad 工具反编译第 17 次调用生成的代理类

李卫公的开平方机
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-JDK动态代理（AOP）使用及实现原理分析
just_learing的博客
04-09 1801
Java-JDK动态代理（AOP）使用及实现原理分析
Spring-AOP-JDK动态代理
05-12
Spring-AOP-利用java中的动态代理和Spring的拦截器做到AOP
AOP-JDK动态代理实现
qq_55673469的博客
01-30 665
1.创建接口，定义方法 public interface UserDao { public int add(int a,int b); } 2.创建接口的实现类，实现方法 public class userdaoimpl implements UserDao{ @Override public int add(int a, int b) { return a+b; } } 3.使用Proxy类创建接口代理对象 public class
Java JDK 动态代理（AOP）使用及实现原理分析
热门推荐
勿忘初心
05-08 16万+
代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息 ​ 一、什么是代理？ 二、Java 动态代理类 三、JDK的动态代理怎么使用？ 四、动态代理怎么实现的？ 五、结论 一、什么是代理？ 代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。 代理模式UML图： 简单结构示意图： 为了保持行为的...
Java Spring-AOP动态代理-JDK和CGlib实现
涂涂写写的笔记
11-18 1357
代理增强的方法和Bean本身的方法当作一个切面，是对面向对象编程OOP的升华。OOP是纵向对一个事物的抽象，一个对象包括静态的属性信息，包括动态的方法信息等。而AOP是横向的对不同事物的抽象，属性与属性、方法与方法、对象与对象都可以组成一个切面，而用这种思维去设计编程的方式叫做。思想，我们会new一个筷子对象，new一个手机对象，然后先调用 chopsticks.pickUp() ，再调用 phone.user()。编码是为了解决生活中的问题，譬如现在我想用筷子吃饭的时候看手机，那么首先会有两个对象。
AOP中JDK动态代理
qq_40834643的博客
09-19 453
在aop中实现动态代理的方式有两种：一种是有接口的情况，使用JDK动态代理，另一种是没有接口的情况，使用CGLIB动态代理。
SpringAOP JDK动态代理
weixin_46281472的博客
07-11 2986
目前我本人正在学习SpringFramework的知识，这也是这个专栏的主题。我前面的几篇博文中，简单的认识了一下SpringFramework，记录了SpringFramework的环境搭建，记录了SpringIOC如何加载配置文件，记录了SpringIOC三种Bean对象的实例化方法。还记录了SpringIOC手动装配（注入）的方法之一：set方法注入。还有另外三个不太常用的SpringIOC手动注入的方法。其实目前大部分都使用的是自动注入的方法，手动注入使用的不多。就算是使用手动注入的方法，使用的主流
Spring 面向切面编程 第3关：AOP实现原理-JDK动态代理
于建章的博客
11-03 2210
Spring 面向切面编程 第3关：AOP实现原理-JDK动态代理
AOP的底层实现--JDK动态代理，CGLIB动态代理
mycsdn_525的博客
10-26 174
AOP中的动态代理的区别--JDK和CGLIB
qq_40277163的博客
05-10 1810
区别 spring AOP的底层实现机制是动态代理，动态代理有JDK 和CGLIB 动态代理 下面说一下这两种动态代理的区别： 1、JDK动态代理只提供接口的代理，不支持类的代理 jdk会在运行时为目标类生成一个 动态代理类$proxy*.class 该代理类是实现了目标类接口的一个类，并且会实现接口所有的方法增强代码 调用时 通过先去调用处理类进行增强，再通过反射的方式进行调用目标方法，从而实现AOP 2、如果代理类 没有实现接口，那么spring AOP会选择使用CGLIB来动态代理目标类 CGL
Spring AOP 实现原理详解之 JDK 动态代理
流华追梦的专栏
02-22 943
JDK 动态代理是由 JDK 提供的工具类 Proxy 实现的，动态代理类是在运行时生成指定接口的代理类，每个代理实例（实现需要代理的接口）都有一个关联的调用处理程序对象，此对象实现了InvocationHandler，最终的业务逻辑是在 InvocationHandler 实现类的 invoke 方法上。JDK 动态代理不需要任何依赖。 2.2. 定义实体 2.3. 被代理的类和接口 接口如下： 实现类如下： 2.4. JDK 代理类 代理类如下： 2.5. 使用代理 启动类
Spring aop 之 静态代理 动态代理 Aspectj aop-config 等实现方式
09-01
主要对Spring AOP的相关概念和简单的静态代理、动态代理以及常见的几种AOP配置方式做总结学习。主要包括：1. AOP的常见概念 2. 静态代理 3. jdk动态代理 4. Aspectj and Aspectjweaver 5. **aop-config** 6. CGLIB ...
Spring Aop的底层实现技术 --- Jdk动态代理原理
03-31
Spring AOP 的底层实现技术 --- Jdk 动态代理原理 JDK 动态代理是 Spring AOP 的底层实现技术，允许开发者在运行期创建接口的代理实例。在 JDK 1.3 以后，JDK 动态代理技术提供了实现 AOP 的绝好底层技术。JDK 动态...
Java Spring代理模式AOP-IOC分析
10-01
Java Spring代理模式AOP-IOC分析 一、代理模式概述 在软件设计中，代理模式是一种常用的设计模式。...本文对Java Spring代理模式AOP-IOC进行了分析和讨论，并提供了一个示例项目来演示如何使用Spring实现AOP和IOC。
java Spring代理模式AOP-IOC结合
10-01
动态代理是一种更加灵活的代理模式实现方式，我们可以使用 JDK 内置的 Proxy 类或 CGLIB 库来实现动态代理。动态代理可以在运行时生成代理类，无需手动创建代理类。 四、AOP（Aspect Oriented Programming） AOP ...
基于springboot的青年公寓服务平台源码数据库
最新发布
s123456sj的博客
06-16 1180
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 404
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 582
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
Spring Boot集成antlr实现词法和语法分析
HBLOG
06-13 977
Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来解析C++；
spring aop jdk动态代理
08-31
Spring AOP中的JDK动态代理是一种实现动态代理的方式。它通过使用JDK的Proxy类和InvocationHandler接口来生成代理对象和处理代理逻辑。具体来说，当我们使用Spring AOP时，代理对象的生成直接使用了JDK动态代理的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值