代理模式（Proxy Pattern）

最新推荐文章于 2024-05-23 18:30:00 发布
最新推荐文章于 2024-05-23 18:30:00 发布
阅读量1k 收藏 12
点赞数 27
分类专栏： 设计模式 文章标签： 代理模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73574147/article/details/136250336
版权

代理模式是一种结构型设计模式，用于控制对其他对象的访问。代理模式在访问对象时引入了一个代理对象，这个代理对象可以充当访问对象的接口，以控制对实际对象的访问。代理模式可以用于多种情况，包括延迟加载、访问控制、监视和远程代理等。、

结构

代理模式通常包含以下几个结构：

  1. Subject（主题）： 定义了一个共用的接口，代理和真实主题都实现这个接口。这是客户端直接访问的对象。

  2. Real Subject（真实主题）： 实际的对象，代理所代表的真实对象。代理模式的目的是控制对真实主题的访问，因此代理对象通常持有一个真实主题的引用。

  3. Proxy（代理）： 代理对象，实现了与主题相同的接口，并持有一个对真实主题的引用。代理对象控制客户端对真实主题的访问，并在必要时将请求传递给真实主题。

// 主题接口
interface Subject {
    void request();
}

// 真实主题
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 代理
class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy() {
        realSubject = new RealSubject();
    }

    @Override
    public void request() {
        // 在访问真实主题之前可以执行一些额外的操作
        System.out.println("Proxy: Performing pre-processing.");
        realSubject.request();
        // 在访问真实主题之后可以执行一些额外的操作
        System.out.println("Proxy: Performing post-processing.");
    }
}

public class Client {
    public static void main(String[] args) {
        Subject subject = new Proxy();
        subject.request();
    }
}

在这个示例中，Proxy 类充当了代理，它持有一个对 RealSubject 的引用，并在访问 RealSubject 之前和之后执行额外的操作。客户端代码通过代理访问主题对象，代理控制了对真实主题的访问。这个示例演示了代理模式的基本概念。

在Java中，代理可以分为两种主要类型：静态代理和动态代理。它们都可以用于生成不同的代理类，但它们的生成方式和使用场景有所不同。

静态代理

静态代理是在编译时生成代理类的方式。代理类通常是手动编写的，并且与真实主题接口具有相同的方法签名。静态代理通过组合或继承真实主题类，然后在代理类中调用真实主题类的方法，可以在调用前后添加额外的逻辑。

静态代理的典型应用场景包括权限验证、日志记录和性能监控等。

下面是一个简单的静态代理示例：

// 主题接口
interface Subject {
    void request();
}

// 真实主题
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 代理
class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy() {
        realSubject = new RealSubject();
    }

    @Override
    public void request() {
        System.out.println("Proxy: Performing pre-processing.");
        realSubject.request();
        System.out.println("Proxy: Performing post-processing.");
    }
}

public class Client {
    public static void main(String[] args) {
        Subject subject = new Proxy();
        subject.request();
    }
}

动态代理

动态代理是在运行时生成代理类的方式。Java提供了两种动态代理机制：基于接口的动态代理和基于类的动态代理。它们都使用Java的反射机制来创建代理对象。

动态代理通常更灵活，因为它可以代理任何实现了接口的类，而不需要手动编写代理类。它的应用场景包括AOP（面向切面编程）和远程方法调用等。

在Java中，有两种主要的动态代理方式：

  1. 基于接口的动态代理：这是最常见的动态代理方式。在这种方式下，代理类必须实现一个或多个接口，代理对象会实现这些接口并代理接口中的方法。Java提供了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现基于接口的动态代理。

    示例代码中的 Proxy.newProxyInstance() 就是基于接口的动态代理的典型使用方式。

  2. 基于类的动态代理：这种方式与基于接口的动态代理不同，它不要求代理类实现接口，而是要求代理类继承自特定的类。基于类的动态代理通常使用字节码生成库，如CGLIB（Code Generation Library）来生成代理类。CGLIB会生成一个继承自目标类的代理类，并覆盖目标类中的方法，实现代理逻辑。

基于接口的动态代理

以下是一个基于接口的动态代理示例：

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

// 主题接口
interface Subject {
    void request();
}

// 真实主题
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 动态代理处理器
class DynamicProxyHandler implements InvocationHandler {
    private Object realSubject;

    public DynamicProxyHandler(Object realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    /**
     * Object proxy：代理对象。在invoke方法中基本不用
     * Method method：对接口中的方法进行封装的method对象
     * Object[] args：调用方法的实际参数
     * 返回值
     *
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Dynamic Proxy: Performing pre-processing.");
        Object result = method.invoke(realSubject, args);
        System.out.println("Dynamic Proxy: Performing post-processing.");
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        /**
          * ClassLoader loader：类加载器，用于加载代理类。可以通过目标对象获取类加载器
         *  Class<?>[] interfaces：代理类实现的接口的字节码对象
         *  InvocationHandler h：代理对象的调用处理程序
          */
        Subject proxy = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(),
                new Class[]{Subject.class},
                new DynamicProxyHandler(realSubject)
        );
        proxy.request();
    }
}

在上面代码中，Proxy.newProxyInstance 方法用于创建动态代理对象，DynamicProxyHandler 作为代理处理器处理代理方法的调用，并在调用前后添加额外的逻辑。

或许上面动态代理的代码有点晦涩难懂，下面就举个具体的例子

实现一个简单计算器(整数的加减乘除)

首先定义一个接口 Calculator，在其中定义了一些数学计算操作：

interface Calculator {
    int add(int a,int b);
    int subtract(int a,int b);
    int multiply(int a, int b);
    int divide(int a,int b);
}

创建一个该接口的具体实现类

class BasicCalculator implements Calculator{
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int subtract(int a, int b) {
        return a - b;
    }

    @Override
    public int multiply(int a, int b) {
        return a * b;
    }

    @Override
    public int divide(int a, int b) {
        if(b==0){
            throw new ArithmeticException("除数不能为0");
        }
        return a / b;
    }
}

使用动态代理来创建一个代理对象，该代理对象可以拦截 Calculator 接口的方法调用并在方法调用前后执行一些额外的逻辑。

首先，创建一个实现了 InvocationHandler 接口的代理处理器类

class CalculatorProxy implements InvocationHandler {
    private final Object calculate;

    public CalculatorProxy(Object calculate) {
        this.calculate = calculate;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法调用前的逻辑
        System.out.println("执行的是"+method.getName()+"计算");
        // 调用目标对象的方法
        Object result = method.invoke(calculate, args);
        // 方法调用后的逻辑
        if(method.getExceptionTypes().length!=0){
            System.out.println("计算出错！！");
        }else{
            System.out.print("计算结果为：");
        }
        return result;
    }
}

最后创建一个Client类，并使用Proxy来创建代理对象

class Client {
    public static void main(String[] args) {
        // 创建目标对象
        Calculator calculator = new BasicCalculator();
        // 创建代理处理器
        CalculatorProxy handler = new CalculatorProxy(calculator);
        // 创建动态代理对象
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
            Calculator.class.getClassLoader(),
            new Class<?>[] {Calculator.class},
            handler
        );
        // 调用代理对象的方法
        System.out.println(proxy.add(10, 20));
        System.out.println(proxy.subtract(15, 9));
        System.out.println(proxy.multiply(3, 4));
        System.out.println(proxy.divide(10, 3));
        System.out.println(proxy.divide(10, 0));
    }
}

值得注意的是，CalculatorProxy 是动态代理中的代理处理器，它用于生成动态代理对象，而不是实际的代理类。动态代理对象实际上是在运行时(在内存中)创建的，可以用于代理多个不同的目标对象，而不需要为每个目标对象手动创建一个代理类。

基于类的动态代理

如果没有定义接口，则无法使用基于接口的动态代理方式，当目标类无法修改或不允许修改，但仍然需要在不改变其代码的情况下添加额外的行为等场景下，都需要使用基于类的动态代理

基于类的动态代理是一种通过生成继承目标类的代理类来实现代理的方式。这种代理方式不要求目标类实现接口，因为它是通过继承目标类并重写方法来实现代理的。在Java中，常用的基于类的动态代理实现工具是CGLIB(Code Generation Library)。

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。

由于CGLIB是第三方包，所以这里采用maven方式将其引入

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

接下来，还是以上面计算器为例。

假设只有一个目标类，其没有实现任何接口

class BasicCalculator{
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public int divide(int a, int b) {
        if(b==0){
            throw new ArithmeticException("除数不能为0");
        }
        return a / b;
    }
}

想要创建一个基于类的动态代理，以在方法调用前后记录日志。首先，需要使用CGLIB库创建代理类。

class CalculatorProxy implements MethodInterceptor {

    private BasicCalculator calculator = new BasicCalculator();
    public BasicCalculator getProxy(){
        // 创建Enhancer对象，相当于JDK代理(基于接口动态代理)中的Proxy类
        Enhancer enhancer = new Enhancer();
        // 设置父类的字节码对象
        enhancer.setSuperclass(BasicCalculator.class);
        // 设置回调函数
        enhancer.setCallback(this);
        // 创建代理对象
        return (BasicCalculator) enhancer.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 方法调用前的逻辑
        System.out.println("执行的是"+method.getName()+"计算");
        // 调用目标对象的方法
        Object result = method.invoke(calculator, args);
        // 方法调用后的逻辑
        if(method.getExceptionTypes().length!=0){
            System.out.println("计算出错！！");
        }else{
            System.out.print("计算结果为：");
        }
        return result;
    }
}

接着实现Client类测试

class Client {
    public static void main(String[] args) {
        // 创建代理工厂对象
        CalculatorProxy calculatorProxy = new CalculatorProxy();
        // 获取代理对象
        BasicCalculator proxy = calculatorProxy.getProxy();
        // 调用代理对象中的方法
        System.out.println(proxy.add(10, 20));
        System.out.println(proxy.subtract(15, 9));
        System.out.println(proxy.multiply(3, 4));
        System.out.println(proxy.divide(10, 3));
        System.out.println(proxy.divide(10, 0));
    }
}

三种代理方式的对比

这三种代理方式分别是：静态代理、JDK动态代理和CGLIB动态代理。它们在实现方式和使用场景上有不同的特点。

静态代理：
  • 实现方式：在编译期间手动创建代理类，代理类与目标类实现相同的接口或继承相同的父类，并且在代理类中调用目标类的方法。
  • 优点：
    • 易于理解和实现。
    • 可以在编译期间进行类型检查。
  • 缺点：
    • 需要为每个目标类创建一个代理类，导致类数量增加。
    • 静态代理不够灵活，如果有多个目标类需要代理，会导致代码重复。
  • 适用场景：适用于目标类不频繁变化，且只需要代理少数几个类的情况。
JDK动态代理：
  • 实现方式：使用Java的反射机制，通过java.lang.reflect.Proxy类和InvocationHandler接口创建代理类，代理类必须实现一个或多个接口。
  • 优点：
    • 不需要手动创建代理类，减少了代码重复。
    • 可以代理实现了接口的目标类。
    • 支持动态代理多个目标类。
  • 缺点：
    • 只能代理实现了接口的类。
    • 对于非接口方法无法代理。
  • 适用场景：适用于需要代理的类实现了接口的情况，例如AOP。
CGLIB动态代理：
  • 实现方式：使用字节码生成技术，通过生成目标类的子类作为代理类，代理类继承自目标类。
  • 优点：
    • 可以代理没有实现接口的类。
    • 可以代理非公共方法。
    • 不要求目标类实现接口，更灵活。
  • 缺点：
    • 生成的代理类可能会增加类加载时间和内存使用。
    • 不能代理final方法和类。
  • 适用场景：适用于需要代理非接口类或非公共方法的情况，例如Hibernate的持久化框架。
相同点
  1. 代理目的相同：静态代理、JDK动态代理和CGLIB动态代理都用于在不修改目标对象的情况下，为目标对象提供额外的功能或控制访问。
  2. 代理模式：它们都是代理设计模式的实现方式，具有相似的结构，包括代理类、目标类和接口（或父类）。
不同点
  1. 实现方式：
    • 静态代理：在编译期间手动创建代理类，代理类与目标类实现相同的接口或继承相同的父类。
    • JDK动态代理：使用Java的反射机制，在运行时动态生成代理类，代理类必须实现一个或多个接口。
    • CGLIB动态代理：通过生成目标类的子类作为代理类，在运行时动态生成代理类，不要求目标类实现接口。
  2. 代理能力：
    • 静态代理：代理类必须手动编写，不能代理多个不同的目标类，只能代理实现了接口的目标类。
    • JDK动态代理：可以代理多个不同的目标类，但只能代理实现了接口的目标类。
    • CGLIB动态代理：可以代理多个不同的目标类，包括没有实现接口的类。
  3. 性能：
    • 静态代理：性能一般较好，因为代理类在编译期间生成，不会引入运行时的性能开销。
    • JDK动态代理：性能相对较好，但比静态代理略有性能开销，因为需要使用反射生成代理类。
    • CGLIB动态代理：性能较差，因为它需要在运行时生成字节码，可能会引入更多的性能开销。
  4. 代理对象类型：
    • 静态代理：代理对象是编译时已知的，因此类型是确定的。
    • JDK动态代理：代理对象在运行时生成，类型是动态确定的。
    • CGLIB动态代理：代理对象也在运行时生成，类型是动态确定的，通常是目标类的子类。

总之，选择静态代理、JDK动态代理还是CGLIB动态代理取决于具体的需求。静态代理适用于简单的情况，JDK动态代理适用于代理接口实现的类，而CGLIB动态代理适用于代理非接口类和非公共方法的情况。

代理模式使用场景

代理模式是一种结构型设计模式，它用于控制对其他对象的访问，允许为对象提供间接的代理。代理对象通常作为被代理对象的接口的替代者，用于控制对被代理对象的访问。以下是一些代理模式的常见使用场景：

  1. 远程代理（Remote Proxy）：

    • 场景：当对象位于不同的地址空间（例如，网络服务器上）时，代理对象可以在客户端和远程对象之间充当中介，使客户端能够访问远程对象。
    • 示例：远程方法调用（RMI）、Web服务代理。

  2. 虚拟代理（Virtual Proxy）：

    • 场景：用于延迟创建或初始化昂贵的对象，只有在真正需要时才会创建。
    • 示例：加载大型图像或复杂文档时的虚拟代理，以避免启动时的性能问题。

  3. 保护代理（Protection Proxy）：

    • 场景：用于控制对对象的访问权限，只有在满足特定条件时才能访问。
    • 示例：文件权限控制、访问控制列表（ACL）。

  4. 缓存代理（Caching Proxy）：

    • 场景：用于缓存对象的操作结果，以提高访问速度。
    • 示例：缓存代理可以用于数据库查询结果的缓存，以减少数据库访问。

  5. 智能引用代理（Smart Reference Proxy）：

    • 场景：用于在访问对象时添加额外的控制逻辑，如引用计数、垃圾回收等。
    • 示例：Java中的java.lang.ref包中的弱引用、软引用等。

  6. 日志记录代理（Logging Proxy）：

    • 场景：用于记录对象的方法调用和操作，以进行调试或日志记录。
    • 示例：应用程序日志记录、性能分析。

  7. 计算属性代理（Virtual Proxy for Calculated Properties）：

    • 场景：用于延迟计算某些属性的值，只有在需要时才进行计算。
    • 示例：计算图形对象的面积或周长时的虚拟代理。

  8. 动态代理（Dynamic Proxy）：

    • 场景：用于在运行时创建代理对象，通常用于实现AOP（面向切面编程）。
    • 示例：Spring框架中的AOP就是一种动态代理的应用。

代理模式的核心思想是通过引入一个代理对象来控制对目标对象的访问，从而实现各种不同的功能和控制策略。在实际应用中，代理模式有助于解耦和提供更好的控制和管理对象的访问。

Onism_DreamBoat
关注
  • 27
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代理模式 Proxy Pattern
03-09
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
Proxy Pattern 代理模式
06-13
Proxy Pattern 代理模式 采用JAVA实现，可以下载看看。
设计模式之代理模式
lidaoping12345的博客
10-12 25
设计模式之代理模式
代理模式Proxy Pattern
weixin_45832694的博客
10-11 338
代理模式：（Proxy Pattern），一个类代表另一个类的功能，一般用于对要访问的类做一些控制、功能增强，同时又不想影响原来类的正常业务。缺点：因为代理对象，需要实现与目标对象一样的接口，如果目标接口类繁多，会导致代理类也多，同时一旦接口增加方法，则目标对象和代理类都需要维护。代理模式是一种设计模式，在不改变代码的情况下，实现对目标对象的功能扩展，甚至可以对目标对象进行功能覆盖或重写。静态代理：（目标接口、目标接口的实现、代理类），在项目中很少用，但是通过静态代理能够更好的了解动态代理。
代理模式 Proxy Pattern 【kotlin版代码参考】
移动端开发与最新技术
01-15 335
kotlin代理模式代码参考
设计模式【代理模式Proxy Pattern】
10-14 305
代理模式 在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。 介绍 意图：为其他对象提供一种代理以控制对这个对象的访问。 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建
JAVA代理模式Proxy Pattern
daitu_liang的博客
09-29 1021
代理模式的定义：对其他对象提供一种代理以控制对这个对象的访问。 代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 代理模式的思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信。 模式结
JAVA设计模式Design Pattern→单例模式Singleton Pattern、工厂模式Factory Pattern、代理模式Proxy Pattern
实干、效率、武功、心法
02-08 145
私有化构造函数的类可以提供相应的 “接口”（一般就是静态方法）来返回自己的唯一实例供外部调用，像这样的确保只生成一个实例的模式被称作单例模式。 工厂模式，一个模型，用来大规模的生产同类产品。该模式将对象的具体实例过程抽象化，并不关心具体的创建过程。通常，工厂模式被用来定义一个对象模型，之后，便可快速规模化实例化对象。 代理模式的定义其实比较简单：代理模式给某对象提供一个代理对象，由代理对象来控制对原对象的引用。 ...
代理模式【Proxy Pattern】
qq_35499112的博客
08-14 972
什么是代理模式呢？我很忙，忙的没空理你，那你要找我呢就先找我的代理人吧，那代理人总要知道被代理人能做哪些事情不能做哪些事情吧，那就是两个人具备同一个接口，代理人虽然不能干活，但是被代理的人能干活呀。
结构型-7.代理模式 Proxy Pattern
Holy
02-11 117
代理模式 Proxy Pattern1.概念及简介**意图：****应用场景：****优缺点：****角色类：**类图 1.概念及简介 别名：Surrogate 意图： 为目标对象提供一个占位对象或代理对象，用来控制客户端对目标对象的访问。 应用场景： 控制昂贵对象的实例化； 控制客户端访问目标对象的权限； 为远程对象提供本地引用代理。 优缺点： 代码结构变复杂 角色类： Subject 目标接口 RealSubject 目标接口实现类（昂贵类） Proxy 代理类，方法具体实现依赖RealSubj
Android设计模式之代理模式（Proxy Pattern）
05-31
Android设计模式之代理模式（Proxy Pattern）
Java 代理(proxy)模式
12-22
代理模式（Proxy Pattern） 　代理模式是常用的Java 设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间...
java 设计模式之代理模式（Proxy Pattern）实现代码及设计详解：动态代理模式、静态代理模式
03-13
java 代理模式实现代码及设计详解：动态代理模式、静态代理模式
【设计模式深度剖析】【1】【结构型】【代理模式】| 玩游戏打怪、升级为例加深理解
浣花御劍
05-20 1069
玩游戏打怪、升级为例深入理解代理模式
背包问题(01背包和无限背包)
weixin_38184628的博客
05-18 743
假设有一个背包，体积是 V，另外有 n 个物品，物品的体积分别是 v1, v2, ... vn，每个物品的价值是 w1, w1, ... wn。求怎么将物品放到背包里，才能使背包中物品的价值最大？背包问题是一个典型的动态规划问题。动态规划问题中经常包含一个最字，比如最大价值?最短路径?动态规划问题的求解思路包括以下几点：（1）只看眼前利益动态规划，关键字是动态，也就是说结果是在变化的。在计算过程中，只看眼前利益，只要当前这种情况满足要求，那么这就是中间的一个结果。下边的代码是找数组的最大值。
设计模式11——代理模式
最新发布
weixin_43687024的博客
05-23 323
代理模式（Proxy） 是一种行为型模式。1、为其他对象提供一种代理 以控制对这个对象的访问； 2、远程代理，也就是为一个对象在不同地址空间提供局部代表，这样就可以隐藏一个对象存在于不同地址空间的事实； 3、虚拟代理，是根据需要创建开销很大的对象。通过代理来存放实例化需要很长时间的真实对象； 4、安全代理，用来控制对真实对象的访问权限； 5、智能指引，是指当调用真 实的对象时，让代理处理另外的一些事情。
组合模式 (Composite Pattern)、装饰器模式 (Decorator Pattern)、外观模式 (Facade Pattern)、享元模式 (Flyweight Pattern)、代理模式 (Proxy Pattern)的应用案例和代码实现步骤的简要说明
07-20
5. 代理模式 (Proxy Pattern)： 应用案例：在一个网络请求中，可以使用代理模式来代表真实的网络请求对象，以进行一些额外的操作，例如鉴权、缓存等。 代码实现步骤：创建一个接口或抽象类来表示真实对象和代理...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值