Java静态代理和动态代理

已于 2024-10-09 15:29:57 修改
阅读量163 收藏 3
点赞数 3
文章标签： java 开发语言
于 2024-10-09 15:24:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61408891/article/details/142788007
版权

Java静态代理和动态代理

静态代理

package com.liuliu.spring.service;

/**
 * 静态代理的实现步骤描述：
 *
 * 定义目标接口：创建一个接口，包含需要被代理的方法。
 *
 * 实现真实对象：实现该接口的具体类，包含实际的业务逻辑。
 *
 * 创建代理类：创建一个代理类，同样实现目标接口，持有对真实对象的引用，并在方法中添加额外的逻辑。
 *
 * 使用代理类：在主程序中，实例化真实对象和代理对象，通过代理对象调用方法，从而实现对真实对象方法的增强。
 */
public class StaticProxy {
    public static void main(String[] args) {
        MyService3 realService = new MyServiceImpl3();
        MyService3 proxyService = new MyServiceProxy(realService);

        // 调用代理方法
        int result = proxyService.performAction(5);
        System.out.println("Result: " + result);
    }
}

// 抽象主题（Subject）接口
interface MyService3 {
    int performAction(int value);
}


// 真实主题（Real Subject）
class MyServiceImpl3 implements MyService3 {
    @Override
    public int performAction(int value) {
        System.out.println("Action performed with value: " + value);
        return value * 3; // 示例：返回值为参数的两倍
    }
}


// 代理类
class MyServiceProxy implements MyService3 {

    // 抽象主题接口的引用
    private final MyService3 realService;

    public MyServiceProxy(MyService3 realService) {
        this.realService = realService;
    }

    @Override
    public int performAction(int value) {
        System.out.println("Before method call");

        // 调用真实主题的方法并获取返回值
        int result = realService.performAction(value);

        System.out.println("After method call");

        // 返回结果
        return result;
    }
}

JDK动态代理

package com.liuliu.spring.service;

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


/**
 * 具体实现
 * 代理模式涉及以下几个角色：
 * <p>
 * 抽象主题（Subject）：是一个接口或抽象类，定义了真实主题和代理对象共同实现的方法，客户端通过抽象主题访问真实主题。
 * 真实主题（Real Subject）：是真正执行业务逻辑的对象，实现了抽象主题定义的方法，是代理模式中被代理的对象。
 * 代理（Proxy）：持有对真实主题的引用，可以控制对真实主题的访问，在其自身的方法中可以调用真实主题的方法，同时也可以在调用前后执行一些附加操作。
 * ————————————————
 *
 * JDK 动态代理的实现步骤主要包括以下几个步骤：
 *     引入 JDK 动态代理支持：确保你的项目中使用 Java 反射机制。
 *     定义接口：创建一个接口，包含要代理的方法。
 *     实现真实类：创建一个实现上述接口的真实类，定义具体的业务逻辑。
 *     实现 InvocationHandler：通过实现 InvocationHandler 接口来定义增强逻辑，重写 invoke() 方法。
 *     创建代理实例：使用 Proxy 类的 newProxyInstance() 方法，指定类加载器、接口和 InvocationHandler 实现，创建代理对象
 */

public class JDKProxy {
    public static void main(String[] args) {
        MyService realService = new MyServiceImpl();

        // 创建代理实例
        MyService proxyService = (MyService) Proxy.newProxyInstance(
                MyService.class.getClassLoader(),  // 类的加载器
                new Class<?>[]{MyService.class}, // 抽象主题接口
                new MyInvocationHandler(realService) // 真实主题
        );

        // 调用代理方法
        int result = proxyService.performAction(5);
        System.out.println("Result: " + result);
    }
}


// 抽象主题（Subject）接口
interface MyService {
    int performAction(int value);
}

// 真实主题（Real Subject）
class MyServiceImpl implements MyService {
    @Override
    public int performAction(int value) {
        System.out.println("Action performed with value: " + value);
        return value * 2; // 示例：返回值为参数的两倍
    }
}


// 代理（Proxy）
class MyInvocationHandler implements InvocationHandler {
	/**
     * 表示真实被代理的对象 MyServiceImpl 
     */
    private final Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    /**
     * @param proxy  就是调用该方法的对象（由Proxy.newProxyInstance返回的代理实例）
     * @param method 相当于被代理类的方法：比如performAction(int value)
     * @param args   被代理类方法传递的参数：比如performAction(5)
     * @return 一般返回方法的返回值，如果返回null，就空指针异常？？
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");

        // 调用真实主题的方法并获取返回值
        Object result = method.invoke(target, args);

        System.out.println("After method call");

        // 返回方法的返回值
        return result;
    }
}

Cglib动态代理

package com.liuliu.spring.service;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * CGLIB 动态代理的实现过程主要包括以下几个步骤：
 * <p>
 * 引入 CGLIB：确保你在项目中添加了 CGLIB 的依赖。
 * 定义真实类：创建要代理的真实类。（不需要抽象类）
 * 实现 MethodInterceptor：通过实现 MethodInterceptor 接口来定义增强逻辑（通过重写方法intercept()）。
 * 使用 Enhancer 创建代理：通过 Enhancer 类设置父类和回调，然后创建代理实例。
 */

public class CglibProxy {
    public static void main(String[] args) {
        // 创建 Enhancer 对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MyServiceImpl2.class); // 设置父类为 MyServiceImpl2
        enhancer.setCallback(new MyMethodInterceptor()); // 设置方法拦截器

        // 创建代理实例
        MyServiceImpl2 proxyService = (MyServiceImpl2) enhancer.create();

        // 调用代理方法
        int result = proxyService.performAction(5);
        System.out.println("Result: " + result);
    }
}

// 真实主题（Real Subject）
class MyServiceImpl2 {
    public int performAction(int value) {
        System.out.println("Action performed with value: " + value);
        return value * 2; // 示例：返回值为参数的两倍
    }
}

// 代理（Proxy）
class MyMethodInterceptor implements MethodInterceptor {
    /**
     * @param obj    传入的是代理实例 proxyService，即 MyServiceImpl2。
     * @param method 传入的是被调用的 performAction 方法的 Method 对象。
     * @param args   传入的是调用 performAction 时提供的参数数组，这里是一个包含值 5 的数组，即 new Object[]{5}。
     * @param proxy  传入的是 CGLIB 的 MethodProxy 对象，用于调用真实的 performAction 方法。
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method call");

        // 调用真实主题的方法并获取返回值
        Object result = proxy.invokeSuper(obj, args);

        System.out.println("After method call");

        // 返回方法的返回值
        return result;
    }
}

静态代理、JDK动态代理和CGLIB动态代理的区别

特性静态代理JDK动态代理CGLIB动态代理
定义编译时生成代理类运行时通过反射生成代理类运行时通过字节码生成代理类
实现方式手动实现代理接口依赖Java接口通过继承被代理类
优点简单直观，易于理解代码量少，灵活性高可以代理没有接口的类，性能较好
缺点增加代码量，维护复杂只能代理实现接口的类不能代理final类或final方法
性能较好较低（因使用反射）较好
适用场景简单或固定的代理需求大部分动态代理情境需要代理没有接口的类或所有方法

选择建议

  • 实现接口：选择JDK动态代理。
  • 无接口：选择CGLIB动态代理。
  • 简单需求：考虑静态代理。

Spirng中的动态代理的场景：

  • Spring AOP 默认使用 JDK 动态代理，如果被代理的类实现了接口。

  • 如果目标类没有实现任何接口，或者你强制要求使用 CGLIB 代理，可以通过配置来指定。

    <aop:aspectj-autoproxy proxy-target-class="true" />

参考来源：一文搞懂设计模式—代理模式_软件设计模式proxy模式-CSDN博客

klspr一路向钱秃
关注
JAVA静态代理和动态代理
08-01
Java提供了两种主要的代理实现方式：静态代理和动态代理。 **静态代理** 静态代理是程序员手动创建代理类并实现与目标对象相同的接口。代理类和目标类都必须实现相同的接口，这样代理类就可以在调用目标对象方法的...
java静态代理和动态代理
01-05
Java提供了两种主要的代理实现方式：静态代理和动态代理。 ### 静态代理 静态代理是在编译时就已经确定了代理关系。首先，我们需要定义一个接口，比如`Car`，这个接口描述了汽车的行为： ```java public ...
java静态代理和动态代理详解
10-16
在Java中，代理主要分为静态代理和动态代理。 1. 静态代理： 静态代理是在编译时就已经明确代理类与被代理类关系的一种方式。为了实现静态代理，我们需要手动创建一个代理类，这个代理类通常会实现与被代理类相同的...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 912
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 341
JDK1.0主要特性。
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1010
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 697
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
==与equals比较
suuijbd的博客
10-08 375
在JVM中，内存分为堆内存跟栈内存。他们二者的区别是： 当我们创建一个对象（new Object）时，就会调用对象的构造函数来开辟空间，将对象数据存储到堆内存中，与此同时在栈内存中生成对应的引用，当我们在后续代码中调用的时候用的都是栈内存中的引用。还需注意的一点，基本数据类型是存储在栈内存中。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 509
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
优先级队列详解
最新发布
2301_79083481的博客
10-08 742
讲解了优先级队列的使用和模拟实现
Java内存布局
阿呆的专栏
10-01 836
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java中的break、continue和return语句
weixin_73230994的博客
10-05 365
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1343
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 189
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1063
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1406
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
【hot100-java】【两数相加】
m0_73629042的博客
10-04 152
【代码】【hot100-java】【两数相加】
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 634
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
Java 静态代理和动态代理
06-29
Java 中的代理模式分为静态代理和动态代理两种类型，它们主要用于控制对目标对象的访问、增强其功能或提供额外的行为。 1. **静态代理**： - 静态代理是预先定义好一个类作为目标对象的代理，代理类在编译时就已经知道目标对象的确切类型。 - 在代理类中，创建目标对象实例并封装在其方法中，当调用代理的方法时，实际上是执行代理类中的相应代码。 - 缺点是无法针对未知的目标类创建代理，如果需求发生变化，需要修改代理类，不够灵活。 2. **动态代理**： - 动态代理是由 Java.lang.reflect包中的 Proxy 类和 InvocationHandler 接口提供的，可以在运行时动态生成代理对象。 - 创建代理对象时，需要提供一个实现了 InvocationHandler 接口的实例，该实例在代理方法被调用时会被调用，从而实现动态地拦截和修改方法行为。 - 动态代理提供了更大的灵活性，因为它可以处理任何实现了特定接口的目标对象，并且可以动态添加新的行为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值