Redis(学习目标、Redis安装及介绍、Redis-cli操作Redis、Java操作Redis、Redis持久化方案、Redis搭载主从复用、SpringData、缓存穿透,缓存击穿,缓存雪崩)

一、学习目标

在这里插入图片描述

二、Redis的介绍及安装

Redis 是一个开源(BSD许可)的,内存中的数据结构存储系统,它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构,如 字符串(strings) , 散列(hashes) , 列表(lists), 集合(sets) , 有序集合(sorted sets) 与范围查询, bitmaps, hyperloglogs 和 地理空间(geospatial) 索引半径查询。 Redis 内置了复制(replication),LUA脚本(Lua scripting),LRU驱动事件(LRU eviction),事务(transactions)和不同级别的 磁盘持久化(persistence), 并通过Redis哨兵(Sentinel) 和自动分区(Cluster)提供高可用性(high availability)

1.Redis历史简介

2008年,意大利一家创业公司Merzia的创始人Salvatore Sanfilippo为了避免MySQL的低性能,亲自定做一个数据库,并于2009年开发完成,这个就是Redis。
从2010年3月15日起,Redis的开发工作由VMware主持。
从2013年5月开始,Redis的开发由Pivotal赞助。
说明:Pivotal公司是由EMC和VMware联合成立的一家新公司。Pivotal希望为新一代的应用提供一个原生的基础,建立在具有领导力的云和网络公司不断转型的IT特性之上。Pivotal的使命是推行这些创新,提供给企业IT架构师和独立软件提供商。

2.支持的数据类型

string 、 hash 、 list 、 set 、 sorted set

3.安装

[1]下载地址

http://redis.io/

[2]上传至服务器

在这里插入图片描述

[3]解压
tar zxvf redis-5.0.3.tar.gz
[4] 安装依赖
yum -y install gcc-c++ autoconf automake

在这里插入图片描述

[5]预编译

切换到解压目录

cd redis-5.0.3/ 
make

在这里插入图片描述

[6]安装

创建安装目录

mkdir -p /usr/local/redis

不使用:make install(make install默认安装到/usr/local/bin目录下)
使用:如果需要指定安装路径,需要添加PREFIX参数

make PREFIX=/usr/local/redis/ install

在这里插入图片描述
安装成功如图
在这里插入图片描述
Redis-cli :客户端
Redis-server:服务器端

[7]启动
安装的默认目标路径:/usr/local/redis/bin

在这里插入图片描述
启动

./redis-server

在这里插入图片描述
默认为前台启动,修改为后台启动

切换至redis的解压目录,本例解压迷路为/root/temp/redis-5.0.5

cp redis.conf /usr/local/redis/bin/

在这里插入图片描述
修改安装路径下的redis.conf,将 daemonize 修改为yes
在这里插入图片描述
在这里插入图片描述
启动时,指定配置文件路径即可
在这里插入图片描述

[8] 通过windows客户端访问

安装Redis客户端
在这里插入图片描述
建立连接失败
修改配置文件redis.conf
注释掉 bind 127.0.0.1可以使所有的ip访问redis,若是想指定多个ip,但并不是所有的ip访问,可以bind设置
在这里插入图片描述
关闭保护模式,设置为no
在这里插入图片描述
添加访问认证
在这里插入图片描述
修改后使用kill命令杀死
在这里插入图片描述
再次连接->成功
在这里插入图片描述
默认数据库的数量是16
在这里插入图片描述
我们可以可以修改默认数据库的数量
修改成默认为20个数据库
在这里插入图片描述
修改后kill-9 XXXX杀死进程,重启Redis即可看到效果
在这里插入图片描述
在这里插入图片描述

三、关系型数据库与非关系型数据库

1. 关系型数据库

采用关系模型来组织数据的数据库,关系模型就是二维表格模型。一张二维表的表名就是关系,二维表中的一行就是一条记录,二维表中的一列就是一个字段。
优点

  • 容易理解
  • 使用方便,通用的sql语言
  • 易于维护,丰富的完整性(实体完整性、参照完整性和用户定义的完整性)大大降低了数据冗余和数据不一致的概率
    缺点
  • 磁盘I/O是并发的瓶颈
  • 海量数据查询效率低
  • 横向扩展困难,无法简单的通过添加硬件和服务节点来扩展性能和负载能力,当需要对数据库进行。升级和扩展时,需要停机维护和数据迁移
  • 多表的关联查询以及复杂的数据分析类型的复杂sql查询,性能欠佳。因为要保证acid,必须按照三范式设计。
    数据库
    Orcale,Sql Server,MySql,DB2

2.非关系型数据库

非关系型,分布式,一般不保证遵循ACID原则的数据存储系统。键值对存储,结构不固定。
优点

  • 根据需要添加字段,不需要多表联查。仅需id取出对应的value
  • 适用于SNS(社会化网络服务软件。比如facebook,微博)
  • 严格上讲不是一种数据库,而是一种数据结构化存储方法的集合
    缺点
  • 只适合存储一些较为简单的数据
  • 不合适复杂查询的数据
  • 不合适持久存储海量数据
    数据库
  • K-V:Redis,Memcache
  • 文档:MongoDB
  • 搜索:Elasticsearch,Solr
  • 可扩展性分布式:HBase
    在这里插入图片描述

四、Redis-cli操作Redis

1.Redis-cli连接Redis

-h :用于指定ip
-p :用于指定端口
-a :用于指定认证密码
在这里插入图片描述
ping命令返回pong(进入redis-cli后,若输入ping后返回pong,则说明连接正常)
在这里插入图片描述
指定database
在这里插入图片描述

2.Redis-cli操作Redis

[1]操作String

set 添加一条string类型数据
get 获得一条string类型的数据
mset 获得多条string类型的数据
mget 获得多条string类型的数据
在这里插入图片描述

[2]操作hash

hset 添加一条hash类型的数据
hget 获得一条hash类型的数据
hmset 添加多条hash类型的数据
hmget 获得多条hash类型的数据
hgetAll 获取指定索引hash类型的数据
hdel 删除指定hash类型的数据 (一条或多条)
在这里插入图片描述
在这里插入图片描述

[3]操作list

lpush 左(头)添加list类型的数据
rpush 右(尾)添加list类型的数据
lrange 获取list类型数据start起始下标 end结尾下标 包含关系
llen 获取条数
lren 删除列表中几个指定list类型的数据
在这里插入图片描述

[4]操作set

sadd 添加set类型的数据
smembers 获取set类型数据
scard 获取条数
srem 删除数据
在这里插入图片描述

[5]操作sorted set

sorted set 是通过分数值来进行排序的,分数值越大越靠后
zadd 添加sorted set类型数据
zrange 获取sorted set类型数据
zcard 获取条数
zrem 删除数据
zadd 需要将Float或者Double类型分数值参数,放置在值参数之前
在这里插入图片描述
Redis中以层级关系、目录形式存储数据
在这里插入图片描述
在这里插入图片描述

设置key的失效时间 Redis 有四个不同的命令可以用于设置键的生存时间(键可以存在多久)或过期时间(键什么时候会被删除) :
EXPlRE <key> <ttl> :用于将键 key 的生存时间设置为 ttl 秒。
PEXPIRE <key> <ttl> :用于将键 key 的生存时间设置为 ttl 毫秒。
EXPIREAT <key> < timestamp> :用于将键 key 的过期时间设置为timestamp所指定的秒数时间戳。
PEXPIREAT <key> < timestamp >:用于将键 key 的过期时间设置为 timestamp 所指定的毫秒数时间戳。
TTL :获取的值为-1说明此 key 没有设置有效期,当值为-2时证明过了有效期。

方法一
在这里插入图片描述
方法二
在这里插入图片描述
方式三
 第一个参数: key
 第二个参数: value
 第三个参数: NX 是不存在时才setXX 是存在时才set
 第四个参数:EX是秒, PX 是毫秒
 在这里插入图片描述
删除
del :用于删除数据(通用,适用于所有数据类型)
hdel :用于删除hash类型数据
在这里插入图片描述
tips:命令为java中方法名,参数:去除括号,引号,将逗号变空格即可
在这里插入图片描述
zadd需要将Float或者Double类型参数,放置在值参数之前
在这里插入图片描述

[6]通用命令
#获取所有的key
keys *
#通用删除
del k
#层级目录,通过:实现
set k:k:k v
#设置失效时间,nx不存在成功,xx存在才成功
set k v ex|px time [nx|xx]
expire k ex|px time [nx|xx]
#获取失效时间
ttl k
pttl k

五、 Java操作Redis

1. 创建项目

[1]用java手脚架创建项目

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

[2]添加依赖
 <dependencies>
        <!--spring data redis 组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <!--
                1.x 的版本默认采用的连接池技术是 Jedis,
                2.0 以上版本默认连接池是 Lettuce, 如果采用 Jedis,需要排除 Lettuce 的依赖。
            -->
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--web组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <!--test组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
[3]配置文件

application.yml文件

spring:
  redis:
    # Redis服务器地址
    host: 192.168.10.100
    # Redis服务器端口号
    port: 6379
    # Redis服务器密码
    password: root
    # 选择哪个库,默认0
    database: 0
    # 连接超时时间
    timeout: 10000ms
    jedis:
      pool:
        # 最大连接数 默认8
        max-active: 1024
        # 最大默认阻塞时间
        max-wait: 10000ms
        # 最大空闲连接 默认8
        max-idle: 200
        # 最小空闲连接 默认0
        min-idle: 5

2.java连接Redis

 /**
     * 连接数据库
     */
    @Test
    void initConn01() {
        //创建Jedis对象,连接Redis服务
        Jedis jedis = new Jedis("192.168.10.100",6379);
        //设置验证密码
        jedis.auth("root");
        //指定数据库 默认是0
        jedis.select(1);

        //使用ping命令,测试连接是否成功
        String result = jedis.ping();
        System.out.println(result);//若连接成功,则打印PONG
        //添加一条数据
        jedis.set("userName","zhangsan");
        //获取一条数据
        String userName = jedis.get("userName");
        System.out.println(userName);

        //释放资源
        if (jedis!=null){
            jedis.close();
        }
    }

运行结果
在这里插入图片描述

3.通过Redis连接池获取连接对象并操作服务器

 /**
     * 通过Redis连接池获取连接对象
     */
    @Test
    void  initConn02(){
        //初始化Redis客户端连接池
        JedisPool jedisPool = new JedisPool(new JedisPoolConfig(),"192.168.10.100",6379,10000,"root");
        //从连接池获取连接
        Jedis jedis =jedisPool.getResource();
        // 指定数据库 默认是0
        jedis.select(2);
        //使用ping命令,测试是否连接成功
        String result = jedis.ping();
        System.out.println("连接测试结果为:"+result);
        //添加一条数据
        jedis.set("usenName","root");
        //获取一条数据
        String userName = jedis.get("userName");
        System.out.println("userName为 "+userName);
        //释放资源
        if (jedis!=null){
            jedis.close();
        }
    }

运行结果为
在这里插入图片描述

4.封装JedisUtil对外提供连接对象获取方法

新建一个配置类JedisConfig.class

@Configuration
public class JedisConfig {

    //服务器地址
    @Value("${spring.redis.host}")
    private String host;
    //端口
    @Value("${spring.redis.port}")
    private int port;
    //密码
    @Value("${spring.redis.password}")
    private String password;
    //超时时间
    @Value("${spring.redis.timeout}")
    private String timeout;
    //最大连接数
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxTotal;
    //最大阻塞等待时间
    @Value("${spring.redis.jedis.pool.max-wait}")
    private String maxWaitMillis;
    //最大空闲连接
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;
    //最小空闲连接
    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Bean
    public JedisPool redisPoolFactory(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //注意值的转变 应为从配置文件中得到的maxWaitMillis值为String类型的10000ms  ,因此需要将其后两位截取掉之后转成Long类型
        jedisPoolConfig.setMaxWaitMillis(Long.parseLong(maxWaitMillis.substring(0,maxWaitMillis.length()-2)));
        //注意值姓名
        jedisPoolConfig.setMaxTotal(maxTotal);
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMinIdle(minIdle);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig,host,port,Integer.parseInt(timeout.substring(0,timeout.length()-2)),password);
        return jedisPool;
    }
}

修改pom文件中 的test组件
在这里插入图片描述
删除 import org.junit.jupiter.api.Test;
新增导包 import org.junit.Test;
在这里插入图片描述
在测试类上面添加注解@RunWith(SpringRunner.class)
将测试类用public修饰,其中所有的测试方法也用public修饰

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisdemoApplicationTests {

    //自动注入JedisPool
    @Autowired
    private JedisPool jedisPool;

    private Jedis jedis;

    //每个Test执行前执行该方法
    @Before
    public void init(){
        jedis=jedisPool.getResource();
    }
    //每个Test执行后执行该方法
    @After
    public void close(){
        if (jedis!=null){
            jedis.close();
        }
    }
    
 @Test
    public void initConn03(){
        String pong = jedis.ping();
        System.out.println(pong);
    }
}    

运行initConn03()方法,测试是否能连接成功
在这里插入图片描述

5.Java操作Redis五种数据类型

注意:以下步骤是在步骤 4 已经 封装JedisUitl对外提供对象获取方法的前提上进行的

[1]连接与释放
    @Autowired
    private JedisPool jedisPool;

    private Jedis jedis;

    //每个Test执行前执行该方法
    @Before
    public void init(){
        jedis=jedisPool.getResource();
    }
    //每个Test执行后执行该方法
    @After
    public void close(){
        if (jedis!=null){
            jedis.close();
        }
    }
[2]操作string
	/**
     * 操作String
     */
    @Test
    public void testString(){
        //添加一条数据
        jedis.set("userName","张三");
        jedis.set("pwd","1111");

        //添加多条数据
        jedis.mset("address","shangHai","gender","man");

        //获取一条数据
        String userName = jedis.get("userName");
        System.out.println(userName);

        //获取多条数据
        List<String> list = jedis.mget("pwd", "address", "gender");
        list.forEach(System.out::println);
        //删除
        jedis.del("userName");
    }

执行结果
在这里插入图片描述

[3]操作hash
  /**
     * 操作Hash
     */
    @Test
    public void testHash(){
        /**
         * 添加一条数据
         * 参数一:redis的key
         * 参数二:hash的key
         * 参数三:hash的value
         */
        jedis.hset("userInfo","userName","张三");

        //添加多条数据
        Map<String,String> map = new HashMap<>();
        map.put("age","18");
        map.put("gender","women");
        //将map中的值存入userInfo中
        jedis.hmset("userInfo",map);

        System.out.println("-----获取一条数据------");
        //获取一条数据
        String userName = jedis.hget("userInfo", "userName");
        System.out.println(userName);


        System.out.println("------获取多条数据-----");
        //获取多条数据
        List<String> list = jedis.hmget("userInfo", "age", "gender");
        list.forEach(System.out::println);

        System.out.println("----获取Hash类型的所有数据-----");
        //获取Hash类型的所有数据
        Map<String, String> userInfoMap = jedis.hgetAll("userInfo");
        // 遍历map集合
        Set<Map.Entry<String, String>> entries = userInfoMap.entrySet();
        entries.forEach(t-> System.out.println(t.getKey()+"---"+t.getValue()));

        //删除 hash类型的数据
        //jedis.hdel("userInfo","userName");

    }

运行结果
在这里插入图片描述

[4]操作list
  /**
     * 操作list
     */
    @Test
    public void TestList(){
        //左添加
        jedis.lpush("students","王五","李四");
        //右添加
        jedis.rpush("students","赵六","田七");
        
        // 获取 start起始下标 end结束下标 包含关系
        List<String> students = jedis.lrange("students", 0, 2);
        students.forEach(System.out::println);

        //获取总条数
        Long total = jedis.llen("students");
        System.out.println("students的总条数为:"+total);

        //删除1条  删除列表中第一次出现的李四
        jedis.lrem("studnets",1,"李四");

        //删除多条  删除key为students的一整个列表
        jedis.del("students");
    }

在这里插入图片描述

[5] 操作set
	/**
     * 操作set-无序
     */
    @Test
    public void testSet(){
        //添加数据
        jedis.sadd("letters","aaa","bbb","ccc","ddd","eee");
        //获取数据
        Set<String> letters = jedis.smembers("letters");
        letters.forEach(System.out::println);

        //获取总条数
        Long scard = jedis.scard("letters");
        System.out.println("set的总条数为:"+scard);
        //删除
        jedis.srem("letters","aaa","ccc");
    }

在这里插入图片描述

[6] 操作sorted set
 @Test
    public void testSortedSet(){
        Map<String,Double> scoreMembers = new HashMap<>();
        scoreMembers.put("张三",3D);
        scoreMembers.put("李四",7D);
        scoreMembers.put("王五",4D);
        scoreMembers.put("赵六",2D);
        scoreMembers.put("田七",5D);

        //添加数据
        jedis.zadd("score",scoreMembers);

        //获取数据
        Set<String> score = jedis.zrange("score", 0, 4);
        score.forEach(System.out::println);

        //总条数
        Long total = jedis.zcard("score");
        System.out.println("总条数为:"+total);
        //删除
        jedis.zrem("score","李四","田七");
    }

按照分数从小到大排序
在这里插入图片描述

[7]Redis中以层级关系、目录形式存储数据
 // Redis中以层级关系、目录形式存储数据
    @Test
    public void testdir(){
        jedis.set("user:01", "user_zhangsan");
        System.out.println(jedis.get("user:01"));
    }

在这里插入图片描述

[8]设置key的失效时间

设置key的失效时间 Redis 有四个不同的命令可以用于设置键的生存时间(键可以存在多久)或过期时间(键什么时候会被删除) :
EXPlRE <key> <ttl> :用于将键 key 的生存时间设置为 ttl 秒。
PEXPIRE <key> <ttl> :用于将键 key 的生存时间设置为 ttl 毫秒。
EXPIREAT <key> < timestamp> :用于将键 key 的过期时间设置为timestamp所指定的秒数时间戳。
PEXPIREAT <key> < timestamp >:用于将键 key 的过期时间设置为 timestamp 所指定的毫秒数时间戳。
TTL :获取的值为-1说明此 key 没有设置有效期,当值为-2时证明过了有效期。

 	/**
     *  设置key的失效时间
     */
    @Test
    public void testExpire(){
        //方法一:
        jedis.set("code", "test");
        jedis.expire("code", 180);// 180秒
        jedis.pexpire("code", 180000L);// 180000毫秒
        jedis.ttl("code");// 获取秒

        //方法二
        jedis.setex("code",180,"test");//180秒
        jedis.psetex("code",180000L,"test");
        jedis.pttl("code");//获取秒

        //方法三
        SetParams setParams = new SetParams();
        //不存在的时候才能设置成功
        // setParams.nx();
        // 存在的时候才能设置成功
        setParams.xx(); //设置失效时间,单位秒
        // setParams.ex(30);
        // 查看失效时间,单位毫秒
        setParams.px(30000);
        jedis.set("code","test",setParams);
    }
[9]获取所有key&事务&删除
 //获取所有的key
    @Test
    public void testAllKeys(){
        //当前库key的数量
        System.out.println(jedis.dbSize());
        //当前库key的名称
        Set<String> keys = jedis.keys("*");
        keys.forEach(System.out::println);
    }

在这里插入图片描述
操作事务

 //操作事务
    @Test
    public void testMulti(){
        Transaction tx =jedis.multi();
        //开启事务
        tx.set("tel","10010");
        //提交事务
        //tx.exec();
        //回滚事务
        tx.discard();
    }
   

删除

 //删除
    @Test
    public void testDelete(){
        // 删除 通用 适用于所有数据类型
        jedis.del("score");
    }
[10] 操作byte

先写一个序列化和反序列化的工具类
SerializeUtil.java

/**
 * 序列化工具类
 */
public class SerializeUtil {
    /**
     * 将java对象转换为byte数组 序列化过程
     */
    public static byte[] serialize(Object object){
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;

        try {
            //序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
    /***
     * 将byte数组转换为java对象 反序列化
     */
    public static Object unserialize(byte[] bytes){

        if (bytes==null) {
            return null;
        }
        ByteArrayInputStream bais=null;

        try {
            //反序列化
            bais=new ByteArrayInputStream(bytes);
            ObjectInputStream ois =new ObjectInputStream(bais);
            return ois.readObject();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

User.java

public class User implements Serializable {
    private Integer id;
    private String userName;
    private String password;

    public User(Integer id, String userName, String password) {
        this.id = id;
        this.userName = userName;
        this.password = password;
    }

    public User() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

JedisTest

 //操作byte
    @Test
    public void testByte(){
        User user = new User();
        user.setId(2);
        user.setUserName("zhangsan");
        user.setPassword("1111");

        //序列化
        byte[] userKey = SerializeUtil.serialize("user:" + user.getId());
        byte[] userValue = SerializeUtil.serialize(user);
        jedis.set(userKey,userValue);

        //获取数据
        byte[] userResult = jedis.get(userKey);
        //反序列化
        User u = (User)SerializeUtil.unserialize(userResult);
        System.out.println(u);
    }

结果
在这里插入图片描述
存储到Redis中的user内容如下
在这里插入图片描述

六、Redis持久化方案

由于Redis是在内存中存储数据,若Redis发生了一些如宕机之类的意外情况,而内存中是无法保存数据的,这就会造成数据的丢失。而Redis可以作为数据库,它提供了两种方案来持久化数据。方案一:快照。方案二:AOF

1.快照(rdb)

用命令

bgsave

来保存当前的数据。如果是用java操作Redis则有对应的bgsave()方法。

  • 优点:保存起来简单,一个命令就备份了
  • 缺点:我们并不知道什么时候Redis会出问题,所以可能会每执行一条命令,就保存一次快照。这样太麻烦了

进入Redis安装的bin目录,编辑reedis.conf
在这里插入图片描述

用vim打开/usr/local/redis/bin/redis.conf文件,可以配置使用bgsave保存的快照文件名及快照目录

在这里插入图片描述

自动保存条件。
我们可以按照格式在下面添加自动保存条件

如 每30秒,如果达到10个key发生变化,则自动保存数据
save 30 10

在这里插入图片描述
注意:1.自动保存的是发送改变的数据。2.该种方式仍有丢失数据的风险(数据发生改变但不足触发保存条件时宕机,则会丢失一些数据)

2.AOF

快照并不能实时持久化保存数据,因此可以采用AOF保存数据。
进入Redis安装的bin目录,编辑reedis.conf
在这里插入图片描述
找到appendonly,将其后面的 no 改为yes。完成该步骤后,快照方式的rdb文件会默认失效。
在这里插入图片描述
至此,AOF方式持久化方案修改完成。
AOF原理:将我们输入的所有命令保存至appendonly.aof文件中,在Redis重启时,会将该文件下所有存储的命令读取出来,然后在执行一遍。因此,当数据量大时开启Redis的速度会非常慢。

3.两种方式的差异

  1. rdb是将数据存储在文件中,而aof是将命令存储在文件中。
  2. rdb不能保证数据不会丢失,而aop可以。
    rdb可以使用bgsave手动保存,也可以设置自动保存条件,当在一段时间内有改动的数据达到某个值时,会将修改后的数据保存在rdb文件中。如果单位时间内变动的数据条数未达到指定的值而redis宕机,则可能会导致数据丢失。而aof是实时保存,将每一条指令都保存在文件中,redis启动的时候会先读取文件中的指令,这些指令运行完毕后redis才启动完毕。
  3. rdb存储数据占用空间较小,而aof方式占用空间较大(aof可以设置文件大小达到某个阈值时缩写)。
  4. rdb和aof两种方式可同时开启,集成了2者的优点,但运行效率会降低。

七、redis搭载主从复用

Redis支持主从复用。数据可以从主服务器向任意数量的从服务器上同步,同步使用的是发布/订阅机制。Mater Slave的模式,从Slave向Master发起SYNC命令。
 可以是1 Master 多Slave,可以分层,Slave下可以再接Slave,可扩展成树状结构。
 因为没有两台电脑,所以只能在一台机器上搭建两个Redis服务端。
 这里使用单机来模拟redis 主从服务器 ,实现读写分离配置

1.读写分离

[1]准备三个装了redis的虚拟机

将linux系统关闭。在原有系统的基础上克隆两个虚拟机
在这里插入图片描述
选择要复制的计算机,右击->管理->克隆->下一步->下一步->创建完整克隆->
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
完成后,需要修改虚拟机的IP地址。(应为同时开启,ip地址会产生冲突)。
修改IP地址

 cd  /etc/sysconfig/network-scripts/
 vim ifcfg-ens33

修改文件内容,仅需修改IPADDR即可

IPADDR=192.168.0.230 #静态IP  
GATEWAY=192.168.0.1 #默认网关  
NETMASK=255.255.255.0 #子网掩码  
DNS1=192.168.0.1 #DNS 配置  
DNS2=8.8.8.8        #谷歌地址

ESC:wq保存并退出
使用service network restart命令,重启网络服务。

[2]配置主节点
  1. 将redis解压后目录中的redis.conf文件拷贝至/usr/local/redis/目录下
    在这里插入图片描述
  2. 修改redis.conf
    2.1 关闭ip绑定
    在这里插入图片描述
    2.2关闭保护模式
    在这里插入图片描述
    2.3 打开后台启动
    在这里插入图片描述
    2.4 修改密码
    在这里插入图片描述
    2.5 添加从服务器访问主服务器认证
    在这里插入图片描述

ESC :wq保存并退出
至此,主节点配置完毕

[3]配置从节点

在充当从节点的虚拟机上修改配置文件

  1. 将redis解压后目录中的redis.conf文件拷贝至/usr/local/redis/目录下
    在这里插入图片描述
  2. 修改redis.conf
    2.1. 关闭ip绑定
    在这里插入图片描述
    2.2. 关闭保护模式
    在这里插入图片描述
    2.3. 打开后台启动
    在这里插入图片描述
    2.4. 修改密码
    在这里插入图片描述
    2.5. 添加从服务器访问主服务器认证(和主节点不同)
    在这里插入图片描述
    ESC :wq保存并退出
    至此,从节点1配置完毕,按照相同的步骤配置从节点2
[4]启动redis

用修改的配置文件redis.conf来打开redis。(所有节点均按照该方式启动)
在这里插入图片描述
用cli登录redis
在这里插入图片描述
使用info replication 查看状态
在这里插入图片描述

[5]测试

搭建完成后,主节点可以,但从节点默认情况下只能读
在从节点写数据会提示错误:只有读权限,没有写的权限
在这里插入图片描述
在主节点写数据
在这里插入图片描述
在从节点读
在这里插入图片描述
在配置文件中设置从节点可读
在这里插入图片描述

2.主备切换

[1]哨兵

哨兵会监控整个主从环境。当发现主节点宕机之后,它会从剩下的从节点上选举新的主节点,其他的从节点会搭载到该主节点上去。当宕机的注解点修复后重新上线时,它会变为从节点搭载到此时的主节点上。

[2]配置哨兵

将解压后的redis目录中的sentinel.conf文件复制到/usr/local/redis-5.0.5目录下
在这里插入图片描述
编辑sentinel.conf文件

  1. 开启后台启动

  2. 设置日志文件路径(具体到文件)
    在这里插入图片描述

  3. 设置要监控的主节点内容
    在这里插入图片描述

  4. 设置密码
    在这里插入图片描述

最后一个数字2的意思是大于一半。如果整个主从节点中,有一半以上的节点都连不上主节点,才触发选举机制。本例中只有3个节点,大于一半则为2

在这里插入图片描述
在这里插入图片描述
wq保存并退出。
同理,其他的节点做出同样的修改。

[3]开启哨兵

开启所有节点的哨兵
在这里插入图片描述
其他节点做相同操作

  • 搜索redis进程查看哨兵进程是否开启
    在这里插入图片描述
  • 查看日志
tail -f sentinel.log

在这里插入图片描述

[4]模拟主节点宕机

强制关闭主节点redis进程
在这里插入图片描述
等待30秒(sentinel.conf文件中默认配置的,若从节点超过30秒后未成功连接主节点,则进行选举)。
在这里插入图片描述
查看日期文件,发现192.168.10.102节点成为了新的主节点。
用192.168.10.102节点登录cli

bin/redis-cli -a root
info replication

在这里插入图片描述
重启192.168.10.100节点,进入cli,用info replication查看状态
在这里插入图片描述

八、SpringDataRedis

1.创建项目

[1]使用idea手脚架工具创建项目

在这里插入图片描述
在这里插入图片描述

[2]添加依赖
<dependencies>
        <!--redis组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--对象池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
		<!--修改test依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
[3]添加application.yml配置文件
spring:
  redis:
    # Redis服务器地址
    host: 192.168.10.100
    # Redis服务器端口号
    port: 6379
    # Redis服务器密码
    password: root
    # 选择哪个库,默认0
    database: 0
    # 连接超时时间
    timeout: 10000ms
    jedis:
      pool:
        # 最大连接数 默认8
        max-active: 1024
        # 最大默认阻塞时间
        max-wait: 10000ms
        # 最大空闲连接 默认8
        max-idle: 200
        # 最小空闲连接 默认0
        min-idle: 5

2. Lettuce和Jedis的区别

Jedis 是一个优秀的基于 Java 语言的 Redis 客户端,但是,其不足也很明显: Jedis 在实现上是直接连接 Redis-Server,在多个线程间共享一个 Jedis 实例时是线程不安全的,如果想要在多线程场景下
使用 Jedis ,需要使用连接池,每个线程都使用自己的 Jedis 实例,当连接数量增多时,会消耗较多的物理资源。

Lettuce 则完全克服了其线程不安全的缺点: Lettuce 是基于 Netty 的连接(StatefulRedisConnection),Lettuce 是一个可伸缩的线程安全的 Redis 客户端,支持同步、异步和响应式模式。多个线程可以共享一个连接实例,而不必担心多线程并发问题。它基于优秀 Netty NIO 框架构建,支持 Redis 的高级功能,如 Sentinel,集群,流水线,自动重新连接和 Redis 数据模型。

3. 测试环境测试环境是否搭建成功

@SpringBootTest(classes = SpringdataredisApplication.class)
@RunWith(SpringRunner.class)
public class SpringdataredisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
   public void test() {
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        ops.set("username","lisi");
        ValueOperations value = redisTemplate.opsForValue();
        value.set("name","wanmgwu");
        System.out.println(value.get("name"));
        System.out.println(ops.get("username"));
    }
}

运行结果
在这里插入图片描述

4.自定义模板解决序列化问题

默认情况下的模板 RedisTemplate<Object, Object>,默认序列化使用的是JdkSerializationRedisSerializer ,存储二进制字节码。这时需要自定义模板,当自定义模板后又想存储 String 字符串时,可以使StringRedisTemplate的方式,他们俩并不冲突。

  • 序列化问题:
    要把 domain object 做为 key-value 对保存在 redis 中,就必须要解决对象的序列化问题。Spring Data Redis给我们提供了一些现成的方案:
    JdkSerializationRedisSerializer 使用JDK提供的序列化功能。 优点是反序列化时不需要提供类型信息(class),但缺点是序列化后的结果非常庞大,是JSON格式的5倍左右,这样就会消耗 Redis 服务器的大量内存。

Jackson2JsonRedisSerializer 使用 Jackson 库将对象序列化为JSON字符串。优点是速度快,序列化后的字符串短小精悍。但缺点也非常致命,那就是此类的构造函数中有一个类型参数,必须提供要序列化对象的类型信息(.class对象)。通过查看源代码,发现其只在反序列化过程中用到了类型信息。
GenericJackson2JsonRedisSerializer通用型序列化,这种序列化方式不用自己手动指定对象的 Class。

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory){

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //为String类型Key设置序列器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //为String类型value设置序列器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        //为hash类型key设置序列器
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //为hash类型value设置序列器
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}
 	@Test
    public void testSerial(){
        User user =new User();
        user.setId(1);
        user.setUserName("张三");
        user.setPassword("1234");

        ValueOperations<String,Object> value = redisTemplate.opsForValue();
        value.set("userInfo",user);
        System.out.println(value.get("userInfo"));
    }

运行结果
在这里插入图片描述

5.操作string

	//操作string
    @Test
    public void testString(){
        ValueOperations<String,Object> value = redisTemplate.opsForValue();
        //添加一条数据
        value.set("username","zhangsan");
        value.set("age","18");
        //redis中以层级关系、目录关系存储数据
        value.set("user:01","lisi");
        value.set("user:02","wangwu");
        //添加多条数据
        Map<String,String> userMap=new HashMap<>();
        userMap.put("address","shanghai");
        userMap.put("gender","1");
        value.multiSet(userMap);

        //获取一条数据
        Object username = value.get("username");
        System.out.println("-----获取一条数据-----");
        System.out.println(username);

        //获取多条数据
        System.out.println("----获取多条数据---");
        List<String> keys = new ArrayList<>();
        keys.add("username");
        keys.add("address");
        keys.add("age");
        keys.add("address");

        List<Object> resultList = value.multiGet(keys);
        //遍历结果
        resultList.forEach(System.out::println);
    }

运行结果
在这里插入图片描述

6.操作hash

    /**
     * 操作hash
     */
    @Test
    public void testHash() {
        /** 添加一条数据
         * 参数一:redis的key
         * 参数二:hash的key
         * 参数三:hash的value
         */
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("user","username","张三");
        //添加多条数据
        HashMap<String, Object> userMap = new HashMap<>();
        userMap.put("address","上海");
        userMap.put("gender","3");
        userMap.put("password","123454");
        hashOperations.putAll("user",userMap);
        
        //获取多条数据
        ArrayList<String> keys = new ArrayList<>();
        keys.add("username");
        keys.add("address");
        keys.add("gender");
        List<String> userList = hashOperations.multiGet("user", keys);
        userList.forEach(System.out::println);

        //获取所有hash类型的数据
        Map<String,Object> user = hashOperations.entries("user");
        Set<Map.Entry<String, Object>> set = user.entrySet();
        //遍历
        set.forEach(t-> System.out.println(t.getKey()+"===="+t.getValue()));
        //删除hash类型的数据
        hashOperations.delete("user","username");
    }

在这里插入图片描述

7.操作list

@Test
    public void testList(){
        ListOperations<String,Object> opsForList = redisTemplate.opsForList();
        // 左添加(上) 单条添加
        opsForList.leftPush("student","WangWu");
        opsForList.leftPush("student","ZhaoLiu");
        //左添加(上) 多条添加
        //opsForList.leftPush("student","WangWu","ZhaoLiu");

        //获取state start起始下标 end结束下标 包含关系
        List<Object> range = opsForList.range("student", 0, 2);
        range.forEach(System.out::println);

        //根据下标获取
        Object student = opsForList.index("student", 1);
        System.out.println(student);
        //获取总条数
        Long total = opsForList.size("student");
        System.out.println("总条数: "+total);

        //删除单条  删除列表中存储的列表中几个出现的Li Si
        opsForList.remove("student",1,"lisi");
        //删除多条
        //redisTemplate.delete("student");
    }

在这里插入图片描述

8.操作Set

	//操作set-无序
    @Test
    public void testSet(){
        SetOperations<String,Object> opsForSet = redisTemplate.opsForSet();
        // 添加数据
        String[] letters = {"aaa","bbb","ccc","ddd","eee"};
        //opsForSet.add("letters","aaa","bbb","ccc","ddd","eee");
        opsForSet.add("letters",letters);
        //获取数据
        Set<Object> lettersSet = opsForSet.members("letters");
        //遍历数据
        lettersSet.forEach(System.out::println);
        //删除数据
        opsForSet.remove("letters","aaa","ccc");
    }

在这里插入图片描述

9.操作sorted set

 // 5.操作sorted set-有序
    @Test
    public void testSortedSet(){
        ZSetOperations<String,Object> zSetOperations = redisTemplate.opsForZSet();
        /**
         * 添加数据
         */
        //创建数据
        DefaultTypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>("张三",7D);
        DefaultTypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<Object>("李四",4D);
        DefaultTypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<Object>("王五",5D);
        DefaultTypedTuple<Object> objectTypedTuple4 = new DefaultTypedTuple<Object>("赵六",2D);
        DefaultTypedTuple<Object> objectTypedTuple5 = new DefaultTypedTuple<Object>("田七",8D);
        //将数据添加到set中
        HashSet<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        tuples.add(objectTypedTuple4);
        tuples.add(objectTypedTuple5);
        //添加数据
        zSetOperations.add("score",tuples);

        //获取数据
        Set<Object> scoreSet = zSetOperations.range("score", 0, 4);
        scoreSet.forEach(System.out::println);

        //获取总条数
        Long total = zSetOperations.size("score");
        System.out.println("总条数"+total);

        //删除数据
        zSetOperations.remove("score","张三","王五");
        //zSetOperations.remove("score"); 删除key为score下的所有数据
    }

在这里插入图片描述

10.获取所有key及删除

   // 获取所有key
    @Test
    public void getAllKeys(){
        //获取当前库所有key的名称
        Set keys = redisTemplate.keys("*");
        keys.forEach(System.out::println);
    }
    //删除
    @Test
    public void testDelete(){
        // 删除 通用 适用于所有数据类型
        redisTemplate.delete("letters");
    }

11.设置key的失效时间

  //设置失效时间
    @Test
    public void testEx(){
        ValueOperations<String,Object> valueOperations = redisTemplate.opsForValue();
        // 方法一:插入一条数据并设置失效时间
        valueOperations.set("code","abcd",180, TimeUnit.SECONDS);
        //方法二:给已存在的key设置失效时间
        redisTemplate.expire("code",180,TimeUnit.SECONDS);
        // 获取指定key的失效时间
        Long l = redisTemplate.getExpire("code");
        System.out.println(l);
    }

在这里插入图片描述

12. SpringDataRedis整合使用哨兵机制

[1]方式一:在配置文件中配置哨兵

application.yml

spring:
  redis:
    # Redis服务器地址
    host: 192.168.10.100
    # Redis服务器端口号
    port: 6379
    # Redis服务器密码
    password: root
    # 选择哪个库,默认0
    database: 0
    # 连接超时时间
    timeout: 10000ms
    jedis:
      pool:
        # 最大连接数 默认8
        max-active: 1024
        # 最大默认阻塞时间
        max-wait: 10000ms
        # 最大空闲连接 默认8
        max-idle: 200
        # 最小空闲连接 默认0
        min-idle: 5
    # 哨兵模式
    sentinel:
      # 主节点名称
      master: mymaster
      # 节点
      nodes: 192.168.10.100:26379,192.168.10.101:26379,192.168.10.102:26379
[2]方式二:编写配置类
@Bean
    public RedisSentinelConfiguration redisSentinelConfiguration(){
        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration()
                //主节点名称
                .master("mymaster")
                //主从服务器地址
                .sentinel("192.168.10.100",26379)
                .sentinel("192.168.10.101",26379)
                .sentinel("192.168.10.102",26379);
        //密码
        redisSentinelConfiguration.setPassword("root");
        return redisSentinelConfiguration;
    }

两种方式选其一即可。

九、如何应对缓存穿透、缓存击穿、缓存雪崩问题

1.Key的过期淘汰机制

Redis可以对存储在Redis中的缓存数据设置过期时间,比如我们获取的短信验证码一般十分钟过期,我们这时候就需要在验证码存进Redis时添加一个key的过期时间,但是这里有一个需要格外注意的问题就是:并非key过期时间到了就一定会被Redis给删除。

[1] 定期删除

Redis 默认是每隔 100ms 就随机抽取一些设置了过期时间的 Key,检查其是否过期,如果过期就删
除。为什么是随机抽取而不是检查所有key?因为你如果设置的key成千上万,每100毫秒都将所有存在
的key检查一遍,会给CPU带来比较大的压力。

[2]惰性删除

定期删除由于是随机抽取可能会导致很多过期 Key 到了过期时间并没有被删除。所以用户在从缓存获
取数据的时候,redis会检查这个key是否过期了,如果过期就删除这个key。这时候就会在查询的时候将
过期key从缓存中清除。

[3] 内存淘汰机制

仅仅使用定期删除 + 惰性删除机制还是会留下一个严重的隐患:如果定期删除留下了很多已经过期的
key,而且用户长时间都没有使用过这些过期key,导致过期key无法被惰性删除,从而导致过期key一直
堆积在内存里,最终造成Redis内存块被消耗殆尽。那这个问题如何解决呢?这个时候Redis内存淘汰机
制应运而生了。Redis内存淘汰机制提供了6种数据淘汰策略:

  • volatile-lru:从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。
  • volatile-ttl :从已设置过期时间的数据集中挑选将要过期的数据淘汰。
  • volatile-random:从已设置过期时间的数据集中任意选择数据淘汰。
  • allkeys-lru :当内存不足以容纳新写入数据时移除最近最少使用的key。
  • allkeys-random:从数据集中任意选择数据淘汰。
  • no-enviction(默认) :当内存不足以容纳新写入数据时,新写入操作会报错。
     一般情况下,推荐使用 volatile-lru 策略,对于配置信息等重要数据,不应该设置过期时间,这样
    Redis就永远不会淘汰这些重要数据。对于一般数据可以添加一个缓存时间,当数据失效则请求会从DB
    中获取并重新存入Redis中。

2.缓存击穿

首先我们来看下请求是如何取到数据的:当接收到用户请求,首先先尝试从Redis缓存中获取到数据,
如果缓存中能取到数据则直接返回结果,当缓存中不存在数据时从DB获取数据,如果数据库成功取到数
据,则更新Redis,然后返回数据
在这里插入图片描述
定义:高并发的情况下,某个热门key突然过期,导致大量请求在Redis未找到缓存数据,进而全部去访问DB请求数据,引起DB压力瞬间增大。
解决方案:
缓存击穿的情况下一般不容易造成DB的宕机,只是会造成对DB的周期性压力。对缓存击
穿的解决方案一般可以这样:

  • Redis中的数据不设置过期时间,然后在缓存的对象上添加一个属性标识过期时间,每次获取到数据时,校验对象中的过期时间属性,如果数据即将过期,则异步发起一个线程主动更新缓存中的数据。但是这种方案可能会导致有些请求会拿到过期的值,就得看业务能否可以接受。
  • 如果要求数据必须是新数据,则最好的方案则为热点数据设置为永不过期,然后加一个互斥锁保证缓存的单线程写。
  • 3.缓存穿透

定义:缓存穿透是指查询缓存和DB中都不存在的数据。比如通过id查询商品信息,id一般大于0,攻击者会故意传id为-1去查询,由于缓存是不命中则从DB中获取数据,这将会导致每次缓存都不命中数据导致每个请求都访问DB,造成缓存穿透。
解决方案:

  • 利用互斥锁,缓存失效的时候,先去获得锁,得到锁了,再去请求数据库。没得到锁,则休眠一段时间重试
  • 采用异步更新策略,无论key是否取到值,都直接返回。value值中维护一个缓存失效时间,缓存如果过期,异步起一个线程去读数据库,更新缓存。需要做缓存预热(项目启动前,先加载缓存)操作。
  • 提供一个能迅速判断请求是否有效的拦截机制,比如,利用布隆过滤器,内部维护一系列合法有效的key。迅速判断出,请求所携带的Key是否合法有效。如果不合法,则直接返回。
  • 如果从数据库查询的对象为空,也放入缓存,只是设定的缓存过期时间较短,比如设置为60秒。

.4. 缓存雪崩

定义:缓存中如果大量缓存在一段时间内集中过期了,这时候会发生大量的缓存击穿现象,所有的请求都落在了DB上,由于查询数据量巨大,引起DB压力过大甚至导致DB宕机。
解决方案:

  • 给缓存的失效时间,加上一个随机值,避免集体失效。如果Redis是集群部署,将热点数据均匀分布在不同的Redis库中也能避免全部失效的问题
  • 使用互斥锁,但是该方案吞吐量明显下降了。
  • 设置热点数据永远不过期。
  • 双缓存。我们有两个缓存,缓存A和缓存B。缓存A的失效时间为20分钟,缓存B不设失效时间。自己做缓存预热操作。然后细分以下几个小点
    1.从缓存A读数据库,有则直接返回
    2.A没有数据,直接从B读数据,直接返回,并且异步启动一个更新线程。
    3.更新线程同时更新缓存A和缓存B。
  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值