广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >深入理解Java动态代理与静态代理
  • 169

0
分享到

深入理解Java动态代理与静态代理

2024-04-02 19:04:59 169人浏览 泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录前言一、静态代理静态代理的使用与装饰者模式的区别二、动态代理jdk 动态代理CGlib 动态代理实现前言 学习 spring 的过程中，不可避免要掌握代理模式。这篇文章总结一下代

前言

学习 spring 的过程中，不可避免要掌握代理模式。这篇文章总结一下代理模式。顾名思义，代理，就是你委托别人帮你办事，所以代理模式也有人称作委托模式的。比如领导要做什么事，可以委托他的秘书去帮忙做，这时就可以把秘书看做领导的代理。下面将以这个例子来讲解。
代理模式又分为静态代理和动态代理。

一、静态代理

静态代理的使用

静态代理，代理类和被代理的类实现了同样的接口，代理类同时持有被代理类的引用，这样，当我们需要调用被代理类的方法时，可以通过调用代理类的方法来做到。

举例：假设领导的工作是开会和给员工考评。

先定义一个接口：

package com.sharpcj;
public interface IWork {
    void meeting();
    int evaluate(String name);
}

然后定义领导类：

package com.sharpcj;
import java.util.Random;
public class Leader implements IWork {
    @Override
    public void meeting() {
        System.out.println("领导早上要组织会议");
    }
    @Override
    public int evaluate(String name) {
        int score = new Random(System.currentTimeMillis()).nextInt(20) + 80;
        System.out.println(String.fORMat("领导给%s的考评为%s分", name, score));
        return score;
    }
}

秘书类：

package com.sharpcj;
public class Secretary implements IWork {
    private Leader mLeader;
    public Secretary(Leader mLeader) {
        this.mLeader = mLeader;
    }
    @Override
    public void meeting() {
        System.out.println("秘书先给老板准备材料");
        mLeader.metting();
    }
    @Override
    public int evaluate(String name) {
        return mLeader.evaluate(name);
    }
}

测试类：

package com.sharpcj;
public class TestApp {
    public static void main(String[] args) {
        Leader leader = new Leader();
        Secretary secretary = new Secretary(leader);
        secretary.meeting();
        secretary.evaluate("Joy");
    }
}

执行结果：

这个代码很简单，注意在调用Secretary类的 meeting 方法时，我们调用了Leader类的 meeting 的方法，在此之前，我们还扩充了该方法。这时有的人可能有疑惑了，这看起来有点是装饰者模式了。这到底怎么回事？

与装饰者模式的区别

实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。

先看看两者的 UML 类图区别：

代理模式：

装饰者模式：

两者伪代码：

代理模式:

Interface Subject {
    void doAction()
}
public class RealSubject implements Subject{
    @Override
    public void doAction() {};
}
public class Proxy implements Subject{
       private RealSubject realSubject;

       public Proxy(RealSubject realSubject) {
             //关系在编译时确定
            this.realSubject = realSubject;
       }
       @Override
       public void doAction() {
             ….
             realSubject.doAction();
             ….
       }
}

装饰者模式;

Interface Component {
    void doAction()
}
public class ConcreteComponent implement Component {
    @Override
    public void doAction() {};
}
public class Decorator implements Component {
       private Component component;

       public Decorator(Component component) {
             //关系在编译时确定
            this.component = new component;
       }
       public void doAction() {
             ….
             component.doAction();
             ….
       }
}

其实代理模式和装饰者模式侧重点不一样，代理模式重点在于明确了被代理的类。如上例中，秘书很明确要代理的是的领导。而装饰者模式侧重于拓展类的方法，装饰类持有的实现Component接口的类的对象不是固定的，也就是说，装饰类可以根据在调用时传入的参数，装饰任意一个实现了 Component 接口的类。

二、动态代理

动态代理的根据实现方式的不同可以分为 JDK 动态代理和 CGlib 动态代理。

JDK 动态代理：利用反射机制生成一个实现代理接口的类，在调用具体方法前调用InvokeHandler来处理。
CGlib 动态代理：利用ASM（开源的Java字节码编辑库，操作字节码）开源包，将代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
区别：JDK代理只能对实现接口的类生成代理；CGlib是针对类实现代理，对指定的类生成一个子类，并覆盖其中的方法，这种通过继承类的实现方式，不能代理final修饰的类。

JDK 动态代理

还是以上面的例子为例：
首先，定一个类实现 InvocationHandler 接口，并实现 invoke 方法：

package com.sharpcj;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class WorkInvocationHandler implements InvocationHandler {
    private Object object;
    public WorkInvocationHandler(Object object) {
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("object: " + object.getClass().getSimpleName());
        System.out.println("proxy: " + proxy.getClass().getSimpleName());

        if ("meeting".equals(method.getName())) {
            System.out.println("代理先准备会议材料...");
            return method.invoke(object, args);
        } else if ("evaluate".equals(method.getName())) {
            if(args[0] instanceof String) {
                if ("James".equals(args[0])) {
                    System.out.println("James 犯过错误，所以考评分数较低...");
                    return 70;
                }
            }
            return method.invoke(object, args);
        }
        return null;
    }
}

然后通过 Proxy.newProxyInstance() 方法创建代理对象：

package com.sharpcj;
import java.lang.reflect.Proxy;
public class TestApp {
    public static void main(String[] args) {
        
        Leader leader = new Leader();
        IWork proxy = (IWork) Proxy.newProxyInstance(Leader.class.getClassLoader(),
                new Class[]{IWork.class}, new WorkInvocationHandler(leader));
        proxy.meeting();
        proxy.evaluate("Joy");
        proxy.evaluate("James");
    }
}

输出结果：

我们看到，通过 WorkInvocationHandler 类，我们同样可以代理 Leader 类的方法的实现，实际上我们实现的是任意的方法的实现，只是我们在创建代理对象的时候传入的是 Iwork 接口以及 Leader 类对象。

这里需要注意的是：在 InvocationHandler 接口的 invoke 方法中第一个参数 proxy, 并不是我们调用方法的对象，那这个参数是什么呢？代码中，我特别增加相应打印，打印出了 proxy 的类名，实际上 proxy 是代理对象本身，它的意义在于，我们可以在 invoke 方法中，返回该代理对象，然后进行连续调用。

看如下例子：

package com.sharpcj.proxytest;
public interface IWork {
    IWork work(String subject);
}
package com.sharpcj.proxytest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class WorkInvocationHandler implements InvocationHandler {
    private Object object;
    public WorkInvocationHandler(Object object) {
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("work".equals(method.getName())){
            System.out.println("--- work: " + args[0]);
            return proxy;
        }
        return null;
    }
}
package com.sharpcj.proxytest;
import java.lang.reflect.Proxy;
public class TestApp {
    public static void main(String[] args) {
        IWork worker = (IWork) Proxy.newProxyInstance(IWork.class.getClassLoader(), new Class[]{IWork.class},
                new WorkInvocationHandler(new IWork() {
                    @Override
                    public IWork work(String subject) {
                        return null;
                    }
                }));
        worker.work("AAA").work("BBB").work("CCC");
    }
}

结果如下：

CGlib 动态代理实现

首先添加 cglib 依赖

build.gradle 文件：

... 
dependencies {
    // 引入 cglib 库
    compile 'cglib:cglib:3.1'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}
...

前面说了，cglib 针对类进行代理，我们以上面的 Leader 类为例，先创建一个类实现 MethodInterceptor接口：

package com.sharpcj;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class LeaderMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if ("meeting".equals(method.getName())) {
            System.out.println("代理先准备会议材料...");
            return methodProxy.invokeSuper(o, objects);
        } else if ("evaluate".equals(method.getName())) {
            if(objects[0] instanceof String) {
                if ("James".equals(objects[0])) {
                    System.out.println("James 犯过错误，所以考评分数较低...");
                    return 70;
                }
            }
            return methodProxy.invokeSuper(o, objects);
        }
        return null;
    }
}

测试代码：

package com.sharpcj;
import net.sf.cglib.core.DebugginGClassWriter;
import net.sf.cglib.proxy.Enhancer;
import java.lang.reflect.Proxy;
public class TestApp {
    public static void main(String[] args) {
        // System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\temp\code");  //保存生成的 class 文件
        Enhancer enhancer = new Enhancer(); // 通过CGLIB动态代理获取代理对象的过程
        enhancer.setSuperclass(Leader.class); // 设置enhancer对象的父类
        enhancer.setCallback(new LeaderMethodInterceptor()); // 设置enhancer的回调对象
        Leader proxy= (Leader)enhancer.create(); // 创建代理对象

        // 通过代理对象调用目标方法
        proxy.meeting();
        proxy.evaluate("Joy");
        proxy.evaluate("James");
    }
}

结果如下：

MethodInterceptor 接口只有一个 intercept 方法，这个方法有4个参数：

  • 1）obj表示增强的对象，即实现这个接口类的一个对象；
  • 2）method表示要被拦截的方法；
  • 3）args表示要被拦截方法的参数；
  • 4）proxy表示要触发父类的方法对象；

需要注意的是:实际调用是 methodProxy.invokeSuper(), 如果使用 invoke() 方法，则需要传入被代理的类对象，否则出现死循环，造成 stackOverflow 。

到此这篇关于深入理解Java动态代理与静态代理的文章就介绍到这了,更多相关Java动态静态代理内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 深入理解Java动态代理与静态代理

本文链接: https://www.lsjlt.com/news/151931.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • 深入理解Java动态代理与静态代理
    目录前言一、静态代理静态代理的使用与装饰者模式的区别二、动态代理JDK 动态代理CGlib 动态代理实现前言 学习 Spring 的过程中，不可避免要掌握代理模式。这篇文章总结一下代...
    99+
    2022-11-13
  • Java静态代理和动态代理的深入讲解
    代理模式 代理模式（Proxy）：为其他对象提供一个代理以控制对这个对象的访问。 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对...
    99+
    2022-11-12
  • Java 静态代理与动态代理解析
    目录一、代码实践静态代理动态代理二、常见的动态代理场景Retrofit中的动态代理使用动态代理实现 onClick注入三、源码探索 Jdk 中的动态代理生成代理类四、总结静态代理: ...
    99+
    2022-11-13
  • Java静态代理与动态代理案例详解
    代理模式 代理模式（Proxy）：为其他对象提供一个代理以控制对这个对象的访问。 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象...
    99+
    2022-11-12
  • java静态代理与动态代理的概念
    本篇内容介绍了“java静态代理与动态代理的概念”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！    ...
    99+
    2023-06-02
  • Java动态代理与静态代理实例分析
    这篇文章主要介绍了Java动态代理与静态代理实例分析的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇Java动态代理与静态代理实例分析文章都会有所收获，下面我们一起来看看吧。一、静态代理静态代理的使用静态代理，代...
    99+
    2023-07-02
  • Java的动态代理和静态代理详解
    目录0、代理模式1、静态代理2、 加深理解3、动态代理动态代理的例子总结0、代理模式 为什么要学习代理模式？这是SpringAOP的底层【SpringAOP和SpringMVC】 代...
    99+
    2022-11-13
  • JAVA代理,静态,动态详解
    目录代理静态代理动态代理JDK动态代理CGLib动态代理总结代理 为其他对象提供一种代理以控制这个对象的访问，在某些情况下一个对象不能直接访问那个对象时，代理就起到了客户端和被代理对...
    99+
    2022-11-12
  • java代理模式（静态代理、动态代理、cglib代理）
    目录代理模式静态代理代码接口被代理对象代理对象测试动态代理代码：接口目标对象代理对象测试cglib代理代码：目标对象代理对象测试应用总结代理模式 代理模式(Proxy Pattern...
    99+
    2022-11-12
  • Java深入分析动态代理
    目录代理模式静态代理动态代理JDK动态代理CGLIB动态代理JDK代理与CGLIB代理的区别"代理"这个词相信大家并不陌生，简单来说就是代替厂家来售卖商品，代理替...
    99+
    2022-11-13
  • Spring静态代理和动态代理代码详解
    本节要点：Java静态代理Jdk动态代理1 面向对象设计思想遇到的问题在传统OOP编程里以对象为核心，并通过对象之间的协作来形成一个完整的软件功能，由于对象可以继承，因此我们可以把具有相同功能或相同特征的属性抽象到一个层次分明的类结构体系中...
    99+
    2023-05-30
    spring 静态代理 动态代理
  • JAVA中静态代理与动态代理的区别有哪些
    这期内容当中小编将会给大家带来有关JAVA中静态代理与动态代理的区别有哪些，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。代理模式是java中最常用的设计模式之一，尤其是在spring框架中广泛应用。对于j...
    99+
    2023-05-31
    java 静态代理 动态代理
  • 怎么理解Java和SAP ABAP的静态代理和动态代理
    本篇内容介绍了“怎么理解Java和SAP ABAP的静态代理和动态代理”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！下图是某应用里方法的常规...
    99+
    2023-06-02
  • 解析Spring中的静态代理和动态代理
    目录一、静态代理1.1、静态代理的使用1.2、与装饰者模式的区别二、动态代理2.1、JDK 动态代理2.2、CGlib 动态代理实现一、静态代理 1.1、静态代理的使用 静态代理，代...
    99+
    2022-11-12
  • 代理模式:JAVA静态代理和动态代理的实例和实现详解
    目录前言静态代理实现简述创建human接口创建接口实现类创建针对接口实现增强操作的代理代理实现效果动态代理实现简述要点：向上转型创建YoungMan接口创建两个接口实现类创建动态代理...
    99+
    2022-11-12
  • Java反射的应用之动态代理深入理解
    目录一、代理模式的引入二、动态代理一、代理模式的引入 静态代理举例 特点：代理类和被代理类在编译期间，就确定下来了。 interface ClothFactory{ ...
    99+
    2022-11-12
  • 使用Java怎么实现静态代理和动态代理
    本篇文章为大家展示了使用Java怎么实现静态代理和动态代理，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。代理模式代理模式（Proxy）：为其他对象提供一个代理以控制对这个对象的访问。主要解决：在直接...
    99+
    2023-06-14
  • Java中动态代理和静态代理的示例分析
    这篇文章主要介绍了Java中动态代理和静态代理的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。0、代理模式为什么要学习代理模式？这是SpringAOP的底层【Spri...
    99+
    2023-06-29
  • 深入浅析java 中的JDK与cglib动态代理
    这篇文章将为大家详细讲解有关深入浅析java 中的JDK与cglib动态代理，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。java 动态代理实例详解1.jdk动态代理 package com...
    99+
    2023-05-31
    java jdk cglib
  • 深入浅析java 1.8 中动态代理的原理
    这篇文章将为大家详细讲解有关深入浅析java 1.8 中动态代理的原理，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。JDK8动态代理源码分析动态代理的基本使用就不详细介绍了：例子：class...
    99+
    2023-05-31
    java 动态代理 ava
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作