SpringBoot——实现对Redis五种数据类型的增删改查

最新推荐文章于 2024-09-20 23:17:22 发布
原创 最新推荐文章于 2024-09-20 23:17:22 发布 · 4.6k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #redis #maven #springboot

本文详细介绍了如何在Spring Boot项目中集成Redis，包括添加依赖、配置属性、创建配置类以及进行单元测试。测试涵盖了字符串、列表、哈希、集合和有序集合等多种数据类型的操作，如设置、获取、删除等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

一、添加Redis依赖

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

二、application.properties

# 应用名称
spring.application.name=springboot_redis
server.port=8085
#配置Redis，redis的host是虚拟机服务器上的IP地址，端口6379
spring.redis.host=127.0.0.1
spring.redis.port=6379

三、添加配置类

package com.ljx.springboot_redis.config;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;

import java.time.Duration;


/**
 * @Author: Ljx
 * @Date: 2021/12/1 13:34
 * @role:
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
    private static final StringRedisSerializer STRING_SERIALIZER = new StringRedisSerializer();
    private static final GenericJackson2JsonRedisSerializer JACKSON__SERIALIZER = new GenericJackson2JsonRedisSerializer();

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //设置缓存过期时间
        RedisCacheConfiguration redisCacheCfg=RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(STRING_SERIALIZER))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(JACKSON__SERIALIZER));
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheCfg)
                .build();
    }

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        // key序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // value序列化
        redisTemplate.setValueSerializer(JACKSON__SERIALIZER);
        // Hash key序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // Hash value序列化
        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

四、测试

TestRedisString

package com.ljx.springboot_redis;

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @Author: Ljx
 * @Date: 2021/12/1 0:52
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
class TestRedisString {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Test
    public void testSet(){
        //向数据库中保存 name heima
        redisTemplate.opsForValue().set("name","heima");

        //相关数据保存 name1 heima1  有效时间为10s
        redisTemplate.opsForValue().set("name1","heima1",10, TimeUnit.SECONDS);

        //替换 heima        heXXa  offset 索引位置是从0开始
        redisTemplate.opsForValue().set("name","XX",2);

        //当key不存在的时候，执行保存操作；当key存在时，什么都不做
        redisTemplate.opsForValue().setIfAbsent("name","heima");

        //批量保存
        Map<String,String> map = new HashMap<>();
        map.put("name2","heima2");
        map.put("name3","heima3");
        map.put("name3","heima3");

        redisTemplate.opsForValue().multiSet(map);

        //追加 当key存在时，会执行追加操作；当key不存在时，会执行保存操作
        redisTemplate.opsForValue().append("name5","heima");
    }


    @Test
    public void testGet(){
        //根据key获取value
        String value = redisTemplate.opsForValue().get("name");
        System.out.println(value);

        //首先根据key获取value，然后再根据value进行截取。从start位置截取到end位置【包含start和end】
        String name = redisTemplate.opsForValue().get("name", 5, 7);
        System.out.println(name);

        //批量获取
        List<String> keys = new ArrayList<>();
        keys.add("name2");
        keys.add("name3");
        keys.add("name4");
        List<String> values = redisTemplate.opsForValue().multiGet(keys);
        for (String s : values) {
            System.out.println(s);
        }

        //根据key获取value的长度
        Long size = redisTemplate.opsForValue().size("name");
        System.out.println(size);
    }


    @Test
    public void testIncrement(){
        redisTemplate.opsForValue().set("age","18");
//        自增1
        redisTemplate.opsForValue().increment("age");
        System.out.println(redisTemplate.opsForValue().get("age"));
//        自增6
        redisTemplate.opsForValue().increment("age",6);
        System.out.println(redisTemplate.opsForValue().get("age"));

//        自减
        redisTemplate.opsForValue().decrement("age");
    }

    //删除
    @Test
    public void testDelete(){
//        单个删除
        redisTemplate.delete("name");

        List<String> list = new ArrayList<>();
        list.add("name2");
        list.add("name3");
        list.add("name4");
//        批量删除
        redisTemplate.delete(list);
    }
}

TestRedisList

package com.ljx.springboot_redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.swing.*;
import java.util.List;

/**
 * @Author: Ljx
 * @Date: 2021/12/1 20:24
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisList {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    //增加
    @Test
    public void testAdd(){
        //从左边添加一个元素
        redisTemplate.opsForList().leftPush("students","zhangshan");
        //从左边添加多个元素
        redisTemplate.opsForList().leftPush("students","lishi","wangwu");

        //从右边添加一个元素
        redisTemplate.opsForList().rightPush("students","zhangshan1");
        //从右边添加多个元素
        redisTemplate.opsForList().rightPush("students","lishi1","wangwu1");
    }

    @Test
    public void testFind(){
        //根据key和元素索引进行查询
        //0和正数代表从左边开始
        //负数代表从右边开始
        String students = redisTemplate.opsForList().index("students", 1);
        System.out.println(students);

        String students1 = redisTemplate.opsForList().index("students", -1);
        System.out.println(students1);

        //范围查询
        //根据key 【start,end】 包括首尾
        List<String> students2 = redisTemplate.opsForList().range("students", 0, 2);
        for (String s : students2) {
            System.out.println(s);
        }
    }
    //删除
    @Test
    public void testRemove(){
        //从左边删除第一个元素
        String s = redisTemplate.opsForList().leftPop("students");
        //从右边删除第一个元素
        String s1 = redisTemplate.opsForList().rightPop("students");

        //count > 0; 删除左边起第几个等于指定值的元素
        //count < 0; 删除右边起第几个等于指定值的元素
        //count = 0; 删除所有等于value的元素
        //删除左边起第二个wangwu
        redisTemplate.opsForList().remove("students",2,"wangwu");


    }
}

TestRedisHash

package com.ljx.springboot_redis;

import com.ljx.springboot_redis.uesr.Article;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @Author: Ljx
 * @Date: 2021/12/1 13:07
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisHash {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testPut(){
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        Article article = new Article();
        article.setTitle("title");
        article.setCreateTime(new Date());
        article.setAuthor("lixiang");

        redisTemplate.opsForHash().put("article","1",article);
    }

    @Test
    public void testGet(){
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        //判断hashkey是否存在
//        Boolean article = redisTemplate.opsForHash().hasKey("article", "2");
//        System.out.println(article);
//
//        //根据key和hashkey获取操作
//        Article article1 = (Article) redisTemplate.opsForHash().get("article", "2");
//        System.out.println(article1);


//        //根据key获取所有的hashkey
//        Set<String> set = redisTemplate.opsForHash().keys("article");
//        for (Object s : set) {
//            System.out.println(s);
//        }


        List<Article> articles = redisTemplate.opsForHash().values("article");
        for (Article article : articles) {
            System.out.println(article);
        }

        Map<String,Article> map = redisTemplate.opsForHash().entries("article");
        for (Map.Entry<String, Article> entry : map.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }

    //删除
    @Test
    public void testDelete(){
        //当hash中的数据全被删除后，整个hash就没了
        redisTemplate.opsForHash().delete("article","1","2");
    }
}

Article

package com.ljx.springboot_redis.uesr;

import javax.xml.crypto.Data;
import java.io.Serializable;
import java.util.Date;

/**
 * @Author: Ljx
 * @Date: 2021/12/1 13:12
 * @role:
 */
public class Article implements Serializable {
    private String author;
    private Data createTime;
    private String title;

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Data getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Data createTime) {
        this.createTime = createTime;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return "Article{" +
                "author='" + author + '\'' +
                ", createTime=" + createTime +
                ", title='" + title + '\'' +
                '}';
    }

    public void setCreateTime(Date date) {
    }
}

TestRedisSet

package com.ljx.springboot_redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;
import java.util.Set;

/**
 * @Author: Ljx
 * @Date: 2021/12/1 20:48
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisSet {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    //增加
    @Test
    public void testAdd(){
        redisTemplate.opsForSet().add("Students","zhangsan","lishi","wangwu","Zhangsan");
    }

    //查询
    @Test
    public void testFind(){
        //查询所有元素
        Set<String> students = redisTemplate.opsForSet().members("Students");
        for (String student : students) {
            System.out.println(student);
        }

        //随机获取一个元素
        String students1 = redisTemplate.opsForSet().randomMember("Students");
        System.out.println(students1);

        //随机获取多个元素【可能会重复】
        List<String> list = redisTemplate.opsForSet().randomMembers("Students", 2);
        for (String s : list) {
            System.out.println(s);
        }
    }

    //删除
    @Test
    public void testRemove(){
        //移除元素，并返回移除成功个数
        Long remove = redisTemplate.opsForSet().remove("Students", "zhangsan", "wangwu");
        System.out.println(remove);

        //随机移除指定集合中的多少个元素
        List<String> students = redisTemplate.opsForSet().pop("Students", 2);
        for (String student : students) {
            System.out.println(student);
        }
    }

    //多集合操作
    @Test
    public void testMoreSet(){
        redisTemplate.opsForSet().add("names1","zhangsan","li","wangwu");
        redisTemplate.opsForSet().add("names2","zhangsan","li","zhaoliu");

        //取交集
        Set<String> intersect = redisTemplate.opsForSet().intersect("names1", "names2");
        for (String s : intersect) {
            System.out.println(s);
        }
        //取并集
        Set<String> union = redisTemplate.opsForSet().union("names1", "names2");
        for (String s : union) {
            System.out.println(s);
        }
        //取差集[第一个集合中存在，但第二个集合中不存在的元素]
        Set<String> difference = redisTemplate.opsForSet().difference("names2", "names1");
        for (String s : difference) {
            System.out.println(s);
        }

    }
}

TestRedisZSet

package com.ljx.springboot_redis;

import org.junit.Before;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Set;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
class TestRedisZSet {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void testAdd(){
        redisTemplate.opsForZSet().add("student","wangwu",60);
        redisTemplate.opsForZSet().add("student","lishi",100);
        redisTemplate.opsForZSet().add("student","zhangshan",90);
    }

//    分数的增减
    @Test
    public void testScore(){
        // 增加分数
        redisTemplate.opsForZSet().incrementScore("student","wangwu",30);

        // 减少分数
        redisTemplate.opsForZSet().incrementScore("student","wangwu",-50);
    }

    // 查询一个元素的信息
    @Test
    public void testFindOne(){
        //查询一个元素的分数
        Double score = redisTemplate.opsForZSet().score("student", "wangwu");
        System.out.println(score);

        //查询一个元素在集合中的排名  排名从0开始
        Long rank = redisTemplate.opsForZSet().rank("student", "zhangshan");
        System.out.println(rank);

    }

    //根据区间获取列表
    @Test
    public void testFindList(){
        //根据排名区间获取元素列表
        Set<String> students = redisTemplate.opsForZSet().range("student",0,2);
        for (String student : students) {
            System.out.println(student);
        }

        System.out.println("-------------");
        Set<ZSetOperations.TypedTuple<String>> student = redisTemplate.opsForZSet().rangeWithScores("student", 0, 2);
        for (ZSetOperations.TypedTuple<String> stringTypedTuple : student) {
            System.out.println(stringTypedTuple.getValue()+"同学，得了"+stringTypedTuple.getScore()+"分");
        }
        System.out.println("-----------------------------");
        //根据排名区间获取元素列表
        Set<String> students1 = redisTemplate.opsForZSet().rangeByScore("student",50,100);
        for (String student1 : students1) {
            System.out.println(student1);
        }

        System.out.println("-------------");
        Set<ZSetOperations.TypedTuple<String>> student1 = redisTemplate.opsForZSet().rangeByScoreWithScores("student", 50, 100);
        for (ZSetOperations.TypedTuple<String> stringTypedTuple : student1) {
            System.out.println(stringTypedTuple.getValue()+"同学，得了"+stringTypedTuple.getScore()+"分");
        }
    }


    //统计
    @Test
    public void testCount(){
        //统计一个集合中元素
        Long student = redisTemplate.opsForZSet().zCard("student");
        System.out.println(student);

        //根据一个分数区间统计元素数量
        Long count = redisTemplate.opsForZSet().count("student", 50, 100);
        System.out.println(count);
    }

    //删除
    @Test
    public void testRemove(){
        //根据key-value删除 value允许传入多个
        redisTemplate.opsForZSet().remove("student","zhangsan","lisi");

        //根据排名区间删除
        redisTemplate.opsForZSet().removeRange("student",0,1);

        //根据分数区间删除
        redisTemplate.opsForZSet().removeRangeByScore("student",70,90);
    }
}
Spring Boot 集成Redis 实现增删改查
weixin_45863786的博客
05-30 1361
spring boot 集成redis 实现CRUD 1：添加pom依赖 <!-- redis 缓存 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &
Spring Boot—— 整合Redis增删改查（极简）
那杯热咖啡
09-03 1623
在传统的 SSM 中，需要开发者自己来配置 Spring Data Redis ，这个配置比较繁琐，主要配置 3 个东西：连接池、连接器信息以及 key 和 value 的序列化方案。 在 Spring Boot 中，经过Spring Boot的整合封装与自动化配置，在Spring Boot中整合Redis已经变得非常容易了，开发者只需要引入Spring Data Redis依赖，...
SpringBoot快速上手——《四》：SpringBoot 集成Redis +SpringCache做缓存
weixin_41254252的博客
12-18 342
SpringBoot 集成Redis +SpringCache做缓存 一.给user加缓存 1.首先创建springboot-redis-cache模块，并把springboot-restful-api的内容复制过来。 2.修改三层架构，即加service层 添加service.UserService接口，再创建实现类service.impl.UserServiceimpl，记得实现类要加上@S...
第二十节：学习Redis缓存数据库实现增删改查（自学Spring boot 3.x的第五天）
Mero技术博客
09-20 1472
这节记录下如何使用redis缓存数据库。本文只记录了增，其它的也大差不差。
在springMVC中java操作redis的封装的增删改查demo
11-07
在springMVC中java操作redis的封装的增删改查demo --------------
Springboot整合Redis实现增删查改
f234344435的博客
05-19 1444
1.添加pox.xml依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- 通用池 --> <dependency> &
SpringBoot 快速集成 redisson 并对 List 数据类型进行增删改查的操作（包含 RedissonConfig 配置）
new_baibai的博客
04-15 1283
SpringBoot 快速集成 Redisson
Java spring-boot-starter-data-redis redis删除list中的值
苏雨丶
06-05 4198
/** * 删除list集合 * @param key */ public void delete(String key) { //保留集合中索引0，0之间的值，其余全部删除 所以list只有有一个值存在 listOperations.trim(key,0,0); //将list中的剩余的一个值也删除 ...
springboot操作redis
A1916403680的博客
09-22 370
springboot操作redis
SpringBoot2.0搭建：集成MyBatis，热部署，redis写的增删改查demo（二）
凉城古梦猫扑街的博客
06-18 2433
上一篇搭建起了大体架构，这一篇写个增删改查demo7、测试显示table 信息  (建table，在sql 里面添加几条数据，显示到页面)8、增加热部署功能  （自动刷新后台java，xml代码变动情况，无需手动重启，不过idea对它支持不大友好，建议idea写完框架后用 sts（eclipse对spring包的集成）继续修改）9、增加 redis设置   （这个著名的高性能sql不用多说了吧？自...
springboot的hash 实现增删改查
最新发布
12-28
在Spring Boot应用中，可以通过集成Redis并使用`Hash`结构来高效地执行增删改查(CRUD)操作。下面是一个具体的例子说明如何配置以及编写代码完成这些基本的操作。 #### 配置依赖项 为了使项目能够访问Redis服务，在...
es基本用法(六)——整合SpringBoot进行增删改查
余额一个亿
01-15 1630
微信公众号：Feature社区 引入依赖 说明:transport-netty4-client依赖是报了netty被占用(貌似是这个异常)的时候需要引入的包,通常redis与es一起使用时会报错，此时需要引入该包,一般情况不需要引入此包 <!-- Spring Boot Elasticsearch 依赖 --> <dependency> <g...
Redis入门篇
Ziman_的博客
09-11 118
1、Redis是基于内存的key-value结构的数据库，mysql是基于磁盘。基于内存存储，读写性能高适合存储热点数据（热点商品、资讯、新闻)企业应用广泛（官网：https://redis.io 中文网：https://www.redis.net.cn/）2、Redis的的Windows版属于绿色软件，直接解压即可使用，解压后目录结构如下：在上图文件目录cmd一下，后输入命令，启动服务客户端连接redis服务3、Redis数据类型① 5种常用数据类型介绍。
cpp map 获取所有 key_「Java」基础27：Map集合
weixin_39628186的博客
11-20 1790
Map，这个单词很多人都认识，不过第一反应应该是“地图”，其实它还有一个意思叫“映射”。地图从某种意义上就是映射的意思。什么叫做映射呢？地图上的一个点，就对应着现实生活中的一个地方，这种一一对应的关系就叫映射。在Java里面，Map就是满足这种一一映射关系的集合，也叫双列集合。前几天学的集合叫Collecion，是单列集合。Map存储元素是一对一对的存的(就像夫妻一样)，所以又叫夫妻集合。Coll...
springboot整合redis缓存的增删改查
weixin_55666891的博客
07-27 1845
Springboot整合Reids使用
springboot对于redis的增删改查
09-10 5124
1.下载redis，安装之后，打开redis服务器。不过有绿色版的，直接打开redis服务器可执行文件，启动redis服务器。 2.在pom.xml配置文件中添加redis依赖包 org.springframework.boot spring-boot-starter-redis 1.3.8.RELEASE 3.在application.propert
1 Springboot中使用redis，自动缓存、更新、删除
热门推荐
tianyaleixiaowu的专栏
04-21 6万+
springboot整合redis，如何用redis做分页查询，redis条件查询
SpringBoot+mysql+Redis整合增删改查操作
u010312671的专栏
04-05 8984
前言: 本文通过记录SpringBoot+springMVC+redis+mysql来实现web项目中增删改查的具体操作。 redis做缓存数据库，针对于频繁需要查询或者解决单点问题都会把数据存到redis来分担服务器压力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值