Spring Boot 集成 Redisson分布式锁（注解版）

置顶 已于 2024-01-18 18:15:11 修改
阅读量1.3w 收藏 78
点赞数 21
分类专栏： Redis 文章标签： spring boot 分布式 java
于 2023-06-09 17:50:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ascend1977/article/details/131126047
版权

        Redisson 是一种基于 Redis 的 Java 驻留集群的分布式对象和服务库，可以为我们提供丰富的分布式锁和线程安全集合的实现。在 Spring Boot 应用程序中使用 Redisson 可以方便地实现分布式应用程序的某些方面，例如分布式锁、分布式集合、分布式事件发布和订阅等。本篇是一个使用 Redisson 实现分布式锁的详细示例，在这个示例中，我们定义了DistributedLock注解，它可以标注在方法上，配合DistributedLockAspect切面以及IDistributedLock分布式锁封装的接口，来实现redisson 分布式锁的 API 调用。

Spring Boot 集成 Redisson

 1、在 pom.xml 文件中添加 Redisson 的相关依赖

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

2、在 application.yml 中配置 Redisson单机模式 的连接信息和相关参数

spring:
  redis:
    host: localhost
    port: 6379
    password: null
redisson:
  codec: org.redisson.codec.JsonJacksonCodec
  threads: 4
  netty:
    threads: 4
  single-server-config:
    address: "redis://localhost:6379"
    password: null
    database: 0

3、Redission还支持主从、集群、哨兵配置

//主从模式
spring:
  redis:
    sentinel:
      master: my-master
      nodes: localhost:26379,localhost:26389
    password: your_password
redisson:
  master-slave-config:
    master-address: "redis://localhost:6379"
    slave-addresses: "redis://localhost:6380,redis://localhost:6381"
    password: ${spring.redis.password}

// 集群模式
spring:
  redis:
    cluster:
      nodes: localhost:6379,localhost:6380,localhost:6381,localhost:6382,localhost:6383,localhost:6384
    password: your_password
redisson:
  cluster-config:
    node-addresses: "redis://localhost:6379,redis://localhost:6380,redis://localhost:6381,redis://localhost:6382,redis://localhost:6383,redis://localhost:6384"
    password: ${spring.redis.password}

// 哨兵模式
spring:
  redis:
    sentinel:
      master: my-master
      nodes: localhost:26379,localhost:26389
    password: your_password
redisson:
  sentinel-config:
    master-name: my-master
    sentinel-addresses: "redis://localhost:26379,redis://localhost:26380,redis://localhost:26381"
    password: ${spring.redis.password}

 本地封装Redisson 分布式锁

1、定义IDistributedLock分布式锁接口

public interface IDistributedLock {
    /**
     * 获取锁，默认30秒失效，失败一直等待直到获取锁
     *
     * @param key 锁的key
     * @return 锁对象
     */
    ILock lock(String key);

    /**
     * 获取锁,失败一直等待直到获取锁
     *
     * @param key      锁的key
     * @param lockTime 加锁的时间，超过这个时间后锁便自动解锁； 如果lockTime为-1，则保持锁定直到显式解锁
     * @param unit     {@code lockTime} 参数的时间单位
     * @param fair     是否公平锁
     * @return 锁对象
     */
    ILock lock(String key, long lockTime, TimeUnit unit, boolean fair);

    /**
     * 尝试获取锁，30秒获取不到超时异常，锁默认30秒失效
     *
     * @param key     锁的key
     * @param tryTime 获取锁的最大尝试时间
     * @return
     * @throws Exception
     */
    ILock tryLock(String key, long tryTime) throws Exception;

    /**
     * 尝试获取锁，获取不到超时异常
     *
     * @param key      锁的key
     * @param tryTime  获取锁的最大尝试时间
     * @param lockTime 加锁的时间
     * @param unit     {@code tryTime @code lockTime} 参数的时间单位
     * @param fair     是否公平锁
     * @return
     * @throws Exception
     */
    ILock tryLock(String key, long tryTime, long lockTime, TimeUnit unit, boolean fair) throws Exception;

    /**
     * 解锁
     *
     * @param lock
     * @throws Exception
     */
    void unLock(Object lock);


    /**
     * 释放锁
     *
     * @param lock
     * @throws Exception
     */
    default void unLock(ILock lock) {
        if (lock != null) {
            unLock(lock.getLock());
        }
    }


}

2、IDistributedLock实现类

@Slf4j
@Component
public class RedissonDistributedLock implements IDistributedLock {

    @Resource
    private RedissonClient redissonClient;
    /**
     * 统一前缀
     */
    @Value("${redisson.lock.prefix:bi:distributed:lock}")
    private String prefix;

    @Override
    public ILock lock(String key) {
        return this.lock(key, 0L, TimeUnit.SECONDS, false);
    }

    @Override
    public ILock lock(String key, long lockTime, TimeUnit unit, boolean fair) {
        RLock lock = getLock(key, fair);
        // 获取锁,失败一直等待,直到获取锁,不支持自动续期
        if (lockTime > 0L) {
            lock.lock(lockTime, unit);
        } else {
            // 具有Watch Dog 自动延期机制 默认续30s 每隔30/3=10 秒续到30s
            lock.lock();
        }
        return new ILock(lock, this);
    }

    @Override
    public ILock tryLock(String key, long tryTime) throws Exception {
        return this.tryLock(key, tryTime, 0L, TimeUnit.SECONDS, false);
    }

    @Override
    public ILock tryLock(String key, long tryTime, long lockTime, TimeUnit unit, boolean fair)
            throws Exception {
        RLock lock = getLock(key, fair);
        boolean lockAcquired;
        // 尝试获取锁，获取不到超时异常,不支持自动续期
        if (lockTime > 0L) {
            lockAcquired = lock.tryLock(tryTime, lockTime, unit);
        } else {
            // 具有Watch Dog 自动延期机制 默认续30s 每隔30/3=10 秒续到30s
            lockAcquired = lock.tryLock(tryTime, unit);
        }
        if (lockAcquired) {
            return new ILock(lock, this);
        }
        return null;
    }

    /**
     * 获取锁
     *
     * @param key
     * @param fair
     * @return
     */
    private RLock getLock(String key, boolean fair) {
        RLock lock;
        String lockKey = prefix + ":" + key;
        if (fair) {
            // 获取公平锁
            lock = redissonClient.getFairLock(lockKey);
        } else {
            // 获取普通锁
            lock = redissonClient.getLock(lockKey);
        }
        return lock;
    }

    @Override
    public void unLock(Object lock) {
        if (!(lock instanceof RLock)) {
            throw new IllegalArgumentException("Invalid lock object");
        }
        RLock rLock = (RLock) lock;
        if (rLock.isLocked()) {
            try {
                rLock.unlock();
            } catch (IllegalMonitorStateException e) {
                log.error("释放分布式锁异常", e);
            }
        }
    }
}

 3、定义ILock锁对象

import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.Objects;

/**
 * <p>
 * RedissonLock 包装的锁对象 实现AutoCloseable接口，在java7的try(with resource)语法，不用显示调用close方法
 * </p>

 * @since 2023-06-08 16:57
 */
@AllArgsConstructor
public class ILock implements AutoCloseable {
    /**
     * 持有的锁对象
     */
    @Getter
    private Object lock;
    /**
     * 分布式锁接口
     */
    @Getter
    private IDistributedLock distributedLock;

    @Override
    public void close() throws Exception {
        if(Objects.nonNull(lock)){
            distributedLock.unLock(lock);
        }
    }
}

4、注入IDistributedLock接口使用示例

// 定义接口
public interface IProductSkuSupplierMeasureService {
    /**
     * 保存SKU供应商供货信息
     *
     * @param dto
     * @return
     *
    Boolean saveSupplierInfo(ProductSkuSupplierInfoDTO dto);

    /**
     * 编辑SKU供应商供货信息
     *
     * @param dto
     * @return
     */
    Boolean editSupplierInfo(ProductSkuSupplierInfoDTO dto);
}

手动释放锁示例 

// 实现类
@Service
public class ProductSkuSupplierMeasureServiceImpl 
        implements IProductSkuSupplierMeasureService {

    @Resource
    private IDistributedLock distributedLock;    
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean saveSupplierInfo(ProductSkuSupplierInfoDTO dto) {
        // 手动释放锁
        String sku = dto.getSku();
        ILock lock = null;
        try {
            lock = distributedLock.lock(dto.getSku(),10L, TimeUnit.SECONDS, false);
            if (Objects.isNull(lock)) {
                throw new BusinessException("Duplicate request for method still in process");
            }
            // 业务代码
        }catch (BusinessException e) {
            throw new BusinessException(e.getMessage());
        } catch (Exception e) {
            log.error("保存异常", e);
            throw new BusinessException (e.getMessage());
        } finally {
            if (Objects.nonNull(lock)) {
                distributedLock.unLock(lock);
            }
        }
        return Boolean.TRUE;
    }

}

 使用try-with-resources 语法糖自动释放锁

// 实现类
@Service
public class ProductSkuSupplierMeasureServiceImpl 
        implements IProductSkuSupplierMeasureService {

    @Resource
    private IDistributedLock distributedLock;    
   

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean editSupplierInfo(ProductSkuSupplierInfoDTO dto) {
       
        String sku = dto.getSku();
        // try-with-resources 语法糖自动释放锁
        try(ILock lock = distributedLock.lock(dto.getSku(),10L, TimeUnit.SECONDS, false)) {
            if(Objects.isNull(lock)){
                throw new BusinessException ("Duplicate request for method still in process");
            }
            
            // 业务代码
        }catch (BusinessException e) {
            throw new BusinessException (e.getMessage());
        } catch (Exception e) {
            log.error("修改异常", e);
            throw new BusinessException ("修改异常");
        }
        return Boolean.TRUE;
   }
}

5、使用AOP切面实现分布式锁的绑定

  定义DistributedLock注解

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DistributedLock {

    /**
     * 保证业务接口的key的唯一性，否则失去了分布式锁的意义 锁key
     * 支持使用spEl表达式
     */
    String key();

    /**
     * 保证业务接口的key的唯一性，否则失去了分布式锁的意义 锁key 前缀
     */
    String keyPrefix() default "";

    /**
     * 是否在等待时间内获取锁，如果在等待时间内无法获取到锁，则返回失败
     */
    boolean tryLok() default false;

    /**
     * 获取锁的最大尝试时间 ，会尝试tryTime时间获取锁，在该时间内获取成功则返回，否则抛出获取锁超时异常，tryLok=true时，该值必须大于0。
     *
     */
    long tryTime() default 0;

    /**
     * 加锁的时间，超过这个时间后锁便自动解锁
     */
    long lockTime() default 30;

    /**
     * tryTime 和 lockTime的时间单位
     */
    TimeUnit unit() default TimeUnit.SECONDS;

    /**
     * 是否公平锁，false:非公平锁，true:公平锁
     */
    boolean fair() default false;
}

 定义DistributedLockAspect Lock切面

@Aspect
@Slf4j
public class DistributedLockAspect {

    @Resource
    private IDistributedLock distributedLock;

    /**
     * SpEL表达式解析
     */
    private SpelExpressionParser spelExpressionParser = new SpelExpressionParser();

    /**
     * 用于获取方法参数名字
     */
    private DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();

    @Pointcut("@annotation(com.yt.bi.common.redis.distributedlok.annotation.DistributedLock)")
    public void distributorLock() {
    }

    @Around("distributorLock()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // 获取DistributedLock
        DistributedLock distributedLock = this.getDistributedLock(pjp);
        // 获取 lockKey
        String lockKey = this.getLockKey(pjp, distributedLock);
        ILock lockObj = null;
        try {
            // 加锁，tryLok = true,并且tryTime > 0时，尝试获取锁，获取不到超时异常
            if (distributedLock.tryLok()) {
                if(distributedLock.tryTime() <= 0){
                    throw new IdempotencyException("tryTime must be greater than 0");
                }
                lockObj = this.distributedLock.tryLock(lockKey, distributedLock.tryTime(), distributedLock.lockTime(), distributedLock.unit(), distributedLock.fair());
            } else {
                lockObj = this.distributedLock.lock(lockKey, distributedLock.lockTime(), distributedLock.unit(), distributedLock.fair());
            }

            if (Objects.isNull(lockObj)) {
                throw new IdempotencyException("Duplicate request for method still in process");
            }

            return pjp.proceed();
        } catch (Exception e) {
            throw e;
        } finally {
            // 解锁
            this.unLock(lockObj);
        }
    }

    /**
     * @param pjp
     * @return
     * @throws NoSuchMethodException
     */
    private DistributedLock getDistributedLock(ProceedingJoinPoint pjp) throws NoSuchMethodException {
        String methodName = pjp.getSignature().getName();
        Class clazz = pjp.getTarget().getClass();
        Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
        Method lockMethod = clazz.getMethod(methodName, par);
        DistributedLock distributedLock = lockMethod.getAnnotation(DistributedLock.class);
        return distributedLock;
    }

    /**
     * 解锁
     *
     * @param lockObj
     */
    private void unLock(ILock lockObj) {
        if (Objects.isNull(lockObj)) {
            return;
        }

        try {
            this.distributedLock.unLock(lockObj);
        } catch (Exception e) {
            log.error("分布式锁解锁异常", e);
        }
    }

    /**
     * 获取 lockKey
     *
     * @param pjp
     * @param distributedLock
     * @return
     */
    private String getLockKey(ProceedingJoinPoint pjp, DistributedLock distributedLock) {
        String lockKey = distributedLock.key();
        String keyPrefix = distributedLock.keyPrefix();
        if (StringUtils.isBlank(lockKey)) {
            throw new IdempotencyException("Lok key cannot be empty");
        }
        if (lockKey.contains("#")) {
            this.checkSpEL(lockKey);
            MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
            // 获取方法参数值
            Object[] args = pjp.getArgs();
            lockKey = getValBySpEL(lockKey, methodSignature, args);
        }
        lockKey = StringUtils.isBlank(keyPrefix) ? lockKey : keyPrefix + lockKey;
        return lockKey;
    }

    /**
     * 解析spEL表达式
     *
     * @param spEL
     * @param methodSignature
     * @param args
     * @return
     */
    private String getValBySpEL(String spEL, MethodSignature methodSignature, Object[] args) {
        // 获取方法形参名数组
        String[] paramNames = nameDiscoverer.getParameterNames(methodSignature.getMethod());
        if (paramNames == null || paramNames.length < 1) {
            throw new IdempotencyException("Lok key cannot be empty");
        }
        Expression expression = spelExpressionParser.parseExpression(spEL);
        // spring的表达式上下文对象
        EvaluationContext context = new StandardEvaluationContext();
        // 给上下文赋值
        for (int i = 0; i < args.length; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        Object value = expression.getValue(context);
        if (value == null) {
            throw new IdempotencyException("The parameter value cannot be null");
        }
        return value.toString();
    }

    /**
     * SpEL 表达式校验
     *
     * @param spEL
     * @return
     */
    private void checkSpEL(String spEL) {
        try {
            ExpressionParser parser = new SpelExpressionParser();
            parser.parseExpression(spEL, new TemplateParserContext());
        } catch (Exception e) {
            log.error("spEL表达式解析异常", e);
            throw new IdempotencyException("Invalid SpEL expression [" + spEL + "]");
        }
    }
}

定义分布式锁注解版启动元注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({DistributedLockAspect.class})
public @interface EnableDistributedLock {
}

6、AOP切面实现分布式锁的绑定使用示例

   启动类添加@EnableDistributedLock启用注解支持

@SpringBootApplication
@EnableDistributedLock
public class BiCenterGoodsApplication {

    public static void main(String[] args) {
        
        SpringApplication.run(BiCenterGoodsApplication.class, args);
        
    }
}

@DistributedLock标注需要使用分布式锁的方法 

    @ApiOperation("编辑SKU供应商供货信息")
    
    @PostMapping("/editSupplierInfo")
    //@DistributedLock(key = "#dto.sku + '-' + #dto.skuId", lockTime = 10L, keyPrefix = "sku-")
    @DistributedLock(key = "#dto.sku", lockTime = 10L, keyPrefix = "sku-")
    public R<Boolean> editSupplierInfo(@RequestBody @Validated ProductSkuSupplierInfoDTO dto) {
        return R.ok(productSkuSupplierMeasureService.editSupplierInfo(dto));
    }

#dto.sku是 SpEL表达式。Spring中支持的它都支持的。比如调用静态方法，三目表达式。SpEL 可以使用方法中的任何参数。SpEL表达式参考

从原理到实践，分析 Redis 分布式锁的多种实现方案（一）_Ascend JF的博客-CSDN博客




 

Ascend1797
关注
专栏目录
SpringBoot项目集成Redisson实现分布式锁
hkl_Forever的博客
11-27 1058
备注：redisson-spring-boot-starter 方式不需要手动初始化 RedissonClient 实例。1、初始化 RedissonClient 实例配置类。
[springboot专栏]使用redisson实现分布式锁
字母哥博客
08-25 2108
Redisson是Redis官方推荐的Java版的Redis客户端（Jedis、letture也是官方推荐的java版本redis客户端程序）。它提供的功能非常多，也非常强大，特别是它默认提供的分布式锁支持功能。，包含多个子项目，对于我们本节比较有用的是集成redisson-spring-data-2x之后能够支持Spring Data redis及RedisTemplate。...
在SpringBoot项目中利用Redission实现布隆过滤器（布隆过滤器的应用场景、布隆过滤器误判的情况、与位图相关的操作）
最新发布
聂可以的博客
09-19 1774
在SpringBoot项目中利用Redission实现布隆过滤器（布隆过滤器的应用场景、布隆过滤器误判的情况、与位图相关的操作）
SpringBoot整合redisson分布式锁
热门推荐
congge
05-08 5万+
1、为什么要使用分布式锁 在分布式场景下为了保证数据最终一致性。在单进程的系统中，存在多个线程可以同时改变某个变量（可变共享变量）时，就需要对变量或代码块做同步(lock—synchronized)，使其在修改这种变量时能够线性执行消除并发修改变量。但分布式系统是多部署、多进程的，开发语言提供的并发处理API在此场景下就无能为力了。 2.分布式锁的使用场景 电商网站用下单操作时需要使用，秒杀活动更...
SpringBoot整合Redisson
马明的博客
01-19 3881
个人博客纯净版 SpringBoot整合Redisson | 代码搬运工 Redisson简介 Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步
Spring Boot集成Redisson实现分布式锁
weixin_45626288的博客
07-15 1774
通过以上步骤，我们成功地在Spring Boot项目中集成了Redisson，并实现了分布式锁的功能。分布式锁可以保证多个节点对共享资源的安全访问，避免了并发访问带来的数据不一致和安全问题。在实际开发中，我们可以根据具体业务需求，使用分布式锁来保证数据的一致性和并发访问的安全性。
SpringBoot集成Redisson分布式锁
liuerpeng1904的博客
01-08 1075
A、B线程争抢一把锁，A获取到后，B阻塞B线程阻塞时并非主动 CAS，而是PubSub方式订阅该锁的广播消息A操作完成释放了锁，B线程收到订阅消息通知B被唤醒开始继续抢锁，拿到锁。
基于Redission实现分布式锁（注解版）
长沙老码农
04-28 2132
起两个或者更多的服务实例，操作同一个数据库（比如扣库存），然后通过nginx将这些服务实例进行负载均衡配置，通过jmeter或者其他压力测试工具实现并发访问，比较Service方法上加@Dislock和不加的区别。我们想通过注解方式无感实现分布式锁，必须要用到AOP的功能，而且是环绕通知（有do 有 return）生成lockKey，保证锁定资源的唯一性，并且只能解锁自己加的锁。主要是将RedissonClient与Redis数据库关联起来。
springboot使用redisson实现分布式锁
qq_42077317的博客
06-06 1441
在实际项目中，某些场景下可能需要使用到分布式锁功能，那么实现分布式锁有多种方式，常见的如mysql分布式锁、zookeeper分布式锁、redis分布式锁，从效率上讲，redis无疑是性能最好的，但也会存在一些问题。1.获取锁的线程在执行任务的过程中挂掉，来不及释放锁，这块资源将会永远被锁住（死锁），别的线程再也别想进来，因此我们需要给key加个过期时间，保证这把锁要在一定时间后自动释放。当线程 A 执行的很慢很慢，到达过期时间都没执行完，这时候锁过期自动释放，线程 B得到了锁。大家可以自己尝试下。
SpringBoot：SpringBoot中使用Redisson实现分布式锁
永远保持随时离开的技术能力！
06-06 1823
Redisson实现分布式锁的代码示例以及原理；源码分析WatchDog的执行过程。
SpringBoot使用Redisson实现分布式锁
12程序猿的博客
03-13 546
SpringBoot使用Redisson实现分布式锁
springboot基于redis分布式锁
11-06
SpringBoot基于redis的分布式锁,有word使用文档,根据文档配置即可使用
Java注解如何基于Redission实现分布式锁
08-25
主要介绍了Java注解如何基于Redission实现分布式锁,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Redisson之——使用Redisson通过自定义注解实现分布式锁，使用Spring AOP简化分布式锁
2401_84046677的博客
04-16 296
搞定算法，面试字节再不怕，有需要文章中分享的这些二叉树、链表、字符串、栈和队列等等各大面试高频知识点及解析最后再分享一份终极手撕架构的大礼包(学习笔记)：分布式+微服务+开源框架+性能优化《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！最后在Worker1的run方法中使用，把替换成如下：});自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
Springboot-redis-springcache缓存-分布式锁redisson
weixin_44748599的博客
11-07 1554
redis
【Spring Boot 3】【Redis】集成Redisson实现消息发布订阅
又言又语
01-22 1381
Redisson区别与Lettuce和Jedis之处在于，Redisson不再是一个纯粹的Redis客户端，还提供了很多高级的分布式服务，本文介绍开发Spring Boot应用集成Redisson实现消息的发布及订阅。：定义消息主题（Topic）及消息对象类。：定时发布消息。：订阅消息。
Redisson分布式锁实践：lock与tryLock解析
并排除了特定版本的Spring Data Redis依赖，然后引入了适用于Spring Data Redis的另一个版本，同时包含了Spring Boot的`spring-boot-starter-data-redis`依赖，以确保能够顺利集成Redisson和Spring Data Redis。...
Spring Boot 基于Redisson实现注解式分布式锁
大橘的博客
12-30 1781
Spring Boot + Redisson 实现分布式锁，本文基于注解和函数式接口两种实现，适配不同的应用场景，速速来看。
SpringBoot中使用注解来实现 Redis 分布式锁
qq_24692021的博客
11-18 276
redis锁
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值