redis分布式锁以及自定义注解

最新推荐文章于 2023-10-10 16:21:17 发布
最新推荐文章于 2023-10-10 16:21:17 发布
阅读量464 收藏 2
点赞数
分类专栏： redis锁 文章标签： redis 分布式 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31259663/article/details/129830667
版权

1.同一个锁key，同一时间只能有一个客户端拿到锁，其他客户端会陷入无限的等待来尝试获取那个锁，只有获取到锁的客户端才能执行下面的业务逻辑。

2.引入依赖 aop redis 

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

这里基于自定义注解引入spring的spel表达式 类似于 

@Cacheable 缓存注解中参数

 

   <!--spel表达式-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
        </dependency>

3.具体锁业务方法

package org.xiaozhang.common.Lock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description:
 * @since 2023/3/27 17:30
 */
@Component
public class RedisLockService {
    private static Logger log = LoggerFactory.getLogger(RedisMutexAop.class);
    private static String UNLOCK_LUA;

    static {
        //如果存在删除返回true
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }

    private RedisTemplate redisTemplate;

    private RedisLockService(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * @param keyCode
     * @param keyValue
     * @param expire          key有效期
     * @param maxWaitLockTime 最大等待锁时间
     * @return
     */
    public boolean getLock(String keyCode, String keyValue, long expire, long maxWaitLockTime) {
        //最先开始时间
        long startTime = System.currentTimeMillis();
        return getLock(keyCode, keyValue, expire, startTime, maxWaitLockTime,0);
    }

    public boolean getLock(RedisMutexDo redisMutexDo) {
        //最先开始时间
        long startTime = System.currentTimeMillis();
        return getLock(redisMutexDo.getKeyCode(), redisMutexDo.getKeyValue(), Long.valueOf(redisMutexDo.getExprire()), startTime, Long.valueOf(redisMutexDo.getMaximumTime()),0);
    }

    /**
     * @param keyCode
     * @param keyValue
     * @param expire          key有效期
     * @param startTime       最先获取锁的开始时间戳(秒)
     * @param maxWaitLockTime 最大等待锁时间(秒)
     * @return
     */
    private boolean getLock(String keyCode, String keyValue, long expire, long startTime, long maxWaitLockTime,int executions) {
        log.info("当前线程:{}试图第{}次开始获取锁keyCode:{},keyValue:{}",Thread.currentThread().getName(),executions,keyCode,keyValue);
        //获取唯一互斥锁
        if (tryGetDistributedLock(keyCode, keyValue, expire)) {
            return true;
        } else {
            //等待时间超过n秒种直接返回
            long l = System.currentTimeMillis() - startTime;
            log.debug("{}等待时长为:{}",Thread.currentThread().getName(),l*0.001);
            if ((l)*0.001 > maxWaitLockTime) {
                System.out.println("当前资源拼缝,请重试");
                return false;
            }
            // 这里延迟2秒种在次获取
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                //异常都返回相同 资源异常
                return false;
            }
            //重新获取
            return getLock(keyCode, keyValue, expire, startTime,maxWaitLockTime,executions+1);
        }
    }

    /**
     * 获取keycode 当不存在时候返回true 并设置过期时间
     *
     * @param keyCode  key
     * @param keyValue 随便
     * @param expire   超时时间 seconds
     * @return
     */
    private boolean tryGetDistributedLock(String keyCode, String keyValue, long expire) {
        try {
            RedisCallback<Boolean> callback = (connection) -> {
                return connection.set(keyCode.getBytes(Charset.forName("UTF-8")), keyValue.getBytes(Charset.forName("UTF-8")), Expiration
                        .seconds(expire), RedisStringCommands.SetOption.SET_IF_ABSENT);
            };
            return (Boolean) this.redisTemplate.execute(callback);
        } catch (Exception var6) {
            System.out.println("set redis occured an exception" + var6);
            return false;
        }
    }

    /**
     * 释放锁
     */
    public boolean releaseDistributedLock(String keyCode, String keyValue) {
        try {
            RedisCallback<Boolean> callback = (redisConnection) -> {
                return (Boolean) redisConnection.eval(UNLOCK_LUA.getBytes(Charset.forName("UTF-8")), ReturnType.BOOLEAN, 1, new byte[][]{keyCode.getBytes(Charset.forName("UTF-8")), keyValue.getBytes(Charset.forName("UTF-8"))});
            };
            boolean var6 = (Boolean) this.redisTemplate.execute(callback);
            return var6;
        } catch (Exception var10) {
            return false;
        } finally {
            ;
        }
    }

    /**
     * 释放锁信息
     */
    public String getLockInfo(String keyCode) {
        try {
            RedisCallback<String> callback = (redisConnection) -> new String(redisConnection.get(keyCode.getBytes(Charset.forName("UTF-8"))));
            return (String) this.redisTemplate.execute(callback);
        } catch (Exception var10) {
            log.error("error get keyCode:{} Exception:{}", keyCode, var10);
            return "";
        }
    }
}

4.编写自定义注解

package org.xiaozhang.common.Lock;

import java.lang.annotation.*;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description: redis分布式互斥锁
 * @since 2023/3/27 16:12
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisMutexLock {
    /**
     * key
     * @return
     */
    String keyCode() default "";

    /**
     * keyValue
     * @return
     */
    String keyValue() default "";
    /**
     * key过期时间
     * @return  默认3分钟
     */
    String exprire() default "18000";

    /**
     * 最大等待时间 默认2分钟
     * @return
     */
    String maximumTime() default "12000";

}

4.2 创建参数对象

package org.xiaozhang.common.Lock;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description:
 * @since 2023/3/27 16:26
 */
public class RedisMutexDo {
    private String keyCode;
    private String keyValue;
    /**
     * 最大等待时间 默认2分钟(秒)
     * @return
     */
    private String exprire;
    /**
     * 最大等待时间 默认3分钟(秒)
     * @return
     */
    private String maximumTime;
    public RedisMutexDo(){}
    public RedisMutexDo(String keyCode, String keyValue) {
        this.keyCode = keyCode;
        this.keyValue = keyValue;
        this.exprire = "120";
        this.maximumTime = "180";
    }
    public RedisMutexDo(String keyCode, String keyValue, String exprire, String maximumTime) {
        this.keyCode = keyCode;
        this.keyValue = keyValue;
        this.exprire = exprire;
        this.maximumTime = maximumTime;
    }

    public String getKeyCode() {
        return keyCode;
    }

    public void setKeyCode(String keyCode) {
        this.keyCode = keyCode;
    }

    public String getKeyValue() {
        return keyValue;
    }

    public void setKeyValue(String keyValue) {
        this.keyValue = keyValue;
    }

    public String getExprire() {
        return exprire;
    }

    public void setExprire(String exprire) {
        this.exprire = exprire;
    }

    public String getMaximumTime() {
        return maximumTime;
    }

    public void setMaximumTime(String maximumTime) {
        this.maximumTime = maximumTime;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("RedisMutexDo{");
        sb.append("keyCode='").append(keyCode).append('\'');
        sb.append(", keyValue='").append(keyValue).append('\'');
        sb.append(", exprire='").append(exprire).append('\'');
        sb.append(", maximumTime='").append(maximumTime).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

4.3 创建aop切面类

package org.xiaozhang.common.Lock;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.CodeSignature;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.xiaozhang.common.exception.OrderException;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description:
 * @since 2023/3/27 16:13
 */
@Aspect
@Component
public class RedisMutexAop {
    private static Logger log = LoggerFactory.getLogger(RedisMutexAop.class);

    @Autowired
    private RedisLockService redisLockService;

    /***
     * 切入点
     */
    @Pointcut("@annotation(org.xiaozhang.common.Lock.RedisMutexLock)")
    public void pointCut() {
    }

    /*****
     * 环绕通知
     * @param point
     * @return
     */
    @Around("pointCut()")
    public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable {
        Object obj = null;
        //获取方法参数
        Method month = getMonth(point);
        //获取map<参数名,参数值>
        Map<String, Object> param = getParam(point);
        //获取锁注解
        RedisMutexLock annotation = month.getAnnotation(RedisMutexLock.class);
        //锁的参数
        RedisMutexDo redisMutexDo = replaceRedisMutexLock(param, annotation);
        //获取锁
        if (redisLockService.getLock(redisMutexDo)) {
            log.info("当前线程{}获取锁,开始执行业务方法",Thread.currentThread().getName());
            //执行目标方法
            obj = point.proceed();
        } else {
            //不执行返回并抛出异常
            log.error("获取分布式锁失败");
            throw new OrderException("获取分布式锁失败");
        }
        if (redisLockService.releaseDistributedLock(redisMutexDo.getKeyCode(), redisMutexDo.getKeyValue())) {
            //释放锁
            log.info("当前线程{}成功释放锁",Thread.currentThread().getName());
        } else {
            //释放失败
            log.error("释放失败{}",redisLockService.getLockInfo(redisMutexDo.getKeyCode()));
        }
        return obj;
    }

    /**
     * 获取参数名和参数值
     * @param proceedingJoinPoint
     * @return
     */
    private Map<String, Object> getParam(ProceedingJoinPoint proceedingJoinPoint) {
        Map<String, Object> map = new HashMap<String, Object>();
        Object[] values = proceedingJoinPoint.getArgs();
        String[] names = ((CodeSignature) proceedingJoinPoint.getSignature()).getParameterNames();
        for (int i = 0; i < names.length; i++) {
            map.put(names[i], values[i]);
        }
        return map;
    }

    /**
     * 获取ProceedingJoinPoint 代理的方法对象
     *
     * @param point
     * @return
     */
    private Method getMonth(ProceedingJoinPoint point) {
        Class<?> targetCls = point.getTarget().getClass();
        //获取方法签名(通过此签名获取目标方法信息)
        MethodSignature ms = (MethodSignature) point.getSignature();
        //获取目标方法上的注解指定的操作名称
        Method targetMethod = null;
        try {
            targetMethod = targetCls.getDeclaredMethod(
                    ms.getName(),
                    ms.getParameterTypes());
        } catch (NoSuchMethodException e) {
            log.error("未找到方法异常{}", e);
        }
        return targetMethod;
    }

    /**
     * 获取当前执行方法中参数中包含#字段值或者RedisMutexDo对象中参数
     *
     * @param args
     * @param annotation
     * @return 返回锁的参数
     */
    private RedisMutexDo replaceRedisMutexLock(Map<String, Object> param, RedisMutexLock annotation) {
        RedisMutexDo redisMutexDo = new RedisMutexDo();
        // 创建ExpressionParser解析表达式
        ExpressionParser parser = new SpelExpressionParser();
        // 创建一个虚拟的容器EvaluationContext
        StandardEvaluationContext ctx = new StandardEvaluationContext();
        //遍历注解中参数属性
        SpelExpression keyCode= null;
        if (checkSignStart(annotation.keyCode(),"#")){
            keyCode = Optional.ofNullable(annotation.keyCode())
                    .map(k -> (SpelExpression) parser.parseExpression(annotation.keyCode())).orElse(null);
        }
        SpelExpression keyValue= null;
        if (checkSignStart(annotation.keyValue(),"#")){
            keyValue =  Optional.ofNullable(annotation.keyValue())
                    .map(k->(SpelExpression)parser.parseExpression(annotation.keyValue())).orElse(null);
        }
        SpelExpression exprire=null;
        if (checkSignStart(annotation.exprire(),"#")){
            exprire =   Optional.ofNullable(annotation.exprire()).map(k->k.contains("#"))
                    .map(k->(SpelExpression)parser.parseExpression(annotation.exprire())).orElse(null);
        }
        SpelExpression maximumTime= null;
        if (checkSignStart(annotation.maximumTime(),"#")){
            maximumTime= Optional.ofNullable(annotation.maximumTime()).map(k->k.contains("#"))
                    .map(k->(SpelExpression)parser.parseExpression(annotation.maximumTime())).orElse(null);
        }
        //遍历参数和对应值
        param.forEach((k,v)->{
            ctx.setVariable(k, v);
        });
        //赋值
        redisMutexDo.setKeyCode(keyCode!=null?(String) keyCode.getValue(ctx):annotation.keyCode());
        redisMutexDo.setKeyValue(keyValue!=null?(String) keyValue.getValue(ctx):annotation.keyValue());
        redisMutexDo.setExprire(exprire!=null?(String) exprire.getValue(ctx):annotation.exprire());
        redisMutexDo.setMaximumTime(maximumTime!=null?(String) maximumTime.getValue(ctx):annotation.maximumTime());
        return redisMutexDo;
    }

 

    /**
     * 检查字符串是否以符号开头
     * @param str 字符串
     * @param sign 符号
     * @return
     */
    private boolean checkSignStart(String str,String sign){
        if (str == null || "".equals(str)){
            return false;
        }
        //去除前后字符串
        if (str.trim().lastIndexOf(sign)==0){
            return true;
        }
        return false;
    }
}

5.开始业务测试 创建个业务方法并重写两种方式

  //车数
    public static int cs=100;

    @RedisMutexLock(keyCode = "#keyCode",keyValue = "#keyValue",exprire = "#exprire",maximumTime = "#maximumTime")
    public JsonResponse getLock(String keyCode,String keyValue,String exprire,String maximumTime){
        RedisMutexDo redisMutexDo = new RedisMutexDo(keyCode,keyValue,exprire,maximumTime);
        return this.getLock(redisMutexDo);
    }
    @RedisMutexLock(keyCode = "#redisMutexDo.keyCode",keyValue = "#redisMutexDo.keyValue",exprire = "#redisMutexDo.exprire",maximumTime = "#redisMutexDo.maximumTime")
    public JsonResponse getLock(RedisMutexDo redisMutexDo) {
        try {
            //睡个20秒
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            log.error("中断异常:{}",e);
        }
        log.info("获得了锁进入业务方法");
        cs=cs-1;
        return JsonResponse.ok(redisMutexDo).setMessage("抢到");
    }

 5.2 开始用测试类去测试 

这里一开始没有启动redis服务,现在处于连接失败状态,不过资源还在一直尝试抢锁,

2秒抢一次锁，最大等待时间/2=抢锁次数这里做了打印

180/2=大约重试锁60次，就会结束抛出异常不再执行业务方法。

 

头发哐哐掉
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
分布式锁基于【注解】，杜绝业务重复提交。动态key
SharingOfficer的博客
12-20 650
前言 在日常开发中，为了防止高并发，在不依赖过多的中间件的情况下，最常使用的分布式锁之一是Redis锁。使用Redis锁就不得不面临一个问题，就是在业务代码中要控制Redis加锁、释放锁等等，对代码的侵入性较强。本文采用注解的方式为方法体增加分布式锁，唯一标识从方法参数中动态获取。 优点 无侵入。通过注解实现加锁和释放锁，代码中只需关注业务实现，无须关心“锁”问题，避免代码侵入。 无死锁。即使某一线程中断没能释放锁，在到达指定的时间后，程序会自动释放锁。 锁唯一独有。加锁和释放锁必须由同一线...
分布式锁注解@RedisLock,接口幂等性
CongBird的博客
02-08 995
分布式锁的运用
Redis分布式锁注解（Java实现）
weixin_47224121的博客
06-07 1793
在项目中遇到了插入重复数据的问题，为了防止并发造成重复数据的插入，故使用加锁，而传统的加锁是单机锁并不适用分布式项目，故采用Redis分布式锁。
@RedisLock注解实现分布式锁
qq_33816292的博客
08-15 3466
@RedisLock注解实现分布式锁
redis分布式锁 做成注解 , 超好用 !
weixin_43786801的博客
09-24 802
redis分布式锁 做成注解
基于redis的java分布式代理锁
05-24
分布式代理锁，动态的锁后缀采用ThreadLocal或者参数名获取 锁粒度自定义选择，目前实现基于redis，后续扩展zk等 SpringBoot，默认使用redisson链接redis，可以更改注解参数使用Spring redis工具 key分为：无后缀、...
fat：基于springboot，zookeeper，redis分布式事务强一致性方案
02-06
脂肪FAT，基于springboot，使用zookeeper，...同时具有一定的扩展性与兼容性，因为存在自定义的服务框架，或者以后会涌现出更多的流行分布式服务框架，所以会提供一些组件适应自定义服务框架。Maven依赖< depende
分布式锁：最强、最方便，一行代码搞定全部，免费提供技术支持，不懂就问
04-12
一行代码实现分布式锁。基于自定义注解实现分布式锁，拆箱即用。附件内有非常详细的使用说明和例子，下雨知道往家跑的人都会用。还是不会可以联系我，免费提供技术支持和解答
基于springboot , zookeeper , redis 分布式事务强一致性方案+源代码+文档说明
最新发布
11-28
同时具备一定的扩展性与兼容性，因为存在自定义的服务框架，或者以后会涌现出更多的流行分布式服务框架，所以会提供一些组件适配自定义服务框架。 ## Maven依赖 ```java <groupId>com.github.cjyican</groupId> ...
spring-boot-distributed-redisson:redis实现分布式锁 Spring Boot core for Redisson RedissonLock
05-17
该项目支持 自定义注解加锁 和 常规加锁 两种模式 自定义注解加锁 @DistributedLock(value="goods", leaseTime=5) public String lockDecreaseStock(){ //业务逻辑 } 常规加锁 //1、加锁 redissonLock.lock(...
AOP+自定义注解+Redis实现分布式锁
小学生波波
10-29 2222
AOP+自定义注解+Redis实现分布式锁
redis锁-注解版
activety的博客
06-05 723
Redis实现分布式锁利用 SETNX 和 SETEX 基本命令主要有： SETNX(SET If Not Exists)： 当且仅当 Key 不存在时，则可以设置，否则不做任何动作。 当且仅当 key 不存在，将 key 的值设为 value ，并返回1；若给定的 key 已经存在，则 SETNX 不做任何动作，并返回0。 SETEX： 基于SETNX功能外,还可以设置超时时间，防止死锁。 项目图 代码实现 application.yml # Redis数据库索引（默认为0） spring.redis.
使用注解实现redis分布式锁！
架构文摘
04-21 261
一、业务背景有些业务请求，属于耗时操作，需要加锁，防止后续的并发操作，同时对数据库的数据进行操作，需要避免对之前的业务造成影响。二、分析流程使用 Redis 作为分布式锁，将锁的状态放到 Redis 统一维护，解决集群中单机 JVM 信息不互通的问题，规定操作顺序，保护用户的数据正确。梳理设计流程1、新建注解 @interface，在注解里设定入参标志2、增加 AOP 切点，扫描特定注解3、建立 ...
自定义注解 输出方法上的参数 和 返回值
夜晓星的博客
01-19 9381
定义自定义注解 /**  * 参数日志  * 输出方法上的参数  * 输出返回对象  */ @Target({ ElementType.METHOD, ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface ParamLog { }     /** ...
自定义注解+RedisLockRegistry实现注解加锁解决并发问题
qq_39022699的博客
05-04 369
三、配置RedisLockRegistry。
自定义注解，基于redis实现分布式锁
weixin_43975276的博客
06-07 1603
实现自定义注解其实很简单，格式基本都差不多。也就参数可能变一变。
使用注解实现 Redis 分布式锁，看了秒懂！
m0_71777195的博客
03-29 273
一、业务背景有些业务请求，属于耗时操作，需要加锁，防止后续的并发操作，同时对数据库的数据进行操作，需要避免对之前的业务造成影响。二、分析流程使用Redis作为分布式锁，将锁的状态放到Redis统一维护，解决集群中单机JVM信息不互通的问题，规定操作顺序，保护用户的数据正确。梳理设计流程1、2、3、4、5、
Redis分布式锁成功案例
春风化雨
01-26 675
1、自定义分布式锁工具类 package com.cache.redis.demo.util; import org.apache.commons.lang.time.DateFormatUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.data.redis.connection.RedisStringCommands; import org.springframewor
Redis 分布式锁 @Klock 注解详解及使用教程
demo_yo的博客
10-10 934
有些人可能会给两个服务的配置改成不一样，比如定时任务的时间修改，一个正常执行，一个在不可能的时间执行，还有人直接给服务设置一个标志位，只有某个标志位的能执行。最常见的就比如手机端录入信息到后台，比如注册之类的等等，用户端可能因为各种原因可能会点击多次，导致后台可能会出现多笔记录的情况，这个时候很简单，用到我们的锁，假设，我们是注册用户，手机号是唯一的。这个时候，如果是点击了两次，第一次业务进入获取到锁进行处理，第二过来了也是一个等待，要么第一次处理完成，第二次业务判断已注册，要么第二次直接超时了。
redis分布式锁spring注解
08-26
对于使用Redis分布式锁的Spring注解，可以使用`@DistributedLock`注解来实现。你可以自定义一个注解，如下所示： ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值