【深入理解MyBatis】- 03Mybatis 从0开始实现Mybatis 插件（plugins）功能

最新推荐文章于 2023-10-19 15:51:16 发布
最新推荐文章于 2023-10-19 15:51:16 发布
阅读量198 收藏
点赞数
分类专栏： 深入理解MyBatis
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/107094023
版权

Mybatis 插件（plugins）简介

Mybatis 插件像是个拦截器，本质上是JDK动态代理的封装，返回了代理对象，起到了拦截器作用，接下来将按照从0开始实现Mybatis 插件（plugins）功能，再使用一下Mybatis插件应用一下，这里实现并不是与Mybatis Plugin代码一模一样，有一些简化和优化，更加方便理解

简单版拦截器功能 v0.1

定义拦截器

public interface Interceptor {
	 Object intercept(Object target, Method method, Object[] args) throws Throwable;
}

通用动态代理实现

public class Plugin implements InvocationHandler {
	
	private final Object target;
	private final Interceptor interceptor;
	
	public Plugin(Object target, Interceptor interceptor) {
		this.target = target;
		this.interceptor = interceptor;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		return interceptor.intercept(target, method, args);
	}
}

封装生成代理类工具类

public class PluginUtils {
	public static <T> T wrap(T target, Interceptor interceptor) {
		return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
				new Plugin(target, interceptor));
	}
}

编写业务测试类

public interface IPerson {
	String sayHello(String name);
	void test();
}

public class PersonImpl implements IPerson {
	@Override
	public String sayHello(String name) {
		String msg = "hello, " + name;
		System.out.println(msg);
		return msg;
	}
	
	@Override
	public void test() {
		System.out.println("test");
	}
}

测试类

实现自定义拦截器

public class MyInterceptor implements Interceptor {
	@Override
	public Object intercept(Object target, Method method, Object[] args) throws Throwable {
		System.out.println("before.");
		Object invoke = method.invoke(target, args);
		System.out.println("after.");
		return invoke;
	}
}

测试类

public class MyTest {
	public static void main(String[] args) {
		Interceptor interceptor = new MyInterceptor();
		IPerson person = new PersonImpl();
		IPerson personProxy = PluginUtils.wrap(person, interceptor);
		String message = personProxy.sayHello("zhangsan");
		System.out.println("return: " + message);
	}
}

测试结果，拦截成功

before.
hello, zhangsan
after.
return: hello, zhangsan

实现注解功能 v0.2

拦截器注解@Intercepts

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Intercepts {
	Signature[] value();
}

标记拦截哪些类注解@Signature

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface Signature {
	Class<?> type();

	SignatureMethod[] method();
}

标记拦截哪些方法注解@SignatureMethod

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface SignatureMethod {
	String method();

	Class<?>[] args();
}

优化代理生成工具类，添加解析注解信息并传入给Plugin类

public class PluginUtils {
	public static <T> T wrap(T target, Interceptor interceptor) {
		Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
		return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
				new Plugin(target, interceptor, signatureMap));
	}
	
	// 解析注解，获取对应的类和方法
	private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
		Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
		if (interceptsAnnotation == null) {
			throw new RuntimeException(
					"No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
		}
		
		Signature[] sigs = interceptsAnnotation.value();
		Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
		for (Signature sig : sigs) {
			Set<Method> methods = signatureMap.get(sig.type());
			if (methods == null) {
				methods = new HashSet<Method>();
				signatureMap.put(sig.type(), methods);
			}

			SignatureMethod[] signatureMethod = sig.method();
			for (int i = 0; i < signatureMethod.length; i++) {
				try {
					Method method = sig.type().getMethod(signatureMethod[i].method(), signatureMethod[i].args());
					methods.add(method);
				} catch (NoSuchMethodException e) {
					throw new RuntimeException(
							"Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
				}
			}
		}
		return signatureMap;
	}
}

优化自定义拦截器，对方法进行控制，只拦截注解对应的方法

public class Plugin implements InvocationHandler {
	private final Object target;
	private final Interceptor interceptor;
	private final Map<Class<?>, Set<Method>> signatureMap;

	public Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
		this.target = target;
		this.interceptor = interceptor;
		this.signatureMap = signatureMap;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Set<Method> methods = signatureMap.get(method.getDeclaringClass());
		if (methods != null && methods.contains(method)) {
			return interceptor.intercept(target, method, args);
		}
		return method.invoke(target, args);
	}
}

测试类

实现自定义拦截器

@Intercepts({
		@Signature(type = IPerson.class, method = { 
				@SignatureMethod(method = "sayHello", args = { String.class }) }) })
public class MyInterceptor3 implements Interceptor {
	@Override
	public Object intercept(Object target, Method method, Object[] args) throws Throwable {
		System.out.println("3333.");
		Object invoke = method.invoke(target, args);
		return invoke;
	}
}

测试类

public class MyTest {
	public static void main(String[] args) {
		Interceptor interceptor = new MyInterceptor3();
		IPerson person = new PersonImpl();
		IPerson personProxy = PluginUtils.wrap(person, interceptor);
		String message = personProxy.sayHello("zhangsan");
		System.out.println("return: " + message);
	}
}

测试结果，拦截成功

3333.
hello, zhangsan
return: hello, zhangsan

修改拦截器自定义拦截器，改为@SignatureMethod(method = "toString", args = {})

@Intercepts({
		@Signature(type = IPerson.class, method = { 
				@SignatureMethod(method = "test", args = {}) }) })
public class MyInterceptor3 implements Interceptor {
	@Override
	public Object intercept(Object target, Method method, Object[] args) throws Throwable {
		System.out.println("3333.");
		Object invoke = method.invoke(target, args);
		return invoke;
	}
}

执行测试类

public class MyTest3 {

	public static void main(String[] args) {
		Interceptor interceptor = new MyInterceptor3();
		IPerson person = new PersonImpl();
		IPerson personProxy = PluginUtils.wrap(person, interceptor);
		String message = personProxy.sayHello("zhangsan");
		System.out.println("return: " + message);
		personProxy.test();
	}
}

测试结果，可以看出，只代理了test方法，没有代理sayHello

hello, zhangsan
return: hello, zhangsan
3333.
test

若想代理，需要修改注解，再次执行测试类即可

@Intercepts({
		@Signature(type = IPerson.class, method = { 
				@SignatureMethod(method = "sayHello", args = { String.class }),
				@SignatureMethod(method = "test", args = { }) }) })

拦截器链实现 v0.3

链式封装

public class InterceptorChain {

	private final List<Interceptor> interceptors = new ArrayList<>();

	public Object wrapAll(Object target) {
		for (Interceptor interceptor : interceptors) {
			target = PluginUtils.wrap(target, interceptor);
		}
		return target;
	}

	public void addInterceptor(Interceptor interceptor) {
		interceptors.add(interceptor);
	}
}

添加实现自定义拦截器

@Intercepts({
		@Signature(type = IPerson.class, method = { 
				@SignatureMethod(method = "sayHello", args = { String.class }) }) })
public class MyInterceptor3 implements Interceptor {
	@Override
	public Object intercept(Object target, Method method, Object[] args) throws Throwable {
		System.out.println("3333.");
		Object invoke = method.invoke(target, args);
		return invoke;
	}
}
@Intercepts({
		@Signature(type = IPerson.class, method = { 
				@SignatureMethod(method = "sayHello", args = { String.class }) }) })
public class MyInterceptor4 implements Interceptor {
	@Override
	public Object intercept(Object target, Method method, Object[] args) throws Throwable {
		System.out.println("4444.");
		Object invoke = method.invoke(target, args);
		return invoke;
	}
}
@Intercepts({
		@Signature(type = IPerson.class, method = { 
				@SignatureMethod(method = "sayHello", args = { String.class }) }) })
public class MyInterceptor5 implements Interceptor {
	@Override
	public Object intercept(Object target, Method method, Object[] args) throws Throwable {
		System.out.println("5555.");
		Object invoke = method.invoke(target, args);
		return invoke;
	}
}

测试类

public class MyTest2 {
	public static void main(String[] args) {
		InterceptorChain chain = new InterceptorChain();
		chain.addInterceptor(new MyInterceptor3());
		chain.addInterceptor(new MyInterceptor4());
		chain.addInterceptor(new MyInterceptor5());
		IPerson person = new PersonImpl();
		IPerson personProxy = (IPerson) chain.wrapAll(person);
		String message = personProxy.sayHello("zhangsan");
		System.out.println("return: " + message);
	}
}

测试结果，多拦截器效果

5555.
4444.
3333.
hello, zhangsan
return: hello, zhangsan

可以思考一下为什么倒序输出5555. 4444. 3333. ？

拦截器链实现 v0.4

封装一下拦截器Interceptor的参数

public class Invocation {

  private final Object target;
  private final Method method;
  private final Object[] args;

  public Invocation(Object target, Method method, Object[] args) {
    this.target = target;
    this.method = method;
    this.args = args;
  }

  public Object getTarget() {
    return target;
  }

  public Method getMethod() {
    return method;
  }

  public Object[] getArgs() {
    return args;
  }

  public Object proceed() throws InvocationTargetException, IllegalAccessException {
    return method.invoke(target, args);
  }

}

修改拦截器Interceptor参数

public interface Interceptor {
	 Object intercept(Invocation invocation) throws Throwable;
}

插件Plugin封装修改return interceptor.intercept(new Invocation(target, method, args));

public class Plugin implements InvocationHandler {
	private final Object target;
	private final Interceptor interceptor;
	private final Map<Class<?>, Set<Method>> signatureMap;

	public Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
		this.target = target;
		this.interceptor = interceptor;
		this.signatureMap = signatureMap;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Set<Method> methods = signatureMap.get(method.getDeclaringClass());
		if (methods != null && methods.contains(method)) {
			return interceptor.intercept(new Invocation(target, method, args));
		}
		return method.invoke(target, args);
	}
}

修改自定义拦截器实现Object invoke = invocation.proceed();

@Intercepts({
		@Signature(type = IPerson.class, method = { 
				@SignatureMethod(method = "sayHello", args = { String.class }) }) })
public class MyInterceptor3 implements Interceptor {
	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		System.out.println("3333.");
		Object invoke = invocation.proceed();
		return invoke;
	}
}

测试类

	public static void main(String[] args) {
		Interceptor interceptor = new MyInterceptor3();
		IPerson person = new PersonImpl();
		IPerson personProxy = PluginUtils.wrap(person, interceptor);
		String message = personProxy.sayHello("zhangsan");
		System.out.println("return: " + message);
	}
}

测试类

3333.
hello, zhangsan
return: hello, zhangsan

接下来分析一下官网的使用

Mybatis官网插件（plugins）分析

MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

  • Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
  • ParameterHandler (getParameterObject, setParameters)
  • ResultSetHandler (handleResultSets, handleOutputParameters)
  • StatementHandler (prepare, parameterize, batch, update, query)

所有我们注册的类只能是上面的四个接口，ExamplePlugin.java拦截器例子

@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})
public class ExamplePlugin implements Interceptor {
  private Properties properties = new Properties();
  public Object intercept(Invocation invocation) throws Throwable {
    // implement pre processing if need， 拦截前
    Object returnObject = invocation.proceed();
    // implement post processing if need， 拦截后
    return returnObject;
  }
  public void setProperties(Properties properties) {
    this.properties = properties;
  }
}

那么从源代码实现来看，为什么Mybatis plugins功能只支持以前四个接口呢，我们可以从类org.apache.ibatis.session.Configuration中明白

  • Executor，这个一个获取Executor的方法，其他的代码可以不用理解，只用查看最后两行代码即可，也就是获取到的Executor对象为代理对象
	public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
		executorType = executorType == null ? defaultExecutorType : executorType;
		executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
		Executor executor;
		if (ExecutorType.BATCH == executorType) {
			executor = new BatchExecutor(this, transaction);
		} else if (ExecutorType.REUSE == executorType) {
			executor = new ReuseExecutor(this, transaction);
		} else {
			executor = new SimpleExecutor(this, transaction);
		}
		if (cacheEnabled) {
			executor = new CachingExecutor(executor);
		}
		executor = (Executor) interceptorChain.pluginAll(executor);
		return executor;
	}
  • StatementHandler，这个一个获取StatementHandler的方法，其他的代码可以不用理解，只用查看最后两行代码即可，也就是获取到的StatementHandler对象为代理对象
	public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,
			Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
		StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject,
				rowBounds, resultHandler, boundSql);
		statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
		return statementHandler;
	}
  • ParameterHandler，这个一个获取ParameterHandler的方法，其他的代码可以不用理解，只用查看最后两行代码即可，也就是获取到的ParameterHandler对象为代理对象
	public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject,
			BoundSql boundSql) {
		ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement,
				parameterObject, boundSql);
		parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
		return parameterHandler;
	}
  • ResultSetHandler ，这个一个获取ResultSetHandler 的方法，其他的代码可以不用理解，只用查看最后两行代码即可，也就是获取到的ResultSetHandler 对象为代理对象
	public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds,
			ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {
		ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler,
				resultHandler, boundSql, rowBounds);
		resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
		return resultSetHandler;
	}

完整代码例子

  1. 执行命令从github上面拉取代码：git clone git@github.com:dengjili/mybatis-3-mybatis-3.4.6.git
  2. 相关代码目录
    src/test/java priv.mybatis.example03
    src/test/java priv.mybatis.example04
    src/test/java priv.mybatis.example05
dengjili
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringBoot】26、SpringBoot中整合MyBatis-Plus实现数据库操作
Asurplus
07-23 21万+
MyBatis 框架相信大家都用过，虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库，很是灵活。但正其操作都要通过 SQL 语句进行，就必须写大量的 xml 文件，很是麻烦。于是 MyBatis-Plus 应运而生，作为 MyBatis 的增强工具，更是为我们开发效率得到了质的飞跃。 一、简介 1、MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBa
Mybatis插件Plugin
weixin_30555753的博客
05-04 113
Mybatis开源Plugin中最熟知的pagehelper，重点made in China 很多人开始用pagehelper时候，肯定很纳闷，以mysql为例，明明没有加limit语句，为什么打印出来的sql中有了limit语句了，这是怎么回事？？？插件在什么地方给sql加上了limit，为什么又能修改写好的sql，只能从pagehelper的源码中找到疑惑的答案了。 @Intercep...
Mybatis插件原理
XZLABC12345的专栏
08-27 1314
Mybatis插件 概述 通过本篇的介绍，你会了解到： 1、插件开发前的准备 2、插件的接口和初始化 3、插件的设计与实现 4、插件的开发实例 5、总结 1 插件开发前准备 插件开发前，我们需要知道签名，插件接口，插件如何初始化、插件代理和反射、分离拦截对象常用工具等。 1.1确定签名 插件开发前，需要确定我们拦截的签名，而签名的确需要以下的两个因素 1.1.1 ...
Mybatis plugin 的使用及原理
战斧的博客
06-15 7341
上次，我们说过了mybatis+springboot时的启动与执行流程，也介绍过mybatis的执行器和缓存，今天，我们来看看mybatis 的另一个大功能 —— plugin。
MybatisPlugin实现及原理
zhangxm_qz的博客
03-28 7608
Plugins 简单理解为拦截器，既然是拦截器说白了一般都是动态代理来实现对目标方法的拦截，在前后做一些操作。 在mybatis将这种东西，称之为plugin，配置在mybatis-config.xml配置文件中，通过 标签配置。在mybatis中，可以被拦截的目标主要是： 1. StatementHandler; 2. ParameterHandler; 3. ResultSetHandler;...
Java 框架 Mybatis 中Plugins(插件)开发指南
tumu6889的博客
06-23 1539
mybatis.的 plugins
MyBatis 教程 - MyBatis插件（Plugins）开发
Ricky
02-17 3万+
MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括： Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) ParameterHandler (getParameterObject, setP
mybatis-dalgen:Mybatis-dalgen
05-14
更新 2016-03-23 (修复) DAO参数排序 DAO参数去重 简介 mybatis-maven-dalgen 源码 解决问题 mybatis-maven-dalgen 后续简称 dalgen,解决mybatis代码自动生成的缺失. 对比其他代码生成工具 *mybatis-generator-maven...
free-mybatis-plugin免费插件
最新发布
10-23
一款免费的idea插件，实现快速在dao层接口和xml方法之间进行切换，在Settings->plugins->install plugin from disk后选择该压缩包 安装重启idea即可
mybatis-3-config.dtd mybatis-3-mapper.dtd
11-19
MyBatis是一个流行的Java持久层框架，它简化了数据库操作，通过XML或注解的方式将SQL与Java代码绑定，提供了一种直接...通过对这些文件的分析和学习，开发者可以更深入地理解和掌握MyBatis的工作原理，提高开发效率。
拿来即用的MyBatis Plugin实现SQL语句结构动态新增/更改字段（线上运行中）
健身变秃，coding变强
04-13 3015
拿来即用的MyBatis Plugin实现SQL语句结构动态新增/更改字段（在实际链路追踪服务运行），项目将开源到GitHub
Mybatis框架源码笔记(八)之Plugin插件原理解析
最爱嫣夜来
03-15 627
引用一段官网的译文MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。这些类中方法的细节可以通过查看每个方法的签名来发现，或者直接查看 MyBatis 发行包中的源代码。如果你想做的不仅仅是监控方法的调用，那么你最好相当了解要重写的方法的行为。因为在试图修改或重写已有方法的行为时，很可能会破坏MyBatis 的核心模块。这些都是更底层的类和方法，所以使用插件的时候要特别当心。自定义插件的实现步骤大致如下：实现Mybatis框架的Interceptor接口。
Mybatis 插件（plugins）
雨后是冰雹
05-23 1976
Mybatis 插件一、Mybatis 插件介绍二、自定义一个插件1. 实现Interceptor接口2. 注册插件 一、Mybatis 插件介绍 MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括： Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) ParameterHandler (getPar
Mybatis Plugin插件
qq_37436172的博客
10-31 734
首先mybatisPlugin是针对于mybatis四大组件（Statementhandler、resultsethandler、parameterHandler、executor）做增强操作的。MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：通过 MyBatis 提供的强大机制，使用插件是非常简单的，只需实现 Interceptor 接口，并指定想要拦截的方法签名即可。以pageHlper拦截器为例。
mybatis-plugin插件执行原理
weixin_47367099的博客
10-19 373
今天主要是在看mybatis的主流程源码，其中比较感兴趣的是mybatis的plugin功能，这里主要记录下mybatis-plugin的插件功能原理。方法新建的代理对象中使用的InvocationHandler对象是Plugin本身，所以在执行方法的时候首先要调用它的。注解上的type、method、args属性去匹配，如果找到符合的，就会为对象创建代理对象，并返回代理对象。类似AOP，使用JDK动态代理，只不过mybatis的增强对象不是所有对象，而是上面陈列的4个对象而已。
Spring注解：AOP
weixin_44481891的博客
09-10 366
Spring注解（AOP）AOPAOP原理@EnableAspectJAutoProxy AOP AOP:面向切面编程，指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式，它的底层是动态代理。 AOP的实现步骤： 1.导入AOP模块spring-aspects 2.定义一个业务逻辑类 3.定义一个日志切面类，切面类里需要动态感知业务运行到哪里，然后执行。通知方法包括： 前置通知（@Before）：在目标方法运行之前运行 后置通知（@After）：在目标方法运行结束之后运行，不管方法正
Mybatis Plugins学习
m0_59164927的博客
10-19 203
mybatis plugin 是一种拦截机制，它允许在特定对象的方法执行之前进行拦截处理，来实现特定的处理功能。
Mybatis plugin
sinat_33822516的博客
07-31 319
在阅读Mybatis源码的时候,对Plugin这边进行了一部分梳理,接下来使用一个例子来说明Mybatis中Plugin的原理. /* 一个电影的Service,只有一个方法是watchMovie */ public interface MovieService { void watchMovie(); } public class MovieServiceImpl implements MovieService { @Override public void watchMov
IDEA Mybatis Plugin插件（方便在Dao接口和Mappper XML文件之间进行切换）
热门推荐
lichuangcsdn的博客
06-29 11万+
该插件主要是在mapper接口方法和mapper XML文件之间来回切换非常方便，极大的提高了开发效率在IDEA中搜索free Mybatis Plugin1、在工具栏有个图片。prefrence2、搜索如下：3、搜索到之后安装即可。安装完成后需要重启下IDEA4、安装成功后可以看到如下图标5、作用详细参见https://github.com/rockjava/intellij-mybatis-p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值