手写动态代理--java

已于 2023-12-28 23:01:02 修改
阅读量660 收藏 8
点赞数 19
分类专栏： 设计模式 文章标签： java 代理模式 开发语言
于 2023-12-28 23:00:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Artisan_w/article/details/135280135
版权

文章目录

动态代理

首先明确代理模式是一个类的方法不能直接使用，我们在客户端和目标对象之间创建一个中介，这个中介就是动态代理，例如租房者，中介和房东之间，租房者通过中介访问房东。
在程序执行的过程中创建代理类对象，在创建过程中利用反射机制来实现的。
即为在使用过程中利用JDK提供的方法才会创建对象。
动态代理的实现有两种：
JDK动态代理：使用jdk字节的类，利用反射实现的代理，反射包Java.lang.reflect包括三个类：Proxy，Method和InvocationHandler
Method：能够实现所有某个接口定义的方法，具体运行哪个具体类的方法，根据invoke传入的对象来决定的。
InvocationHandler：只有一个接口invoke（） ，表示代理对象要执行的功能代码，你的代理类完成的功能就写在invoke() 方法中。
代理类完成的功能：调用目标方法，并且功能增强

静态代理的写法

被代理类接口

package proxy1;

public interface Foo {
    void fo();
    int bar();
}

被代理类

package proxy1;

public class target1 implements Foo{

    @Override
    public void fo() {
        System.out.println("fo");
    }

    @Override
    public int bar() {
        System.out.println("bar");
        return 1;
    }
}

代理类

package proxy1;

public class $Proxy1 implements Foo{
    @Override
    public void fo() {
        System.out.println("before fo");
        new target1().fo();
    }

    @Override
    public int bar() {
        System.out.println("before bar");
       return new target1().bar();
    }
}

执行

package proxy1;

public class Main1 {
    public static void main(String[] args) {
        Foo proxy = new $Proxy1();
        proxy.fo();
        proxy.bar();
    }
}

结果

before fo
fo
before bar
bar

动态代理基本写法

上面的代理类的方法都是写死的，如 new target1().fo(); return new target1().bar();
如果语句是需要动态的执行的话，那么就不好搞了，因此需要把这些动态语句，抽离出来。
这时候定义了InvocationHnadler接口，来表达这个被代理的类，通过h.invoke()方法来执行真实的类，就有了如下写法
我们通过反射的方式动态获取方法对象。
void invoke(Method method, Object[] args)
修改传入参数，一个是要执行的方法，一个是传入方法的参数
在代理中通过反射的方式来获取方法，并且将参数传进去
被代理接口

package proxy2;

import java.lang.reflect.InvocationTargetException;

public interface Foo {
    void fo() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException;
    int bar() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException;
}

被代理的类

package proxy2;

public class target1 implements Foo {

    @Override
    public void fo() {
        System.out.println("fo");
    }

    @Override
    public int bar() {
        System.out.println("bar");
        return 1;
    }
}

代理接口

package proxy2;

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

public interface InvocationHandler {
    Object invoke(Method method, Object[] args) throws InvocationTargetException, IllegalAccessException;
}

代理类

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

public class $Proxy1 implements Foo {

    proxy2.InvocationHandler h;

    public $Proxy1(InvocationHandler h) {
        this.h = h;
    }

    @Override
    public void fo() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Method method = Foo.class.getMethod("fo");
        h.invoke(method, null);
    }

    @Override
    public int bar() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Method method = Foo.class.getMethod("bar");
        String[] str = new String[2];
        str[0] = "param1";
        str[1] = "param2";
        return (int) h.invoke(method, str);
    }
}

具体执行

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

public class Main1 {

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        Foo proxy = new $Proxy1(new InvocationHandler() {

            @Override
            public Object invoke(Method method, Object[] objects) throws InvocationTargetException, IllegalAccessException {
                System.out.println("before...");
                return method.invoke(new target1(), args);
            }
        });
        proxy.fo();
        System.out.println(proxy.bar());
    }
}

通过预先定义一个InvocationHandler h，h中传入具体的类的方法即可通过反射的方式实现方法的执行。
ps：这里需要补充一下lamda表达式的写法，在new $Proxy1时传入一个new InvocationHandler()，这是一个接口需要具体实现，于是就有了

{
            @Override
            public Object invoke(Method method, Object[] objects) throws InvocationTargetException, IllegalAccessException {
                System.out.println("before...");
                return method.invoke(new target1(), args);
            }
}

实际上，这里有个隐形的实现类，不过被隐藏起来了，可以简化为lamda表达式

 Foo proxy = new $Proxy1((proxy1, method, objects) -> {
            System.out.println("before...");
            return method.invoke(new target1(), args);
        });

(proxy1, method, objects)就代表实现了接口的类

静态化具体方法

进一步的优化，将被代理类的方法进行静态化，这样可以加快执行速度

package proxy4;

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

public class $Proxy1 implements Foo {

    InvocationHandler h;
    public $Proxy1(InvocationHandler h) {
        this.h = h;
    }

    @Override
    public void fo() {
        try {
            h.invoke(this, fo, null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
    @Override
    public int bar() {

        try {
            String[] str = new String[2];
            str[0] = "param1";
            str[1] = "param2";
            return (int) h.invoke(this, bar , str);
        } catch (Throwable e) {
            e.printStackTrace();
            return -1;
        }

    }
    //静态化被代理方法
    static Method bar;
    static Method fo;
    static {
        try {
            bar = Foo.class.getMethod("bar");
            fo = Foo.class.getMethod("fo");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}


package proxy3;

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

public class $Proxy1 implements Foo {

    InvocationHandler h;
    public $Proxy1(InvocationHandler h) {
        this.h = h;
    }

    @Override
    public void fo() {
        try {
            h.invoke(this, fo, null);
        } catch (InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    @Override
    public int bar() {
        try {
            String[] str = new String[2];
            str[0] = "param1";
            str[1] = "param2";
            return (int) h.invoke(this, bar , str);
        } catch (InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
            return -1;
        }
    }
    static Method bar;
    static Method fo;
    static {
        try {
            bar = Foo.class.getMethod("bar");
            fo = Foo.class.getMethod("fo");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

改成用JDK的InvocationHandler

在程序中自定义了InvocationHandler
如果删除这个接口，将引用的这个接口改变为import java.lang.reflect.InvocationHandler;实际上效果是一样的
被代理类：

package proxy4;

public class target1 implements Foo {

    @Override
    public void fo() {
        System.out.println("fo");
    }

    @Override
    public int bar() {
        System.out.println("bar");
        return 1;
    }
}

代理类

package proxy4;

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

public class $Proxy1 implements Foo {

    InvocationHandler h;
    public $Proxy1(InvocationHandler h) {
        this.h = h;
    }

    @Override
    public void fo() {
        try {
            h.invoke(this, fo, null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
    @Override
    public int bar() {

        try {
            String[] str = new String[2];
            str[0] = "param1";
            str[1] = "param2";
            return (int) h.invoke(this, bar , str);
        } catch (Throwable e) {
            e.printStackTrace();
            return -1;
        }

    }
    static Method bar;
    static Method fo;
    static {
        try {
            bar = Foo.class.getMethod("bar");
            fo = Foo.class.getMethod("fo");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

测试代码

package proxy4;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

public class Main1 {

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, IOException {

        Foo proxy = new $Proxy1((proxy1, method, objects) -> {
            System.out.println("before...");
            return method.invoke(new target1(), args);
        });
        proxy.fo();
        System.out.println(proxy.bar());
        System.out.println(proxy.getClass());
        System.in.read();
    }
}

实现InvacationHandler接口，重写invoke()方法，在invoke() 方法中增强类的方法

Artisan_w
关注
  • 19
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【设计模式】手写JDK动态代理
qq_39220705的博客
04-07 214
最近在咕泡学院学习JDK动态代理时，看到老师有教手写JDK动态代理实现。由于课堂时间有限，老师讲的一些地方不够完善。自己后期进行了如下修改。 支持对有参数的方法进行代理。 添加了缩进。生成代理类Java文件更加美观。 整个生成代理类Java文件的过程都是动态生成的。 代码如下： XLInvocationHandler package com.gupao.proxy.custom;...
java装饰模式及动态代理模式示例源码
06-09
java中的装饰模式及动态代理模式示例源码，并且手写数据库连接池，以及展示动态代理模式在连接池中的使用
手写实现动态代理
ttq1985的专栏
05-25 821
一般来说最常见的动态代理是这么写的: 1,正常版本 import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class JDKProxy implements InvocationHandler { pri...
java 手写动态代理
djh_it的博客
03-24 597
动态代理，在方法的前后增加日志功能
手写简易版动态代理
Livingdd的博客
05-01 273
基础代码 先在此处声明接口与实现类，后续会用到。 Dao接口： package dao; /** * @author Livingdd * 2020/4/30 10:47 **/ public interface Dao { void queryDataBase(); String queryDataBase(String param); } Dao实现类： packag...
【动态代理】手写自己的动态代理
hansirl的博客
06-07 272
Spring中常用到JDK动态代理和CGLIB动态代理，让他们帮我们生成对目标对象增强后的代理对象，避免了在这个工程中手动新建代理类文件导致类爆炸，手写动态代理也是以此为目标。 /** * 目标对象 * @author l */ public interface TargetInterface { /** * 目标对象方法 * @param str1 参数 * @param str2 参数 */ void query(String str1, String str2); } /*
mybatis-demo:手写一个mybatis
05-01
核心：JDK动态代理、JDBC、XML解析 version-1.0 SQL语句定义在自定义注解中 难点：1、各个Mapper如何统一管理 2、参数映射 version-2.0 SQL语句定义在XML文件中 难点：XML文件的解析 Created on 2018.07.11 by ...
java8集合源码分析-javaInterview:java面试
06-04
java8 集合源码分析 2020年深圳java打工仔找工作记录帖,有一段时间的社畜了,...动态代理和静态代理的区别? jdk哪个接口实现动态代理? 自定义注解? 怎么写? spring 的事务管理机制是什么形式的?怎么理解spring的事务管
gupaoedu-mybatis
04-30
com.gupaoedu.mybatis.proxy.Test 为JDK动态代理测试用例。 MapperProxy.invokeDefaultMethod 方法何时执行？ 通过AOP，将 Configuration#interceptorChain 插入到Mapper的执行过程中。 将Execu
Java理论与实践：用动态代理进行修饰
03-04
虽然这些模式不使用动态代理，只用普通的类就能够实现，但是在许多情况下，动态代理方式更方便、更紧凑，可以清除许多手写或生成的类。动态代理是强大而未充分利用的工具，可以用于实现许多设计模式。这些模式基于...
两万字吐血总结，代理模式及手写实现动态代理（aop原理，基于jdk动态代理）
12-22
代理模式及手实现动态代理（aop原理）一、代理模式1. 定义2. 示例（1）静态代理（2）动态代理3. 通用类图4. 代理模式的优点二、jdk动态代理实现原理1. jdk动态代理源码分析(通过该示例学会阅读源码的方法)2.jdk动态代理生成的代理类的源码3.总结三、手写实现jdk动态代理 一、代理模式 熟悉代理模式的可以直接点击目录第二章，jdk动态代理实现原理,本文的精髓所在,通过这个例子，教大家如何去学习源码。 1. 定义 代理模式（Proxy Pattern） 是一个使用频率非常高的设计模式，其定义如下： Provide a surrogate or placeholder for an
手写动态代理框架
最新发布
06-05 104
package com.customproxy; import javax.tools.JavaCompiler; import javax.tools.StandardJavaFileManager; import javax.tools.ToolProvider; import java.io.File; import java.io.FileWriter; import java.lang.reflect.Constructor; import java.lang.reflect.Method; i
手写Java动态代理
程序员小潘
11-16 3184
博客内容来自笔者微信公众号。 动态代理又包括JDK代理和CGLIB代理。 MyBatis框架就用到了动态代理技术，我们只关心Dao接口，而无需关心实现类。 动态代理功能十分强大，今天记录一下本人 手动实现动态代理的过程。 分析 要如何对一个类对象进行代理呢？ 首先当然是要分析被代理对象，解析它的方法，然后动态的生成一个子类，对父类方法进行重写。 拦截方法，将方法的运行交给代理对象去完成，然后在...
手写JAVA动态代理
wflovejava的博客
12-18 216
代码目录： 具体类： public interface UserDao { public void query(String s); } public class UserDaoImpl implements UserDao{ private UserDao userDao; public UserDaoImpl(){ } publi...
手写JDK动态代理
瑞文のBlog
01-16 294
先看代码实现然后我们去剖析源码 1、还是需要去创建我们需要代理的代理类的接口和实现 service public interface OrderService { void test() throws Throwable; } impl public class OrderServiceImpl implements OrderService { @Override public void test() { System.out.println("【Test】"
【设计模式】——纯手写实现JDK动态代理
我爱吃土豆
08-22 6152
前言 在【设计模式】——代理模式(静态)以及【设计模式】——代理模式(动态)中，我们已经基本了解了什么是代理模式，以及什么是静态代理，什么是动态代理。 JDK动态代理以及Cglib动态代理其实底层实现原理都是字节码的重组，不过各自对应的代理场景不同，本文我们重点研究jdk动态代理。 通过前文的了解，我们已经知道在JDK动态代理中是JDK动态的帮我们生成一个名为$Proxy0的代理类，那么，我.........
不用JDK的动态代理，手写JDK动态代理
忆亦何为的博客
10-22 507
App ClassLoader实现步骤：继承ClassLoader并覆盖findClass。实现newProxyInstance共五个步骤。
java动态代理的实现
04-19
动态代理可以在运行时动态生成代理类，而不需要手写代理类。实现动态代理的步骤大致如下：首先定义一个业务逻辑接口，然后定义一个实现该接口的业务逻辑类。接着编写一个代理类实现InvocationHandler接口，并重写...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值