【设计模式】动态代理Proxy_03

最新推荐文章于 2023-08-15 09:46:39 发布
最新推荐文章于 2023-08-15 09:46:39 发布
阅读量885 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 动态代理 Proxy Proxy原理剖析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acmman/article/details/46828187
版权
我们继续上一篇总结。

我们把TankTimeProxy的类Load进内存之后我们要生成它的一个对象。我们先来回顾一下我们之前写好的Proxy类： 
package cn.edu.hpu.ProxyTest;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;

import cn.edu.hpu.proxy.Moveable;

public class Test1 {
	public static void main(String[] args) throws Exception{
		String rt="\r\n";
		
		String src=
			"package cn.edu.hpu.proxy;"+ rt +


		"public class TankTimeProxy implements Moveable{"+ rt +
		"    Moveable t;"+ rt +
		"    long start;"+ rt +
		"    long end;"+ rt +


		"    public TankTimeProxy(Moveable t) {"+ rt +
			"        super();"+ rt +
			"        this.t = t;"+ rt +
		"    }"+ rt +


		"    public void before(){"+ rt +
			"        start=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"开始时间:\"+start+\"ms\");"+ rt +
		"    }"+
			
		"    public void after(){"+ rt +
			"        end=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"运行时间:\"+(end-start)+\"ms\");"+ rt +
		"    }"+ rt +
			
		"    @Override"+ rt +
		"	 public void move() {"+ rt +
			"        this.before();"+ rt +
			"        t.move();"+ rt +
			"        this.after();"+ rt +
		"    }"+ rt +
			
		"}";
		
		//拿到当前项目的根目录:System.getProperty("user.dir"));
		String fileName=System.getProperty("user.dir")
						+"/src/cn/edu/hpu/proxy/TankTimeProxy.java";
		
		//我们把src的源码写入自己创建的File文件中去
		File f=new File(fileName);
		FileWriter fw=new FileWriter(f);
		fw.write(src);
		fw.flush();
		fw.close();
		
		//编译(getSystemJavaCompiler()拿到系统默认的Java编译器，其实就是javac)
		JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
		//需要一个FileManager，用它来管理文件(参数1:诊断的监听器，参数2、3国际化)
		StandardJavaFileManager fileMgr=
			compiler.getStandardFileManager(null, null, null);
		//通过FileManager找到TankTimeProxy文件，然后放到一个Iterable中
		//Iterable是一个数组，用它可以进行迭代
		Iterable units=fileMgr.getJavaFileObjects(fileName);
		//参数:(输出位置，文件管理器对象，监听器，编译的时候指定的参数，用到那些class文件，需要编译哪些文件)
		CompilationTask t=compiler.getTask(null, fileMgr, null, null, null, units);
		//进行编译
		t.call();
		fileMgr.close();
		
		//把编译好的.class文件加载到内存中
		//urls指定.class文件所放的地方(使用URL还可以Load从网上传过来的类)
		URL[] urls=new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src")};
		//ClassLoader指的是吧硬盘里的Java文件放到内存中的那些个类
		URLClassLoader ul=new URLClassLoader(urls);
		Class c=ul.loadClass("cn.edu.hpu.proxy.TankTimeProxy");
		System.out.println(c);
		
	}
}


我们已经拿到TankTimeProxy类的class类，下面我们来得到它的对象： 
//得到TankTimeProxy类的构造方法，构造方法的参数为Moveable类型
Constructor ctr=c.getConstructor(Moveable.class);
Moveable m=(Moveable)ctr.newInstance(new Tank());
m.move();

运行结果:
class cn.edu.hpu.proxy.TankTimeProxy
开始时间:1436429931050ms
坦克正在移动中...
运行时间:6313ms

我们把Test1的所有代码转移到Proxy类中。我们的整个的Proxy类的结构如下： 
package cn.edu.hpu.proxy;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;


import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;


public class Proxy {
	
	//这个方法用来产生新的代理类
	//参数:告诉程序使用实现哪个接口的动态代理
	public static Object newProxyInstance() throws Exception{
		String rt="\r\n";
		
		String src=
			"package cn.edu.hpu.proxy;"+ rt +


		"public class TankTimeProxy implements Moveable{"+ rt +
		"    Moveable t;"+ rt +
		"    long start;"+ rt +
		"    long end;"+ rt +


		"    public TankTimeProxy(Moveable t) {"+ rt +
			"        super();"+ rt +
			"        this.t = t;"+ rt +
		"    }"+ rt +


		"    public void before(){"+ rt +
			"        start=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"开始时间:\"+start+\"ms\");"+ rt +
		"    }"+
			
		"    public void after(){"+ rt +
			"        end=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"运行时间:\"+(end-start)+\"ms\");"+ rt +
		"    }"+ rt +
			
		"    @Override"+ rt +
		"	 public void move() {"+ rt +
			"        this.before();"+ rt +
			"        t.move();"+ rt +
			"        this.after();"+ rt +
		"    }"+ rt +
			
		"}";
		
		//拿到当前项目的根目录:System.getProperty("user.dir"));
		String fileName=System.getProperty("user.dir")
						+"/src/cn/edu/hpu/proxy/TankTimeProxy.java";
		
		//我们把src的源码写入自己创建的File文件中去
		File f=new File(fileName);
		FileWriter fw=new FileWriter(f);
		fw.write(src);
		fw.flush();
		fw.close();
		
		//编译(getSystemJavaCompiler()拿到系统默认的Java编译器，其实就是javac)
		JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
		//需要一个FileManager，用它来管理文件(参数1:诊断的监听器，参数2、3国际化)
		StandardJavaFileManager fileMgr=
			compiler.getStandardFileManager(null, null, null);
		//通过FileManager找到TankTimeProxy文件，然后放到一个Iterable中
		//Iterable是一个数组，用它可以进行迭代
		Iterable units=fileMgr.getJavaFileObjects(fileName);
		//参数:(输出位置，文件管理器对象，监听器，编译的时候指定的参数，用到那些class文件，需要编译哪些文件)
		CompilationTask t=compiler.getTask(null, fileMgr, null, null, null, units);
		//进行编译
		t.call();
		fileMgr.close();
		
		//把编译好的.class文件加载到内存中
		//urls指定.class文件所放的地方(使用URL还可以Load从网上传过来的类)
		URL[] urls=new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src")};
		//ClassLoader指的是吧硬盘里的Java文件放到内存中的那些个类
		URLClassLoader ul=new URLClassLoader(urls);
		Class c=ul.loadClass("cn.edu.hpu.proxy.TankTimeProxy");
		System.out.println(c);
		
		//得到TankTimeProxy类的构造方法，构造方法的参数为Moveable类型
		Constructor ctr=c.getConstructor(Moveable.class);
		Moveable m=(Moveable)ctr.newInstance(new Tank());
		
		return m;
		
	}
}

到此为止，我们就自己写了一个生成动态代理的类。自己想往这个动态代理中写任何东西都可以。

我们虽然实现了一个动态代理，但是貌似我们只实现了Moveable接口的类的动态代理。如果换成实现了其它接口的类还是不行。那是不是可以产生一个对实现任意接口的类的代理？

思路：在Proxy类中，我们产生newProxyInstance()的时候，告诉程序你要实现哪个接口就可以了。 

//这个方法用来产生新的代理类
//参数:告诉程序使用实现哪个接口的动态代理
public static Object newProxyInstance(Class infce) throws Exception{
	String rt="\r\n";
		
	String src=
		"package cn.edu.hpu.proxy;"+ rt +


	"public class TankTimeProxy implements "+infce.getName()+"{"+ rt +
	......
}

测试: 
package cn.edu.hpu.proxy;


public class Client {
	public static void main(String[] args) throws Exception {
		
		Moveable m=(Moveable)Proxy.newProxyInstance(Moveable.class);
		m.move();
	}
}

测试结果:
class cn.edu.hpu.proxy.TankTimeProxy
开始时间:1436430626384ms
坦克正在移动中...
运行时间:9612ms

我现在想让它去实现其它接口的代理，也完全可以。

下面我们进行下一步的模拟。我们虽然可以换接口，但是我们下面的代码还是只是实现了一个move()方法，而不是我们实现的接口的方法，严格来说，实现的接口有多少方法，我们就应该给多少个方法生成代码。那么怎么知道这个Class中有多少个方法呢？

我们再写一个反射的测试：
我们想要知道一个类中有多少个方法，其实很简单: 
package cn.edu.hpu.ProxyTest;

import java.lang.reflect.Method;


public class Test2 {
	public static void main(String[] args) {
		//使用了Java的反射机制中的getMethods();方法来得到一个类的所有方法
		Method[] methods=cn.edu.hpu.proxy.Moveable.class.getMethods();
		for (Method m:methods) {
			System.out.println(m.getName());
		}
	}
}
测试结果:
move

既然我们能拿到某各类所有方法，对于我们代理类的方法这么改写: 
package cn.edu.hpu.proxy;


import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;


import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;


public class Proxy {
	
	//这个方法用来产生新的代理类
	//参数:告诉程序使用实现哪个接口的动态代理
	public static Object newProxyInstance(Class infce) throws Exception{
		String methodStr="";
		String rt="\r\n";
		
		//使用了Java的反射机制中的getMethods();方法来得到一个类的所有方法
		Method[] methods=infce.getMethods();
		for (Method m:methods) {
			methodStr += rt+"    @Override"+rt+
				"    public void "+m.getName()+"() {"+rt+
				"        this.before();"+ rt +
				"	     t."+m.getName()+"();"+ rt +
				"	     this.after();"+ rt +
				"    }"; //返回值通过反射机制也可以拿到，但是比较麻烦，我们这里暂时用void代替
		}
		
		
		
		String src=
			"package cn.edu.hpu.proxy;"+ rt +


		"public class TankTimeProxy implements "+infce.getName()+"{"+ rt +
		"    Moveable t;"+ rt +
		"    long start;"+ rt +
		"    long end;"+ rt +


		"    public TankTimeProxy(Moveable t) {"+ rt +
			"        super();"+ rt +
			"        this.t = t;"+ rt +
		"    }"+ rt +


		"    public void before(){"+ rt +
			"        start=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"开始时间:\"+start+\"ms\");"+ rt +
		"    }"+
			
		"    public void after(){"+ rt +
			"        end=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"运行时间:\"+(end-start)+\"ms\");"+ rt +
		"    }"+ rt +
			
		methodStr+ rt +
			
		"}";
		
		//拿到当前项目的根目录:System.getProperty("user.dir"));
		String fileName=System.getProperty("user.dir")
						+"/src/cn/edu/hpu/proxy/TankTimeProxy.java";
		
		//我们把src的源码写入自己创建的File文件中去
		File f=new File(fileName);
		FileWriter fw=new FileWriter(f);
		fw.write(src);
		fw.flush();
		fw.close();
		
		//编译(getSystemJavaCompiler()拿到系统默认的Java编译器，其实就是javac)
		JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
		//需要一个FileManager，用它来管理文件(参数1:诊断的监听器，参数2、3国际化)
		StandardJavaFileManager fileMgr=
			compiler.getStandardFileManager(null, null, null);
		//通过FileManager找到TankTimeProxy文件，然后放到一个Iterable中
		//Iterable是一个数组，用它可以进行迭代
		Iterable units=fileMgr.getJavaFileObjects(fileName);
		//参数:(输出位置，文件管理器对象，监听器，编译的时候指定的参数，用到那些class文件，需要编译哪些文件)
		CompilationTask t=compiler.getTask(null, fileMgr, null, null, null, units);
		//进行编译
		t.call();
		fileMgr.close();
		
		//把编译好的.class文件加载到内存中
		//urls指定.class文件所放的地方(使用URL还可以Load从网上传过来的类)
		URL[] urls=new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src")};
		//ClassLoader指的是吧硬盘里的Java文件放到内存中的那些个类
		URLClassLoader ul=new URLClassLoader(urls);
		Class c=ul.loadClass("cn.edu.hpu.proxy.TankTimeProxy");
		System.out.println(c);
		
		//得到TankTimeProxy类的构造方法，构造方法的参数为Moveable类型
		Constructor ctr=c.getConstructor(Moveable.class);
		Object m=ctr.newInstance(new Tank());
		return m;
		
	}
}

这样我们就可以生成实现任意接口的对象的代理类了。
测试： 
package cn.edu.hpu.proxy;

public class Client {
	public static void main(String[] args) throws Exception {
		
		Moveable m=(Moveable)Proxy.newProxyInstance(Moveable.class);
		m.move();
	}
}

生成的TankTimeProxy 
package cn.edu.hpu.proxy;
public class TankTimeProxy implements cn.edu.hpu.proxy.Moveable{
    Moveable t;
    long start;
    long end;
    public TankTimeProxy(Moveable t) {
        super();
        this.t = t;
    }
    public void before(){
        start=System.currentTimeMillis();
        System.out.println("开始时间:"+start+"ms");
    }    public void after(){
        end=System.currentTimeMillis();
        System.out.println("运行时间:"+(end-start)+"ms");
    }


    @Override
    public void move() {
        this.before();
	     t.move();
	     this.after();
    }
}

所以我们现在实现了这样一个功能：往newProxyInstance(Class infce)传任意接口，就能生成一个实现了某接口的类的对象。我们的“动态代理”又近了一步。

但是还有一个特别麻烦的事，我们现在在自己代理的内容是写死的。。

比如 
"    public void before(){"+ rt +
			"        start=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"开始时间:\"+start+\"ms\");"+ rt +
		"    }"+
			
		"    public void after(){"+ rt +
			"        end=System.currentTimeMillis();"+ rt +
			"        System.out.println(\"运行时间:\"+(end-start)+\"ms\");"+ rt
这段，里面的代码是写死的，我们只能实现时间上的代理，我们想实现其它类型代理实现不了...

怎么让before()和after()中的内容也让客户灵活指定？

不管怎么样，我们现在需要一个这样的东西:可以动态指定对方法进行处理的指令。

我们下篇总结继续

转载请注明出处：http://blog.csdn.net/acmman/article/details/46828187

光仔December
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++设计模式课件15_Proxy_代理模式.pdf
12-13
C++设计模式课件15_Proxy_代理模式.pdf
设计模式C++学习之代理模式（Proxy）
09-07
设计模式C++学习之代理模式（Proxy）
C++设计模式之代理模式(Proxy)
12-26
代理模式是一种程序设计最为重要的一种模式，其具体的使用非常广泛，根据它的作用，其实我们可以直接理解为中间件或者中间层，比如各类软件的中间件，软件与硬件中的中间层。 作用 为其他对象提供一种代理以控制对这个对象的访问。这样实现了业务和核心功能分离。 抽象类视图 分类 虚拟代理：是根据需要创建开销很大的对象，通过它来存放实例化需要很长时间的真实对象，使其只有在真正需要时才被创建。 远程代理：为一个对象在不同的地址空间提供局部代表，这样可以隐藏一个对象存在于不同地址空间的事实。这个不同的地址空间可以是在本机器上，也可以在另一台机器中。 智能引用代理：是指当调用真实对象时，代理处理
设计模式之代理模式proxy.zip
12-29
代码仅供参考学习 。
php设计模式 Proxy (代理模式)
12-19
代理，指的就是一个角色代表另一个角色采取行动，就象生活中，一个红酒厂商，是不会直接把红酒零售客户的，都是通过代理来完成他的销售业务。而客户，也不用为了喝红酒而到处找工厂，他只要找到厂商在当地的代理就行了，具体红酒工厂在那里，客户不用关心，代理会帮他处理。 代理模式，就是给某一对象提供代理对象，并由代理对象控制具体对象的引用。 代理模式涉及的角色： 抽象主题角色，声明了代理主题和真实主题的公共接口，使任何需要真实主题的地方都能用代理主题代替。 代理主题角色，含有真实主题的引用，从而可以在任何时候操作真实主题，代理主题功过提供和真实主题相同的接口，使它可以随时代替真实主题。代理主题通过持有真实主题
动态代理(Proxy)
热门推荐
紫竹blog
09-23 1万+
本文主要讨论代理模式和动态代理 一.代理模式的定义： 为其他对象提供一种代理以控制对这个对象的访问 二.代理模式的结构说明： Proxy：代理对象，实现与具体的目标对象一样的接口，并且保存一个指向目标对象的引用，可以在需要的时候调用具体的目标对象。
时隔多年，这次我终于把动态代理的源码翻了个地儿朝天
博学谷狂野架构师的博客
02-15 417
本文内容整理自 博学谷狂野架构师 动态代理简介 ​ Proxy模式是常用的设计模式，其特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。 用户可以更加结构图，自己编码完成Proxy模式。这种实现称为静态代理。 ​ Java提供了java.lang.reflect.Proxy类与InvocationHandler接口，配合反射，可以实现动态代理。静态代理的代理类与代理操作，都是事先编码，运行过程种无法修改代理
Proxy-代理模式(转载 动态生成代理对象那块挺有意思)
正走向大牛的菜鸟
11-25 184
Java动态代理模式 1. 代理:一个角色代表别一个角色来完成某些特定的功能。 比如：生产商，中间商，客户这三者这间的关系 客户买产品并不直接与生产商打交道，也不用知道产品是如何产生的，客户只与中间商打交道，而中间商就可以对产品进行一些包装，提供一些售后的服务。 代理模式有三个角色: 1. 抽象主题角色 2. 代理主题角色 3. 实际被代理角色 其它类通过访问代理主题角色来访问实际被代理角色。...
vue3+ts中对getCurrentInstance的使用
weixin_47239456的博客
08-15 1495
vue3+ts中对getCurrentInstance的使用
Proxy动态代理应用、源码分析
dhfzhishi的专栏
03-23 394
注：1、Java的动态代理是基于接口的，如果类未实现接口是不能进行代理的，需要使用CGlib方式。前言代理是java中非常重要的一种设计模式 ,动态代理则是是一种代理模式的最佳实践,本文将由浅及深的介绍动态代理及其proxy源码分析,文章写的不一定都对,请各位看官带着批判的态度阅读此文章.代理模式是设计模式中的一种,而且在实际的开发中使用的频率非常高 ,比如spring AOP,mybatis代理...
【设计模式】Iterator迭代器设计模式(容器和容器的遍历)
程序猿之洞
02-24 1815
在遍历容器元素的时候，有很多初学者在疑惑，为什么返回一个iterator我就能够去遍历这个容器了呢？ 今天我们就来深入剖析一下迭代器iterator的设计模式(循序渐进的剖析，一定要耐心看完) iterator是"四人帮"所定义的23种设计模式之一(不太难，也不是非常重要，只是在遍历容器的时候能够用到) 首先需要读这个总结的同志掌握面向对象的思想。 1.我们先自己写一个可以
【设计模式】Object Oriented面向对象思想剖析
程序猿之洞
02-14 1522
OO思维(Object Oriented以对象为方向) 这里以"老张开车去东北"为例子。 创建一个ThinkInOO的工程： 先来看看小明的非面向对象思维的工程: package cn.edu.ThinkInOO; public class Test1 { public static void main(String[] args) { System.ou
【设计模式】责任链4-链接链
程序猿之洞
03-27 1465
紧接着上一个问题来： 为了不要跟原来的代码冲突，又新建了一个工程，将所有代码放在一起。 代码清单：(为了测试简洁，去掉了FaceFilter.java) Filter.java FilterChain.java HTMLFilter.java Main.java MsgProcessor.java Request.java Response.java SesitiveFil
【设计模式】面向对象作业-超级母牛的故事
程序猿之洞
02-14 1447
留的作业: 农场一头小母牛， 每年生头小母牛， 母牛五岁产母牛， 二十年上多少牛？ 马老师给的这个问题我个人感觉不太好理解，就按照我自己的理解吧，我把题目给白话文一下: 农场中引进一只超级母体牛，它每年都可以生一只普通小牛，而它生下的普通小牛到5岁的时候会 生下一只普通小牛，以后就不会再生。问这个农场20年后有多少只牛(包括超级母牛)？ 分析问题，这是一个群
【设计模式】责任链3-横刀植入
程序猿之洞
03-27 1342
紧接着上一篇的开始： 我们来说说普遍的解决方案，我们用一个类来模拟： 这个类模拟一个够过滤器链条： package cn.edu.hpu.responsibility; import java.util.List; import java.util.ArrayList; public class FilterChain { List filters=new ArrayList();
【设计模式】Iterator设计作业-设计LinkedList的iterator
程序猿之洞
02-24 1277
完成了上次迭代器设计的作业:http://blog.csdn.net/acmman/article/details/43920153 LinkedList也需要写一个iterator方法，返回一个实现了Iterator的对象。该如何写？ LinkedList.java: package cn.edu.hpu.iterator; public class LinkedList imple
【设计模式】动态代理Proxy_01
程序猿之洞
07-10 1218
大家都知道设计模式中一个比较难理解的模式--动态代理模式，下面我们来通过一步一步完善一个工程来学习动态代理。 首先我们创建一个JavaProject，名字为"ProxyTest"。 创建一个类Tank.java，是一个坦克类，然后我们创建一个接口Moveable.java Moveable.java: package cn.edu.hpu.proxy; public in
【动态代理】动态代理Proxy_04
程序猿之洞
07-10 1190
我们继续上一篇总结。 上篇我们说到，怎么让before()和after()中的内容也让客户灵活指定？ 不管怎么样，我们现在需要一个这样的东西:可以动态指定对方法进行处理的指令。 我们创建一个方法调用的处理器，用来对任意方法进行自定义的处理: package cn.edu.hpu.proxy; import java.lang.reflect.Method; //方法调用的处
【设计模式】策略模式Strategy_03
程序猿之洞
06-25 1042
接着上一篇总结继续探讨。 我们之前用自己的方式来实现了JDK的Comparable和Comparator接口，我们下面来看看实际当中JDK给我们的Comparable和Comparator接口。 我们对之前的Dog和Dog的比较类DogWeightComparator的实现进行修改： Dog.java: package cn.edu.hpu.Strategy; public clas
java动态代理设计模式
最新发布
04-12
Java动态代理是一种设计模式，它允许在运行时创建代理类和代理对象，以实现对目标对象的间接访问和控制。动态代理可以在不修改目标对象的情况下，为其添加额外的功能或行为。 Java动态代理主要涉及两个核心类：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

光仔December

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值