如何实现接口防抖功能，杜绝重复提交

已于 2024-06-16 17:56:44 修改
阅读量335 收藏 4
点赞数 4
分类专栏： Spring Boot 文章标签： 接口防抖解决方案
于 2024-06-16 17:56:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43759352/article/details/139723719
版权

文章目录

前言

作为一名老码农，在开发后端Java业务系统，包括各种管理后台和小程序等。在这些项目中，我设计过单/多租户体系系统，对接过许多开放平台，也搞过消息中心这类较为复杂的应用，但幸运的是，我至今还没有遇到过线上系统由于代码崩溃导致资损的情况。

这其中的原因有三点：

一是业务系统本身并不复杂；

二是我一直遵循某大厂代码规约，在开发过程中尽可能按规约编写代码；

三是经过多年的开发经验积累，我成为了一名熟练工，掌握了一些实用的技巧；

啥是防抖

所谓防抖，一是防用户手抖，二是防网络抖动。在Web系统中，表单提交是一个非常常见的功能，如果不加控制，容易因为用户的误操作或网络延迟导致同一请求被发送多次，进而生成重复的数据记录。要针对用户的误操作，前端通常会实现按钮的loading状态，阻止用户进行多次点击。而对于网络波动造成的请求重发问题，仅靠前端是不行的。为此，后端也应实施相应的防抖逻辑，确保在网络波动的情况下不会接收并处理同一请求多次。

一个理想的防抖组件或机制，我觉得应该具备以下特点：

  • 逻辑正确，也就是不能误判；
  • 响应迅速，不能太慢；
  • 易于集成，逻辑与业务解耦；
  • 良好的用户反馈机制，比如提示“您点击的太快了”；

思路解析

前面讲了那么多，我们已经知道接口的防抖是很有必要的了，但是在开发之前，我们需要捋清楚几个问题。

哪一类接口需要防抖?

接口防抖也不是每个接口都需要加，一般需要加防抖的接口有这几类：

  • 用户输入类接口：比如搜索框输入、表单输入等，用户输入往往会频繁触发接口请求，但是每次触发并不一定需要立即发送请求，可以等待用户完成输入一段时间后再发送请求。
  • 按钮点击类接口：比如提交表单、保存设置等，用户可能会频繁点击按钮，但是每次点击并不一定需要立即发送请求，可以等待用户停止点击一段时间后再发送请求。
  • 滚动加载类接口：比如下拉刷新、上拉加载更多等，用户可能在滚动过程中频繁触发接口请求，但是每次触发并不一定需要立即发送请求，可以等待用户停止滚动一段时间后再发送请求。
如何确定接口是重复的？

防抖也即防重复提交，那么如何确定两次接口就是重复的呢？首先，我们需要给这两次接口的调用加一个时间间隔，大于这个时间间隔的一定不是重复提交；其次，两次请求提交的参数比对，不一定要全部参数，选择标识性强的参数即可；最后，如果想做的更好一点，还可以加一个请求地址的对比。

分布式部署下如何做接口防抖？

有两个方案：

使用共享缓存

流程图如下：

使用分布式锁

流程图如下：

常见的分布式组件有Redis、Zookeeper等，但结合实际业务来看，一般都会选择Redis，因为Redis一般都是Web系统必备的组件，不需要额外搭建。

具体实现

现在有一个保存用户的接口：

@PostMapping("/add")  
@RequiresPermissions(value = "add")  
@Log(methodDesc = "添加用户")  
public ResponseEntity<String> add(@RequestBody AddReq addReq) {  
        return userService.add(addReq);  
}

AddReq.java

import java.util.List;  
import lombok.Data;  
@Data
public class AddReq {  
    /**     * 用户名称     */    private String userName;  
    /**     * 用户手机号     */    private String userPhone;  
    /**     * 角色ID列表     */    private List<Long> roleIdList;
}

目前数据库表中没有对userPhone字段做UK索引，这就会导致每调用一次add就会创建一个用户，即使userPhone相同。

请求锁

根据上面的要求，我定了一个注解 @RequestLock ，使用方式很简单，把这个注解打在接口方法上即可。

RequestLock.java

import java.util.List;   
import lombok.Data;  
  
@Data  
public class AddReq {  
  
    /**  
     * 用户名称  
     */  
    private String userName;  
  
    /**  
     * 用户手机号  
     */  
    private String userPhone;  
  
    /**  
     * 角色ID列表  
     */  
    private List<Long> roleIdList;  
}

@RequestLock注解定义了几个基础的属性，redis锁前缀、redis锁时间、redis锁时间单位、key分隔符。其中前面三个参数比较好理解，都是一个锁的基本信息。key分隔符是用来将多个参数合并在一起的，比如userName是张三，userPhone是123456，那么完整的key就是"张三&123456"，最后再加上redis锁前缀，就组成了一个唯一key。

唯一key生成

这里有些同学可能就要说了，直接拿参数来生成key不就行了吗？额，不是不行，但我想问一个问题：如果这个接口是文章发布的接口，你也打算把内容当做key吗？要知道，Redis的效率跟key的大小息息相关。所以，我的建议是选取合适的字段作为key就行了，没必要全都加上 。

要做到参数可选，那么用注解的方式最好了，注解如下：

RequestKeyParam.java

import java.lang.annotation.*;  
  
/**  
 * @description 加上这个注解可以将参数设置为key  
 */  
@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Inherited  
public @interface RequestKeyParam {  
  
}

注：这个注解加到参数上就行，没有多余的属性。

接下来就是lockKey的生成了，代码如下:

RequestKeyGenerator.java

import java.lang.annotation.Annotation;  
import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
import java.lang.reflect.Parameter;  
  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.reflect.MethodSignature;  
import org.springframework.util.ReflectionUtils;  
import org.springframework.util.StringUtils;  
  
public class RequestKeyGenerator {  
    /**  
     * 获取LockKey  
     *  
     * @param joinPoint 切入点  
     * @return  
     */  
    public static String getLockKey(ProceedingJoinPoint joinPoint) {  
        //获取连接点的方法签名对象  
        MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();  
        //Method对象  
        Method method = methodSignature.getMethod();  
        //获取Method对象上的注解对象  
        RequestLock requestLock = method.getAnnotation(RequestLock.class);  
        //获取方法参数  
        final Object[] args = joinPoint.getArgs();  
        //获取Method对象上所有的注解  
        final Parameter[] parameters = method.getParameters();  
        StringBuilder sb = new StringBuilder();  
        for (int i = 0; i < parameters.length; i++) {  
            final RequestKeyParam keyParam = parameters[i].getAnnotation(RequestKeyParam.class);  
            //如果属性不是RequestKeyParam注解，则不处理  
            if (keyParam == null) {  
                continue;  
            }  
            //如果属性是RequestKeyParam注解，则拼接 连接符 "& + RequestKeyParam"  
            sb.append(requestLock.delimiter()).append(args[i]);  
        }  
        //如果方法上没有加RequestKeyParam注解  
        if (StringUtils.isEmpty(sb.toString())) {  
            //获取方法上的多个注解（为什么是两层数组：因为第二层数组是只有一个元素的数组）  
            final Annotation[][] parameterAnnotations = method.getParameterAnnotations();  
            //循环注解  
            for (int i = 0; i < parameterAnnotations.length; i++) {  
                final Object object = args[i];  
                //获取注解类中所有的属性字段  
                final Field[] fields = object.getClass().getDeclaredFields();  
                for (Field field : fields) {  
                    //判断字段上是否有RequestKeyParam注解  
                    final RequestKeyParam annotation = field.getAnnotation(RequestKeyParam.class);  
                    //如果没有，跳过  
                    if (annotation == null) {  
                        continue;  
                    }  
                    //如果有，设置Accessible为true（为true时可以使用反射访问私有变量，否则不能访问私有变量）  
                    field.setAccessible(true);  
                    //如果属性是RequestKeyParam注解，则拼接 连接符" & + RequestKeyParam"  
                    sb.append(requestLock.delimiter()).append(ReflectionUtils.getField(field, object));  
                }  
            }  
        }  
        //返回指定前缀的key  
        return requestLock.prefix() + sb;  
    }  
}

注：由于@RequestKeyParam可以放在方法的参数上，也可以放在对象的属性上，所以这里需要进行两次判断，一次是获取方法上的注解，一次是获取对象里面属性上的注解。

重复提交判断

Redis缓存方式

RedisRequestLockAspect.java

import java.lang.reflect.Method;  
import com.summo.demo.exception.biz.BizException;  
import com.summo.demo.model.response.ResponseCodeEnum;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.reflect.MethodSignature;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.core.annotation.Order;  
import org.springframework.data.redis.connection.RedisStringCommands;  
import org.springframework.data.redis.core.RedisCallback;  
import org.springframework.data.redis.core.StringRedisTemplate;  
import org.springframework.data.redis.core.types.Expiration;  
import org.springframework.util.StringUtils;  
  
/**  
 * @description 缓存实现  
 */  
@Aspect  
@Configuration  
@Order(2)  
public class RedisRequestLockAspect {  
  
    private final StringRedisTemplate stringRedisTemplate;  
  
    @Autowired  
    public RedisRequestLockAspect(StringRedisTemplate stringRedisTemplate) {  
        this.stringRedisTemplate = stringRedisTemplate;  
    }  
  
    @Around("execution(public * * (..)) && @annotation(com.summo.demo.config.requestlock.RequestLock)")  
    public Object interceptor(ProceedingJoinPoint joinPoint) {  
        MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();  
        Method method = methodSignature.getMethod();  
        RequestLock requestLock = method.getAnnotation(RequestLock.class);  
        if (StringUtils.isEmpty(requestLock.prefix())) {  
            throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "重复提交前缀不能为空");  
        }  
        //获取自定义key  
        final String lockKey = RequestKeyGenerator.getLockKey(joinPoint);  
        // 使用RedisCallback接口执行set命令，设置锁键；设置额外选项：过期时间和SET_IF_ABSENT选项  
        final Boolean success = stringRedisTemplate.execute(  
            (RedisCallback<Boolean>)connection -> connection.set(lockKey.getBytes(), new byte[0],  
                Expiration.from(requestLock.expire(), requestLock.timeUnit()),  
                RedisStringCommands.SetOption.SET_IF_ABSENT));  
        if (!success) {  
            throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");  
        }  
        try {  
            return joinPoint.proceed();  
        } catch (Throwable throwable) {  
            throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "系统异常");  
        }  
    }  
}

这里的核心代码是stringRedisTemplate.execute里面的内容，正如注释里面说的“使用RedisCallback接口执行set命令，设置锁键；设置额外选项：过期时间和SET_IF_ABSENT选项”，有些同学可能不太清楚SET_IF_ABSENT 是个啥,这里我解释一下： SET_IF_ABSENT 是RedisStringCommands.SetOption 枚举类中的一个选项，用于在执行 SET命令时设置键值对的时候，如果键不存在则进行设置，如果键已经存在，则不进行设置。

Redisson分布式方式

Redisson分布式需要一个额外依赖，引入方式：

<dependency>  
    <groupId>org.redisson</groupId>  
    <artifactId>redisson-spring-boot-starter</artifactId>  
    <version>3.10.6</version>  
</dependency>

由于我之前的代码有一个RedisConfig，引入Redisson之后也需要单独配置一下，不然会和RedisConfig冲突

RedissonConfig.java

import org.redisson.Redisson;  
import org.redisson.api.RedissonClient;  
import org.redisson.config.Config;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
public class RedissonConfig {  
  
    @Bean  
    public RedissonClient redissonClient() {  
        Config config = new Config();  
        // 这里假设你使用单节点的Redis服务器  
        config.useSingleServer()  
            // 使用与Spring Data Redis相同的地址  
            .setAddress("redis://127.0.0.1:6379");  
        // 如果有密码  
        //.setPassword("xxxx");  
        // 其他配置参数  
        //.setDatabase(0)  
        //.setConnectionPoolSize(10)  
        //.setConnectionMinimumIdleSize(2);  
        // 创建RedissonClient实例  
        return Redisson.create(config);  
    }  
}

配好之后，核心代码如下:

RedissonRequestLockAspect.java

import java.lang.reflect.Method;  
import com.summo.demo.exception.biz.BizException;  
import com.summo.demo.model.response.ResponseCodeEnum;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.reflect.MethodSignature;  
import org.redisson.api.RLock;  
import org.redisson.api.RedissonClient;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.core.annotation.Order;  
import org.springframework.util.StringUtils;  
  
/**  
 * @description 分布式锁实现  
 */  
@Aspect  
@Configuration  
@Order(2)  
public class RedissonRequestLockAspect {  
    private RedissonClient redissonClient;  
  
    @Autowired  
    public RedissonRequestLockAspect(RedissonClient redissonClient) {  
        this.redissonClient = redissonClient;  
    }  
  
    @Around("execution(public * * (..)) && @annotation(com.summo.demo.config.requestlock.RequestLock)")  
    public Object interceptor(ProceedingJoinPoint joinPoint) {  
        MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();  
        Method method = methodSignature.getMethod();  
        RequestLock requestLock = method.getAnnotation(RequestLock.class);  
        if (StringUtils.isEmpty(requestLock.prefix())) {  
            throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "重复提交前缀不能为空");  
        }  
        //获取自定义key  
        final String lockKey = RequestKeyGenerator.getLockKey(joinPoint);  
        // 使用Redisson分布式锁的方式判断是否重复提交  
        RLock lock = redissonClient.getLock(lockKey);  
        boolean isLocked = false;  
        try {  
            //尝试抢占锁  
            isLocked = lock.tryLock();  
            //没有拿到锁说明已经有了请求了  
            if (!isLocked) {  
                throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");  
            }  
            //拿到锁后设置过期时间  
            lock.lock(requestLock.expire(), requestLock.timeUnit());  
            try {  
                return joinPoint.proceed();  
            } catch (Throwable throwable) {  
                throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "系统异常");  
            }  
        } catch (Exception e) {  
            throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");  
        } finally {  
            //释放锁  
            if (isLocked && lock.isHeldByCurrentThread()) {  
                lock.unlock();  
            }  
        }  
  
    }  
}

Redisson的核心思路就是抢锁，当一次请求抢到锁之后，对锁加一个过期时间，在这个时间段内重复的请求是无法获得这个锁，也不难理解。

测试验证

第一次提交，“添加用户成功”

短时间内重复提交，“BIZ-0001:您的操作太快了,请稍后重试”

过几秒后再次提交，“添加用户成功”

来源: juejin.cn/post/7308992638468227109

小小Java开发者
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Springboot实现防重复提交和防重复点击（附源码），java数据结构和算法面试题及答案
m0_60607289的博客
03-22 572
无论是哪家公司，都很重视基础，大厂更加重视技术的深度和广度，面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。针对以上面试技术点，我在这里也做一些分享，希望能更好的帮助到大家。无论是哪家公司，都很重视基础，大厂更加重视技术的深度和广度，面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。
防止Layui form表单重复提交的实现方法
10-16
今天小编就为大家分享一篇防止Layui form表单重复提交的实现方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
后端接口防抖实现
qq_43513370的博客
02-19 381
通过aop实现接口一段时间内的重复性访问。
SpringBoot防止重复请求，重复表单提交超级简单的注解实现之三（升级版1）
热门推荐
猿份哥
05-31 1万+
1. 注解接口  /** * @description 防止表单重复提交注解 */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Documented public @interface DuplicateSubmitToken { //保存重复提交标记 默认为需要保存 boolean sav...
《优化接口设计的思路》系列：第六篇—接口防抖(防重复提交)的一些方式
summon的博客
12-05 1870
大家好！我是sum墨，一个一线的底层码农，平时喜欢研究和思考一些技术相关的问题并整理成文，限于本人水平，如果文章和代码有表述不当之处，还请不吝赐教。作为一名从业已达六年的老码农，我的工作主要是开发后端Java业务系统，包括各种管理后台和小程序等。在这些项目中，我设计过单/多租户体系系统，对接过许多开放平台，也搞过消息中心这类较为复杂的应用，但幸运的是，我至今还没有遇到过线上系统由于代码崩溃导致资损的情况。这其中的原因有三点：一是业务系统本身并不复杂；
springboot实现全局api幂等（后端实现防抖功能）
m0_63410831的博客
02-07 866
用户在实际操作中，有可能因为手抖或者网络波动，短时间内将一个相同的请求重复提交多次。系统也会多次执行这些请求，就有可能会出现一些问题。例如创建新用户功能：我们一般会先验证用户名是否已存在，再去insert用户信息。但由于用户手抖，极短的时间点了两次提交按钮。前端没防住的情况下两个相同参数的请求几乎同时到达了后端。两个请求由于间隔时间太短，验证用户名是否存在的时候都成功了，于是数据库insert了两条除id外，其余字段都相同的数据。这可能会对以后的业务造成意料之外的影响。对于这种情况，我们有很我们有很多解决方
提交以后禁用按钮一段时间，防止重复提交
02-21
提交以后禁用按钮一段时间，防止重复提交 使用 v-noMoreClick
WEB 前端开发中防治重复提交的实现方法
01-19
而前端的防治重复提交至少很有效的防治了人为正常操作下的很多不必要麻烦。下面就来讲讲如何有效避免前端的表单重复提交 表单提交有以下几种方式： <form name=”form” method=”post” action=”#> <...
使用定时器实现按键防抖的源代码
05-11
使用定时器实现按键防抖的源代码
防止用户重复提交表单的方法和组件.rar
01-09
好友使用vue技术封装了一个专门用于提交表单和下载文件的“防抖按钮”，其实现原理和使用方法看这里 https://blog.csdn.net/PursueExcellence/article/details/103903139。
接口优化思路 - 接口防抖
GeGe&YoYo的博客
12-12 1241
在Web系统中，表单提交是一个非常常见的功能，如果不加控制，容易因为用户的误操作或网络延迟导致同一请求被发送多次，进而生成重复的数据记录。要针对用户的误操作，前端通常会实现按钮的loading状态，阻止用户进行多次点击。而对于网络波动造成的请求重发问题，仅靠前端是不行的。为此，后端也应实施相应的防抖逻辑，确保在网络波动的情况下不会接收并处理同一请求多次。接口防抖也不是每个接口都需要加，一般需要加防抖的接口有这几类：比如搜索框输入、表单输入等，用户输入往往会频繁触发接口请求，但是每次触发并不一定需要立即发送请
防抖、防止频繁请求(重复提交相同数据)
总结分享
03-12 3278
这篇文章将介绍如何在 `java `中`不依赖数据库`完成防抖、防止重复提交相同数据
接口如何设置节流与防抖（前后端）
Reische的博客
11-14 890
接口幂等性是指在分布式系统中，对于相同的请求，无论请求多少次，都应该返回相同的结果。这意味着，如果请求已经处理完毕，那么重复请求应该返回相同的响应，而不应该产生额外的副作用。这种特性对于确保系统的稳定性和一致性非常重要，尤其是在处理并发请求和网络异常的情况下。在编程中，可以通过一些特定的设计来实现接口幂等性，例如使用全局唯一的ID来标记请求，或者使用乐观锁机制来防止重复处理等。防抖（Debouncing）是一种在前端开发中常用的技术，主要用于减少不必要的频繁操作，提高性能和用户体验。
前端接口防止重复请求实现方案
最新发布
muzidigbig的博客
03-15 1120
虽然大部分的接口处理我们都是加了的，但又不能确保真的是每个接口都加了的，可是如果要一个接口一个接口的排查，那这维护了四五年的系统，成百上千的接口肯定要耗费非常多的精力，根本就是不现实的，所以就只能去做。
Java自定义拦截器处理防抖
YXWik的博客
10-21 910
拦截器处理防抖
真实场景1：如何防止接口重复提交？幂等性问题+解决方案
竹林幽深
08-28 1197
之所以把获取请求唯一ID的生成规则放在后端，好处就是生成规则可以自己定义，也并不一定要用uuid来生成，也可以用雪花算法，或者自己设计一套计算规则，保证当前业务提交时请求ID是唯一的，比如事先生成唯一的订单号，作为请求唯一ID，然后再提交，规则放在后端来生成，会更加灵活！接口的幂等性实际上就是接口可重复调用，在调用方多次调用的情况下，接口最终得到的结果是一致的。有些接口可以天然的实现幂等性，比如查询接口，对于查询来说，查询一次和两次，对于系统来说，没有任何影响，查出的结果也是一样。
前端基础：防抖与节流
郭宇的博客
06-27 2060
防抖闭包
消灭前端闪烁魔鬼：Vue中的防抖术
前端全栈大佬
11-18 4319
本文将深入研究Vue中的防抖动技术。我们将首先介绍什么是防抖动，以及它在前端开发中的重要性。然后，我们将详细讨论Vue中如何实现防抖动，以及在实际项目中如何应用这一技术来优化用户体验。
SpringBoot项目防止重复提交表单（防抖机制）插件
u011584350的博客
09-27 1475
基于SpringBoot的后端防抖插件
如何在.net6 中实现接口的防抖
05-27
在.NET 6中，可以使用`System....在`MyClass`类中，使用了`DebounceProxy`类来实现接口的防抖功能。在`OnEvent`方法中，调用`_debounce.Debounce()`方法，将事件的调用委托给`DebounceProxy`类的实例，以实现防抖功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小小Java开发者

“是一种鼓励，你懂的”

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

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

打赏作者

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

抵扣说明：

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

余额充值