Java动态代理的实现

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量108 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28140917/article/details/131778332
版权

目录

JDK动态代理

在学习Spring的时候，我们知道Spring主要有两大思想，一个是IoC，另一个就是AOP，对于IoC，依赖注入就不用多说了，而对于Spring的核心AOP来说，我们不但要知道怎么通过AOP来满足的我们的功能，我们更需要学习的是其底层是怎么样的一个原理，而AOP的原理就是java的动态代理机制，所以本篇随笔就是对java的动态机制进行一个回顾。

在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的：

1-InvocationHandler

InvocationHandler is the interface implemented by the invocation handler of a proxy instance.

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

每一个动态代理类都必须要实现 InvocationHandler 这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由 InvocationHandler 这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我们看到这个方法一共接受三个参数，那么这三个参数分别代表什么呢？

Object invoke(Object proxy, Method method, Object[] args) throws Throwable
/**
proxy:　　指代我们所代理的那个真实对象
method:　　指代的是我们所要调用真实对象的某个方法的Method对象
args:　　指代的是调用真实对象某个方法时接受的参数
*/

如果不是很明白，等下通过一个实例会对这几个参数进行更深的讲解。
接下来我们来看看Proxy这个类：

Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

2-Proxy

这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

/**
Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.
*/

这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

/**
loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
*/

好了，在介绍完这两个接口(类)以后，我们来通过一个实例来看看我们的动态代理模式是什么样的：
首先我们定义了一个Subject类型的接口，为其声明了两个方法：

public interface Subject {
    public void rent();
    public void hello(String str);
}

接着，定义了一个类来实现这个接口，这个类就是我们的真实对象，RealSubject类：


public class RealSubject implements Subject {
    @Override
    public void rent() {
    	System.out.println("I want to rent my house");
    }
    @Override
    public void hello(String str) {
    	System.out.println("hello: " + str);
    }
}

下一步，我们就要定义一个动态代理类了，前面说个，每一个动态代理类都必须要实现 InvocationHandler 这个接口，因此我们这个动态代理类也不例外：


public class DynamicProxy implements InvocationHandler {
    //　这个就是我们要代理的真实对象
    private Object subject;
    // 构造方法，给我们要代理的真实对象赋初值
    public DynamicProxy(Object subject) {
    	this.subject = subject;
    }
    @Override
    public Object invoke(Object object, Method method, Object[] args) throws Throwable {
        //　　在代理真实对象前我们可以添加一些自己的操作
        System.out.println("before rent house");
        System.out.println("Method:" + method);
        // 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用 	
        method.invoke(subject, args);
        //　　在代理真实对象后我们也可以添加一些自己的操作
    	System.out.println("after rent house");
    	return null;
    }
}

最后，来看看我们的Client类：

public class Client {
	public static void main(String[] args) {
		// 我们要代理的真实对象
		Subject realSubject = new RealSubject();

		// 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
		InvocationHandler handler = new DynamicProxy(realSubject);

		/*
		 * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
		 * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
		 * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
		 * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
		 */
		Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
			.getClass().getInterfaces(), handler);
		System.out.println(subject.getClass().getName());
		subject.rent();
		subject.hello("world");
	}
}

我们先来看看控制台的输出：

$Proxy0
before rent house
Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent()
I want to rent my house
after rent house

before rent house
Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)
hello: world
after rent house

我们首先来看看 $Proxy0 这东西，我们看到，这个东西是由 System.out.println(subject.getClass().getName()); 这条语句打印出来的，那么为什么我们返回的这个代理对象的类名是这样的呢？

Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
.getClass().getInterfaces(), handler);

可能我以为返回的这个代理对象会是Subject类型的对象，或者是InvocationHandler的对象，结果却不是，首先我们解释一下为什么我们这里可以将其转化为Subject类型的对象？
原因就是在newProxyInstance这个方法的第二个参数上，我们给这个代理对象提供了一组什么接口，那么我这个代理对象就会实现了这组接口，这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个，因为这里的接口是Subject类型，所以就可以将其转化为Subject类型了。

同时我们一定要记住，通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。

接着我们来看看这两句

subject.rent();
subject.hello("world");

这里是通过代理对象来调用实现的那种接口中的方法，这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行，而我们的这个 handler 对象又接受了一个 RealSubject类型的参数，表示我要代理的就是这个真实对象，所以此时就会调用 handler 中的invoke方法去执行：

public Object invoke(Object object, Method method, Object[] args) throws Throwable {
    // 在代理真实对象前我们可以添加一些自己的操作
    System.out.println("before rent house");
    System.out.println("Method:" + method);
    // 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用 method.invoke(subject, args);
    // 在代理真实对象后我们也可以添加一些自己的操作
    System.out.println("after rent house");
    return null;
}

我们看到，在真正通过代理对象来调用真实对象的方法的时候，我们可以在该方法前后添加自己的一些操作，同时我们看到我们的这个 method 对象是这样的：

public abstract void com.xiaoluo.dynamicproxy.Subject.rent()

public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)

正好就是我们的Subject接口中的两个方法，这也就证明了当我通过代理对象来调用方法的时候，起实际就是委托由其关联到的 handler 对象的invoke方法中来调用，并不是自己来真实调用，而是通过代理的方式来调用的。

3-静态代理和动态代理的区别

静态代理

  1. 代理复杂，难于管理。
    代理类和目标类实现了相同的接口，每个代理类都需要实现目标类的方法，这样就出现了大量的代码重复。如果接口增加一个方法，除了所有目标类需要实现这个方法外，所有代理类也需要实现此方法。——>增加了代码维护的复杂度。
  2. 静态代理事先知道要代理的是什么。

动态代理

  1. 动态代理类DynamicProxy不需要实现目标类实现的接口。
  2. 动态代理不需要知道要代理什么类，只有在运行时才知道（在运行期动态创建一个目标类的接口的实例），因为构造方法接收目标对象的是Object对象。
  3. 动态代理是代理一个接口下的多个实现类。
  4. 动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运行时，由Java反射机制动态产生。

静态代理和动态代理主要区别：动态代理类DynamicProxy不需要实现目标类实现的接口。静态代理需要实现目标类实现的接口，一旦接口增加方法，所有实现了该接口的代理类都要修改代码。

疑问：静态代理的成员变量使用目标类的接口类型，构造方法接收目标类的接口类型参数并且赋值成员变量，然后这样就可以代理该接口下所有目标类，这样算不算动态代理？
答：不是，动态代理是不需要实现目标类实现的接口，这样接口内部的方法新增、修改、删除都不会影响动态代理类逻辑。 静态代理的这种实现了目标接口的代理类是需要修改的。

CGLib动态代理

CGLIB是一个强大、高性能的字节码生成库。使用CGLib实现动态代理，完全不受代理类必须实现接口的限制，而且CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。

需要引入对应的包：

asm.jar
cglib.jar
asm-commons.jar
asm-tree.jar

注意下版本问题

Maven项目引用

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

cglib动态代理相关的基础类：

  • net.sf.cglib.proxy.Enhancer 主要的增强类。
  • net.sf.cglib.proxy.MethodInterceptor 主要的方法拦截类，它是Callback接口的子接口，需要用户实现。
  • net.sf.cglib.proxy.MethodProxy JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用。
  • net.sf.cglib.proxy.Callback 接口在CGLIB包中是一个重要的接口，所有被net.sf.cglib.proxy.Enhancer类调用的回调（callback）接口都要继承这个接口。

cglib动态代理Demo

① 创建一个代理的目标类。

// 代理的目标类
class Person {
    //  代理类中由普通方法
    public void eat() {
        System.out.println("开始吃饭了。");
    }
 
    public void play() {
        System.out.println("出去玩了。");
    }
}

② 创建一个拦截器MyApiInterceptor，实现MethodInterceptor接口。

class DydamicProxyInterceptor implements MethodInterceptor {
 
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 在代理目标类前添加一些的操作
        System.out.println("吃饭前先洗手...");
        // 执行目标类的方法
        Object result = proxy.invokeSuper(obj, args);
        // 在代理目标类后添加一些的操作
        System.out.println("吃完饭后休息一会..." );
        return result;
    }
}

③ demo实现

public class TestCglibDemo {
    public static void main(String[] args) {
        // 1.先创建类加强器Enhancer来生成代理对象
        Enhancer enhancer = new Enhancer();
        // 2.设置代理的目标类
        enhancer.setSuperclass(Person.class);
        // 3.设置代理拦截器
        enhancer.setCallback(new DydamicProxyInterceptor());
        // 4.创建代理目标类对象
        Person person = (Person) enhancer.create();
        person.eat();
    }
}

Enhancer中有几个常用的方法：

  1. void setSuperclass(java.lang.Class superclass) 设置产生的代理对象的父类。
  2. void setCallback(Callback callback) 设置CallBack接口的实例。
  3. void setCallbacks(Callback[] callbacks) 设置多个CallBack接口的实例。
  4. void setCallbackFilter(CallbackFilter filter) 设置方法回调过滤器。
  5. Object create() 使用默认无参数的构造函数创建目标对象。
  6. Object create(Class[], Object[]) 使用有参数的构造函数创建目标对象。参数Class[] 定义了参数的类型，第二个Object[]是参数的值。

使用CallbackFilter可以实现目标类不同的方法使用不同的回调方法。CallbackFilter中的accept方法，根据不同的method返回不同的编号值i, 这个i值对应callbacks数组中的下标，就是调用了callbacks[i]。

package com.test;
 
import net.sf.cglib.proxy.*;
 
import java.lang.reflect.Method;
 
public class TestCglibDemo {
    public static void main(String[] args) {
 
        // 定义一个回调接口的数组
        Callback[] callbacks = new Callback[] {
                new DydamicProxyInterceptor(), new DydamicProxyForPlayInterceptor()
        };
 
        // 1.先创建类加强器Enhancer来生成代理对象
        Enhancer enhancer = new Enhancer();
        // 2.设置代理的目标类
        enhancer.setSuperclass(Person.class);
        // 3.设置代理回调的拦截器数组
        enhancer.setCallbacks(callbacks);
        // 4.设置回调选择器
        enhancer.setCallbackFilter(new CallbackFilterImpl()); 
		// 创建代理对象
        Person person = (Person) enhancer.create(); 
 
        person.eat();
        System.out.println("#################");
        person.play();
    }
}
 
class DydamicProxyInterceptor implements MethodInterceptor {
 
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 在代理目标类前添加一些的操作
        System.out.println("吃饭前先洗手...");
        // 执行目标类的方法
        Object result = proxy.invokeSuper(obj, args);
        // 在代理目标类后添加一些的操作
        System.out.println("吃完饭后休息一会..." );
        return result;
    }
}

class DydamicProxyForPlayInterceptor implements MethodInterceptor {
 
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("出去玩前先带钱...");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("没钱了回家..." );
        return result;
    }
}

class CallbackFilterImpl implements CallbackFilter {
    @Override
    public int accept(Method method) {
        if (method.getName().equals("play")){
            return 1;
        }else{
            return 0;
        }
    }
}

class Person {
    public void eat() {
        System.out.println("我要开始吃饭咯...");
    }
 
    public void play() {
        System.out.println("我要出去玩耍了,,,");
    }
}
随源qq_28140917
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
动态代理实现的两种方式
itbird的专栏
09-28 1710
我们知道不管静态代理还是动态代理，实际上都是对于源对象的一种控制，通过代理对象来间接访问目标对象。但是静态代理有以下两个问题静态代理存在的问题是：1）一旦接口新增或者修改，那么代理对象和被代理对象就得去适配修改2）静态代理是在代码编写时，去生成的，class文件必然会造成类爆炸的风险有没有方案解决以上的问题呢？显然是有的，那就是动态代理。动态代理，顾名思义，就是在运行时去动态生成代理，我们下面分别说两种实现方式，分别为JDK和Cglib。
java的动态代理机制详解
weixin_34362991的博客
10-22 1640
在学习Spring的时候，我们知道Spring主要有两大思想，一个是IoC，另一个就是AOP，对于IoC，依赖注入就不用多说了，而对于Spring的核心AOP来说，我们不但要知道怎么通过AOP来满足的我们的功能，我们更需要学习的是其底层是怎么样的一个原理，而AOP的原理就是java的动态代理机制，所以本篇随笔就是对java的动态机制进行一个回顾。 在java的动态代理机制中，有两个重要的类或接口...
JDK动态代理，代理接口没有实现类，实现动态代理
a907691592的博客
07-10 8093
JDK代理，代理的是接口，那么笔者想一想，既然代理的是接口，那如果没有实现类怎么办，能不能代理。答案是可以的，Mybatis就是这样的。 Mybatis使用JDK动态代理来实现Mapper接口，事先保存好Mapper接口，和接口声明的方法，返回值，参数类型，然后代理类的方法调用的时候使用MapperMethod这个事先放入方法缓存里的对象来真实调用功能。 笔者极度简化了一下代码： 被代理的接...
代理模式(Proxy Pattern)(二)：Java API中的动态代理
jialinqiang的专栏
05-22 4605
一、Java动态代理         相对于静态代理的代理类在编译时生成（.class文件），动态代理与其的区别是:动态代理类在运行时在JVM中生成。Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类(实现了InvocationHandler接口)对象，便能动态地获得代理类，避免了静态代理中代理类的急剧膨胀问题。代理类会负责将所有的方
java反射知识点小结
kuaimeidong的博客
01-08 144
1.反射 正射：直接对这个类进行实例化，之后使用这个类对象进行操作。 Phone phone = new Phone(); //直接初始化，「正射」 phone.setPrice(4); 反射：一开始并不知道我要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。 Class clz = Class.forName("com.xxp.reflect.Phone"); Met...
java动态代理实现自定义连接池
05-06
1.主要理解动态代理的设计思想 2.理解连接池的设计思想以及优点
java 动态代理实现注解日志拦截
04-02
java动态代理对象实现日志输出，另外再配上annotation实现注解输出。
java 动态代理实现AOP
05-17
讲述JAVA的动态代理的原理，以及通过JAVA的动态代理来实现AOP。简洁，易懂，学习AOP的入门级文档
jdk动态代理源码分析
shenbug的博客
01-03 418
jdk动态代理源码分析 源码探索代理类如何产生以及invoke的是如何如何调用的 一、 调用Proxy.newProxyInstance() public Object newProxyInstance(Object targetObject){ this.targetObject=targetObject; //该方法用于为指定类装载器、一组接口及
JAVA动态代理--使用JAVA API实现JAVA动态代理
T`
09-04 2067
1.什么是动态代理? 答：动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象，但是延迟实现实际对象的部分功能，实际对象实现系统的实际功能，代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。 2.为什么使用动态代理? 答：因为动态代理可以对请求进行任何处理 3.使用它有哪些好处? 答：因为
动态代理-使用方式
chentu9924的博客
09-28 145
JDK动态代理 代理类中使用的方法需要声明在接口中 需要得到目标类的对象 Cglib包中的动态代理 import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net...
动态代理相关API
蓝色虫子的博客
06-15 207
public interface InvocationHandler { Object invoke(Object var1, Method var2, Object[] var3) throws Throwable; } - 参数说明： Object var1 表示代理类的对象； Method var2 表示被代理的方法 Object[ ] var3 表示这个方法的参数 ...
JDK动态代理（接口的代理）
ccityzh的博客
04-12 3175
本文基于动态代理的基本思路，实现对接口的动态代理，使用接口函数完成你想完成的任务。其实主要是为了理解在使用mybatis的时候只有dao层接口函数，却可以在service层用来实现其配置文件中sql语句的功能，恍惚给人一种接口被执行的阴影。
纯接口的动态代理
tanzhangwen的专栏
08-17 2663
参考：http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/ 代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。相关类及接口 java.lang.reflect.Proxy：这是 Java 动态代理机制的主类，它提供了一组静态
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 415
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 479
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1503
c++中string的模拟实现，面试必会知识点
java动态代理实现
05-26
Java动态代理是一种在运行时期创建代理对象的技术，可以无需手动编写代理类的代码，而是通过反射机制来动态生成代理对象。Java动态代理主要涉及到两个类：`java.lang.reflect.Proxy`和`java.lang.reflect.InvocationHandler`。 下面是一个简单的Java动态代理的实现示例： 首先，定义一个接口`Subject`和一个实现类`RealSubject`： ```java public interface Subject { void doSomething(); } public class RealSubject implements Subject { @Override public void doSomething() { System.out.println("RealSubject do something."); } } ``` 接下来，定义一个实现了`InvocationHandler`接口的代理处理类`ProxyHandler`： ```java import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class ProxyHandler implements InvocationHandler { private Object target; public ProxyHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Before method execute."); Object result = method.invoke(target, args); System.out.println("After method execute."); return result; } } ``` `ProxyHandler`类中有一个成员变量`target`，表示被代理的对象。在`invoke()`方法中，会在方法执行前后分别输出`Before method execute.`和`After method execute.`，并调用被代理对象的方法。 最后，在主函数中使用`Proxy`类创建代理对象，并调用其方法： ```java import java.lang.reflect.Proxy; public class Main { public static void main(String[] args) { RealSubject realSubject = new RealSubject(); ProxyHandler proxyHandler = new ProxyHandler(realSubject); Subject proxySubject = (Subject) Proxy.newProxyInstance( realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), proxyHandler); proxySubject.doSomething(); } } ``` 运行程序，可以看到输出： ``` Before method execute. RealSubject do something. After method execute. ``` 这说明调用代理对象的`doSomething()`方法时，会先执行`ProxyHandler`类中的`invoke()`方法，再调用被代理对象的`doSomething()`方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值