动态代理

最新推荐文章于 2024-05-20 23:45:16 发布
最新推荐文章于 2024-05-20 23:45:16 发布
阅读量167 收藏
点赞数
分类专栏： JAVA 设计模式 文章标签： 动态代理 设计模式 cglib java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013140391/article/details/71123022
版权

代理模式需要为每个类编写一个代理类，动态代理则会自动生成代理类简化操作。
实现动态代理有两种方式java自带api和cglib。

java自带api

基于接口生成代理类，实现动态代理

/**
 * 功能接口
 */
public interface MyDao {
    void create();

    void query();

    void update();

    void delete();
}

/**
 * 功能类
 */
public class MyDaoImp implements MyDao {
    public void create() {
        // 第八步：正真的create方法被调用
        System.out.println("create something ... ");
    }

    public void query() {
        System.out.println("query something ... ");
    }

    public void update() {
        System.out.println("update something ... ");
    }

    public void delete() {
        System.out.println("delete something ... ");
    }
}

/**
 * 委托类
 */
public class Agent implements InvocationHandler {

    private Object proxied;
    private int id;

    public Agent(Object proxied, int id) {
        this.proxied = proxied;
        this.id = id;
    }

    // 通过代理类我们实现了权限过滤
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 第六步：目标方法调用前做一些业务操作，我们这里做了权限过滤
        if (method.getName().equals("query")) {
            return method.invoke(proxied, args);
        }

        if (id != 110) {
            System.out.println("id=" + id + "没有" + method.getName() + "权限");
            return null;  // 空对象
        }
        // 第七步：利用反射调用了MyDaoImp中的create方法
        return method.invoke(proxied, args);
    }
}

/**
 * 测试类
 */
public class Main {

    public static void main(String[] args) {
        // 第一步：新建对象，调用函数
        Main main = new Main();
        main.start();
        // main.getClassFile(new Class[]{MyDao.class});
    }

    private void start() {

        int id = 1101;
        // 第二步：新建委托类，传入被代理的功能类，以及我们业务需要的id
        Agent agent = new Agent(new MyDaoImp(), id);
        // 第三步：取得代理对象，传入类加载器、实现的接口数组、代理类，这时会根据传入的参数生成一个代理类$Proxy0
        MyDao myDao = (MyDao) Proxy.newProxyInstance(MyDaoImp.class.getClassLoader(), new Class[]{MyDao.class}, agent);
        // 第四步：调用create方法，由于我们使用的是接口，所以我们正真拿到的对象并不是MyDaoImp，而是第三步生成的实现了MyDao的$Proxy0类（以create方法为例讲解调用步骤）
        myDao.create();
        myDao.query();
        myDao.delete();
        myDao.update();

    }

    // 该方法可以获取动态生成的代理类
    private void getClassFile(Class[] classes) {
        byte[] classFile = ProxyGenerator.generateProxyClass("com.sun.proxy.$Proxy0", classes);

        FileOutputStream out = null;

        try {
            out = new FileOutputStream(("D:/$Proxy0.class"));
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 生成的代理类
 * 可用测试类中的getClassFile方法取得class文件
 */
public final class $Proxy0 extends Proxy implements MyDao {
    private static Method m1;
    private static Method m6;
    private static Method m2;
    private static Method m4;
    private static Method m5;
    private static Method m0;
    private static Method m3;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void query() throws  {
        try {
            super.h.invoke(this, m6, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void delete() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void create() throws  {
        try {
            // 第五步：调用Agent中的invoke方法
            // super.h 在构造器中传入，即为Agent对象
            // m5 在静态块中加载，反射取得MyDao中的create方法
            super.h.invoke(this, m5, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void update() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m6 = Class.forName("core.proxy.jdk.MyDao").getMethod("query", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("core.proxy.jdk.MyDao").getMethod("delete", new Class[0]);
            m5 = Class.forName("core.proxy.jdk.MyDao").getMethod("create", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m3 = Class.forName("core.proxy.jdk.MyDao").getMethod("update", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

注：

该动态代理的原理，根据传入的委托类和接口，利用java的字节码技术自动生成一个新的代理类。
由于我们使用的是接口，所用我们真正使用的是生成的代理类。
该动态代理有一个接口
spring默认使用该动态代理技术

cglib

基于继承生成代理类，实现动态代理

/**
 * 功能类
 */
public class MyDaoImp {
    public void create() {
        System.out.println("create something ... ");
    }

    public void query() {
        System.out.println("query something ... ");
    }

    public void update() {
        System.out.println("update something ... ");
    }

    public void delete() {
        System.out.println("delete something ... ");
    }
}

/**
 * 委托类
 */
 public class Agent implements MethodInterceptor {

    private int id;

    public Agent(int id) {
        this.id = id;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 第九步：处理业务员逻辑
        if (method.getName().equals("query")) {
            return methodProxy.invokeSuper(o, objects);
        }

        if (id != 110) {
            System.out.println("id=" + id + "没有" + method.getName() + "权限");
            return NoOp.INSTANCE;  // 空对象
        }
        // 第十步：调用真正的业务类
        return methodProxy.invokeSuper(o, objects);
    }
}

/**
 * 测试类
 */
public class Main {

    public static void main(String[] args) {
        // 第一步：新建对象，调用函数
        Main main = new Main();
        main.start();
    }

    public void start() {
        int id = 111;
        // 第二步：新建委托类
        Agent agent = new Agent(id);
        // 第三步：新建代理类处理对象
        Enhancer enhancer = new Enhancer();
        // 第四步：设置生成代理对象的父类
        enhancer.setSuperclass(MyDaoImp.class);
        // 第五步：设置委托类
        enhancer.setCallback(agent);
        // 第六步：取得生成的代理类，返回的类为MyDaoImp的子类
        MyDaoImp myDaoImp = (MyDaoImp) enhancer.create();
        // 第七步：调用create方法，实际调用了MyDaoImp子类的create方法，（以create方法为例继续接下去的流程）
        myDaoImp.create();
        myDaoImp.query();
        myDaoImp.update();
        myDaoImp.delete();
        getClassFile(enhancer);
    }

    // 获取代理对象字节码文件
    private void getClassFile(Enhancer enhancer){

        FileOutputStream out = null;

        try {
            byte[] bytes = DefaultGeneratorStrategy.INSTANCE.generate(enhancer);
            out = new FileOutputStream(("D:/Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72.class"));
            out.write(bytes);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 生成的代理类
 * 可用测试类中的getClassFile方法取得class文件
 */
public class aa28f65a extends core.proxy.cglib.MyDaoImp implements net.sf.cglib.proxy.Factory {
    private boolean CGLIB$BOUND;
    public static java.lang.Object CGLIB$FACTORY_DATA;
    private static final java.lang.ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final net.sf.cglib.proxy.Callback[] CGLIB$STATIC_CALLBACKS;
    private net.sf.cglib.proxy.MethodInterceptor CGLIB$CALLBACK_0;
    private static java.lang.Object CGLIB$CALLBACK_FILTER;
    private static final java.lang.reflect.Method CGLIB$update$0$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$update$0$Proxy;
    private static final java.lang.Object[] CGLIB$emptyArgs;
    private static final java.lang.reflect.Method CGLIB$delete$1$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$delete$1$Proxy;
    private static final java.lang.reflect.Method CGLIB$create$2$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$create$2$Proxy;
    private static final java.lang.reflect.Method CGLIB$query$3$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$query$3$Proxy;
    private static final java.lang.reflect.Method CGLIB$equals$4$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$equals$4$Proxy;
    private static final java.lang.reflect.Method CGLIB$toString$5$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$toString$5$Proxy;
    private static final java.lang.reflect.Method CGLIB$hashCode$6$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$hashCode$6$Proxy;
    private static final java.lang.reflect.Method CGLIB$clone$7$Method;
    private static final net.sf.cglib.proxy.MethodProxy CGLIB$clone$7$Proxy;

    static void CGLIB$STATICHOOK2() { /* compiled code */ }

    final void CGLIB$update$0() { /* compiled code */ }

    public final void update() { /* compiled code */ }

    final void CGLIB$delete$1() { /* compiled code */ }

    public final void delete() { /* compiled code */ }

    final void CGLIB$create$2() { /* compiled code */ }

    // 生成的代理类无法完全反编译
    // 第八步：调用Agent的intercept方法
    // 预测无法反编译的内容为 intercept(this, CGLIB$create$2$Method, null, CGLIB$create$2$Proxy)
    public final void create() { /* compiled code */ }

    final void CGLIB$query$3() { /* compiled code */ }

    public final void query() { /* compiled code */ }

    final boolean CGLIB$equals$4(java.lang.Object o) { /* compiled code */ }

    public final boolean equals(java.lang.Object o) { /* compiled code */ }

    final java.lang.String CGLIB$toString$5() { /* compiled code */ }

    public final java.lang.String toString() { /* compiled code */ }

    final int CGLIB$hashCode$6() { /* compiled code */ }

    public final int hashCode() { /* compiled code */ }

    final java.lang.Object CGLIB$clone$7() throws java.lang.CloneNotSupportedException { /* compiled code */ }

    protected final java.lang.Object clone() throws java.lang.CloneNotSupportedException { /* compiled code */ }

    public static net.sf.cglib.proxy.MethodProxy CGLIB$findMethodProxy(net.sf.cglib.core.Signature signature) { /* compiled code */ }

    public aa28f65a() { /* compiled code */ }

    public static void CGLIB$SET_THREAD_CALLBACKS(net.sf.cglib.proxy.Callback[] callbacks) { /* compiled code */ }

    public static void CGLIB$SET_STATIC_CALLBACKS(net.sf.cglib.proxy.Callback[] callbacks) { /* compiled code */ }

    private static final void CGLIB$BIND_CALLBACKS(java.lang.Object o) { /* compiled code */ }

    public java.lang.Object newInstance(net.sf.cglib.proxy.Callback[] callbacks) { /* compiled code */ }

    public java.lang.Object newInstance(net.sf.cglib.proxy.Callback callback) { /* compiled code */ }

    public java.lang.Object newInstance(java.lang.Class[] classes, java.lang.Object[] objects, net.sf.cglib.proxy.Callback[] callbacks) { /* compiled code */ }

    public net.sf.cglib.proxy.Callback getCallback(int i) { /* compiled code */ }

    public void setCallback(int i, net.sf.cglib.proxy.Callback callback) { /* compiled code */ }

    public net.sf.cglib.proxy.Callback[] getCallbacks() { /* compiled code */ }

    public void setCallbacks(net.sf.cglib.proxy.Callback[] callbacks) { /* compiled code */ }
}

注：

该动态代理的原理，根据传入的委托类和业务类，利用java的字节码技术自动生成一个新的代理类。
生成的代理类为被代理的子类。
spring可选择使用该动态代理技术

参考文章
已忘记。。。

纯洁的LELE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
qt qtableview动态代理
09-14
通过动态代理，在单元格中添加spinbox，checkbox，combobox。
win 10 使用本地代理自动配置pac
drcwr的专栏
09-01 3万+
win 10 使用本地代理自动配置pac1.修改注册表 以下内容保为pac.reg,双击。或手动修改注册表。Windows Registry Editor Version 5.00[HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\CurrentVersion\Internet Settings] "EnableLegacyAutoPro
动态代理之实战
cswhit的博客
05-20 279
最近需要封装一个redis连接工具，需要根据配置来初始化，但是可能是集群模式也可能是单机模式，如果用普通的方法写的话可能是这样的 public class RedisSingle { public JedisPool jedisPool; public void setValue(String key, int second, String value) { Jedis resource = jedisPool.getResource(); resource.setex(key, s
Java两种动态代理JDK动态代理和CGLIB动态代理
Java相关领域
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
热门推荐
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
动态代理详解
白羊座的橙子
10-08 1万+
想要更加透彻的理解动态代理，首先要熟悉下静态代理。
java动态代理
飞！！！的博客
12-28 5万+
前段时间去学习了一下RPC原理，其中提到了动态代理。特意去学习了一下，为了防止以后忘记，写下这篇博客做个记录，有不对的地方欢迎指正。 java中的常见的动态代理如Spring AOP。关于动态代理首先需要了解代理模式，根据代理类的创建时间又可以分为静态代理和动态代理。 1、代理模式 代理模式是常见的设计模式之一，Java我们通常通过new一个对象然后调用其对应的方法来访问我们需要的服务。代理模式则...
动态代理机制
qq_49306008的博客
12-12 1911
文章目录代理模式1、使用代理模式的作用2、实现代理的方式3、静态代理 代理模式 代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。 换句话说，使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。 客户类真正想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。代理类与目标类要实现同一个接口。 例如：有A，B，C三个类，A原
cglib动态代理
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
CGLIB 动态代理
m0_61609890的博客
03-11 6909
目录 CGLIB 动态代理 简单结构: 添加依赖 定义类 CGLIB 动态代理 JDK的动态代理机制只能代理实现了接口的类。而不能实现接口的类就不能使用JDK的动态代理，CGLIB是针对类来实现代理的，它的原理是对指定目标类生成一个子类，并覆盖其中的方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 简单结构: 实现原理:继承思想 代理类继承目标类，重写目标类中的方法， CGLIB像是一个拦截器，在调用我们的代...
JDK动态代理
weixin_46666822的博客
06-17 1万+
个人理解： 就是当你写了一个接口，里面有方法，然后写了实现类实现方法，完成方法逻辑，然后有一天，想对这个方法进行修改，但是不想改源码，所以有两种方式可以实现。第一种是静态代理，创建一个类继承实现类，然后对方法进行修改，这样太局限，因为只能针对特定的类增强方法，有100个实现类就要创建100个子类去实现。第二种方式是动态代理，可以动态地生成代理类，这是可以接受的。 这篇文章记录的JDK动态代理 2.创建代理类 需要实现InvocationHandler接口，重写invoke方法，这里可以对方法进行增强。 3
java + 动态代理 + 动态代理实际应用场景
04-28
1：静态代理出现的实际背景，静态代理时如何演化成动态代理 2： 动态代理demo 举例实际应用场景（载入数据库驱动的时候，使用AIDL与系统Servic进行通信） 3: 动态代理使用到基础理论：ClassLoader 加载.class字节码...
动态代理由浅入深
09-04
动态代理的作用：可以在不改变原有类的基础上对方法进行增强。执行代理对象的任何方法，就需要执行invocationHandler的invoke方法。本文对以上内容进行了举例分析。
动态代理例子
05-17
是一个描述动态代理的实例，用的是反射的方法，感觉还是比较容易理解得
【设计模式深度剖析】【1】【结构型】【代理模式】| 玩游戏打怪、升级为例加深理解
最新发布
浣花御劍
05-20 1130
玩游戏打怪、升级为例深入理解代理模式
Java设计模式-备忘录模式（23）
艾利克斯冰的博客
05-17 94
备忘录模式
Java设计模式-责任链模式（17）
艾利克斯冰的博客
05-16 83
责任链模式提供了一种优雅的方式来组织和管理请求的处理流程，它不仅降低了请求发送者与接收者之间的耦合度，还为系统的扩展和维护创造了良好基础。通过灵活的设计，可以适应多种复杂的业务场景，是解决请求处理问题的有效手段之一。然而，其使用也需注意平衡系统复杂度与性能需求，确保模式的应用既满足功能需求，又保持了系统的高效与简洁。
【设计模式】JAVA Design Patterns——Bridge（桥接模式）
CSBIGDOG的博客
05-20 610
考虑一下你拥有一种具有不同附魔的武器，并且应该允许将具有不同附魔的不同武器混合使用。为每个附魔创建每种武器的多个副本，还是只是创建单独的附魔并根据需要为武器设置它？桥接模式使您可以进行第二次操作。桥接模式是一个更推荐组合而不是继承的模式。将实现细节从一个层次结构推送到具有单独层次结构的另一个对象。桥接模式是软件工程中使用的一种设计模式，旨在“将抽象与其实现分离，从而使两者可以独立变化”将抽象与其实现分离，以便二者可以独立变化。
android 动态代理
04-18
Android动态代理是一种在运行时生成代理对象的技术，它可以用于实现AOP（面向切面编程）和其他一些功能。在Android开发中，动态代理常用于实现事件监听、权限管理、网络请求等功能。 Android动态代理的实现方式主要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值