redis

    * 快照（Snapshot）
    * AOF（Append Only File）之追加日志文件（把所有写的操作都存放在日志文件中）

<!--引入redis依赖-->
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.9.0</version>
</dependency>

import redis.clients.jedis.Jedis;
import java.util.Set;
/**
 * @Description: 测试java操作redis
 * @Author: Guo.Yang
 * @Date: 2022/02/27/21:20
 */
public class TestRedis {
    public static void main(String[] args) {
        // 创建jedis客户端对象
        Jedis jedis = new Jedis("39.105.228.254",6379); // redis服务必须关闭防火墙 2.redis服务必须开启远程连接
        // 设置redis密码
        jedis.auth("root123456");
        // 选择使用一个库 默认：使用 0号库
        jedis.select(0);
        // 执行相关操作
        // ...
        // 释放资源
        jedis.close();
    }
}

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
/**
 * @Description: 测试key操作
 * @Author: Guo.Yang
 * @Date: 2022/02/27/21:31
 */
public class TestKeys {
    private Jedis jedis;
    // 创建 TestKeys类之前方法
    @Before
    public void before(){
        // 创建redis对象
        this.jedis = new Jedis("39.105.228.254", 6379);
        this.jedis.auth("root123456");
    }
    // 创建 TestKeys类之后方法
    @After
    public void after(){
        this.jedis.close();
    }
    @Test
    public void testKeys(){
        // 测试redis操作键
        // 删除一个key
//        jedis.del("gy");
        // 删除多个key
//        jedis.del("gy","name");
        // 判断一个key是否存在exits
//        Boolean name = jedis.exists("name");
//        System.out.println(name);
        // 设置一个key超时时间 expire pexpire
        // 设置的key一定是存在的key
//        Long age = jedis.expire("gy", 100);
//        System.out.println(age);
        // 查看一个key超时时间 ttl
        // 查看的一定是存在的key
//        Long age1 = jedis.ttl("gy");
//        System.out.println(age1);
        // 随机获取一个key （不删除）
//        String s = jedis.randomKey();
//        System.out.println(s);
        // 获取key的类型
        String name = jedis.type("name");
        System.out.println(name);
    }
}

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.List;
/**
 * @Description: 测试string操作
 * @Author: Guo.Yang
 * @Date: 2022/02/27/21:31
 */
public class TestString {
    private Jedis jedis;
    // 创建 TestKeys类之前方法
    @Before
    public void before(){
        // 创建redis对象
        this.jedis = new Jedis("39.105.228.254", 6379);
        this.jedis.auth("root123456");
    }
    // 创建 TestKeys类之后方法
    @After
    public void after(){
        this.jedis.close();
    }
    @Test
    public void testKeys(){
        // set
        String set = jedis.set("name", "小陈");
        // get
        String name = jedis.get("name");
        System.out.println(name);
        //mset
        jedis.mset("content", "好人", "address", "海淀区");
        //mget
        List<String> mget = jedis.mget("content", "address");
        for (String s : mget) {
            System.out.println(s);
        }
        //getset
        String set1 = jedis.getSet("name", "小明");
        System.out.println(set1);
    }
}

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.BinaryClient;
import redis.clients.jedis.Jedis;
import java.util.List;
/**
 * @Description: 测试List操作
 * @Author: Guo.Yang
 * @Date: 2022/02/27/21:31
 */
public class TestList {
    private Jedis jedis;
    // 创建 TestList类之前方法
    @Before
    public void before(){
        // 创建redis对象
        this.jedis = new Jedis("39.105.228.254", 6379);
        this.jedis.auth("root123456");
    }
    // 创建 TestKeys类之后方法
    @After
    public void after(){
        this.jedis.close();
    }
    @Test
    public void testList(){
        // lpush
        jedis.lpush("name1","张三","王武","李四");
        // rpush
        jedis.rpush("name1","xaioming");
        // lrange
        List<String> name1 = jedis.lrange("name1", 0, -1);
        for (String s : name1) {
            System.out.println(s);
        }
        // lpop
        String name11 = jedis.lpop("name1");
        System.out.println(name11);
        // rpop
        String name12 = jedis.rpop("name1");
        System.out.println(name12);
        // linsert
        jedis.linsert("lists", BinaryClient.LIST_POSITION.BEFORE, "小黑", "小陈");
    }
}

<!--        引入springboot data redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

# 配置redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0

import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
 * @Description:
 * @Author: Guo.Yang
 * @Date: 2022/03/01/20:17
 */
@Data
public class User implements Serializable {
    private String id;
    private Integer age;
    private Date bir;
    private String name;
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@SpringBootTest
class RedisBootApplicationTests {
    // 注入StringRedisTemplate
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    // 操作redis中字符串 opsForValue 实际上操作的就是redis中的String类型
    // 理解： stringRedisTemplate.opsFor谁 操作的就是谁，opsForList  就是操作的redis中的list类型
    @Test
    public void testString(){
        stringRedisTemplate.opsForValue().set("name","小陈");
        String name = stringRedisTemplate.opsForValue().get("name");
        System.out.println(name);
        // 设置一个键值 且超时时间为120秒 四个参数： 1key 2value 3超时时间 4超时时间的之间类型
        stringRedisTemplate.opsForValue().set("code","2312",120, TimeUnit.SECONDS);
        //追加在一个key的value后边的值
        Integer append = stringRedisTemplate.opsForValue().append("name", "他是一个好人");
    }
    @Test
    public void testKey(){
        Boolean name = stringRedisTemplate.delete("qq"); // 删除一个key
        System.out.println(name);
        Boolean name1 = stringRedisTemplate.hasKey("qw"); // 判断key是否存在
        System.out.println(name1);
        DataType name2 = stringRedisTemplate.type("666"); // 判断key的类型
        System.out.println(name2);
        Set<String> keys = stringRedisTemplate.keys("*"); // 获取redis中的所有key
        System.out.println(keys);
//        Boolean age = stringRedisTemplate.expire("age", Duration.ofDays(100)); // 设置key的超时时间
        Long age1 = stringRedisTemplate.getExpire("age");
        System.out.println(age1);
//        stringRedisTemplate.rename("age","age1"); // 修改key的名字，如果没有key会报错
        // 理论上是不抛异常的，可能api有些变化
//        Boolean aBoolean = stringRedisTemplate.renameIfAbsent("qwe", "qww"); // 修改key的名字，但修改之前会进行判断是否有这个key
        Boolean age2 = stringRedisTemplate.move("age", 1);// 移动一个可以 到1号库
    }
    @Test
    public void testList(){
        Long aLong = stringRedisTemplate.opsForList().leftPush("names", "小张");
        Long aLong1 = stringRedisTemplate.opsForList().rightPush("testList", "test");
        Long aLong2 = stringRedisTemplate.opsForList().leftPushAll("testLeftPushAll", "v1", "v2");
        ArrayList<String> list = new ArrayList<>();
        list.add("123");
        list.add("666");
        stringRedisTemplate.opsForList().leftPushAll("testPushAllOfList",list);
        List<String> testPushAllOfList = stringRedisTemplate.opsForList().range("testPushAllOfList",0,-1);
        for (String s : testPushAllOfList) {
            System.out.println("testPushAllOfList --- >" + s);
        }
    }
    @Test
    public void testSet(){
        // 设置一个set集合
         stringRedisTemplate.opsForSet().add("testSet","张三","张三","李四");
         // 查看set集合成员
        Set<String> testSet = stringRedisTemplate.opsForSet().members("testSet");
        for (String s : testSet) {
            System.out.println("testSet" + s);
        }
        // 查看testSet的值的长度
        Long testSet1 = stringRedisTemplate.opsForSet().size("testSet");
        System.out.println(testSet1);
    }
    @Test
    public void testZset(){
        // 创建一个zset集合
        Boolean add = stringRedisTemplate.opsForZSet().add("zset", "小黑", 10);
        // 便利zset集合
        Set<String> zset = stringRedisTemplate.opsForZSet().range("zset", 0, -1);
        for (String s : zset) {
            System.out.println(s);
        }
        System.out.println("-----------");
        // 获取 指定下标范围的zset元素
        Set<ZSetOperations.TypedTuple<String>> zset1 = stringRedisTemplate.opsForZSet().rangeByScoreWithScores("zset", 0, 100);
        for (ZSetOperations.TypedTuple<String> stringTypedTuple : zset1) {
            System.out.println(stringTypedTuple.getValue());// 元素
            System.out.println(stringTypedTuple.getScore());// 分数
        }
    }
    @Test
    public void testHash(){
        // Hash类型 和java里的haspmap很像
        // 3个参数 redis里边的大key 大key里边的 key value
        stringRedisTemplate.opsForHash().put("maps","name","张三");
        // 获取大key里边的多个key的值
        List<Object> maps = stringRedisTemplate.opsForHash().multiGet("maps", Arrays.asList("name","age"));
        // 获取hash类型key 的key的value
        Object o = stringRedisTemplate.opsForHash().get("maps", "name");
        //// 获取hash类型key 的value
        List<Object> maps1 = stringRedisTemplate.opsForHash().values("maps");
        // 获取hash类型key 的key
        Set<Object> maps2 = stringRedisTemplate.opsForHash().keys("maps");
    }
}

import com.yang.redisboot.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.util.*;
import java.util.concurrent.TimeUnit;
@SpringBootTest
class RedisTemplateApplicationTests {
    // 注入StringRedisTemplate
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void testRedisTemplate(){
        User user = new User();
        user.setId(UUID.randomUUID().toString());
        user.setName("小陈");
        user.setAge(18);
        user.setBir(new Date());
        /**
         * 使用 redisTemplate去取StringRedisTemplate存进去的key时，是取不出来的
         * 因为 redisTemplate 无论存值、取值 都是要序列化完成之后存进去、或者按序列化的key取出来后在反序列化出来
         */
//        Object names = redisTemplate.opsForValue().get("names");
//        System.out.println(names); // 输出：null
        /**
         * 存进去的以user为key的User对象
         * 注意：如果使用终端命令取的话  get user 是取不出来的，因为看似java程序我们存进去的是以user为key
         * 但是实际是user序列化以后的值才是我们存进去的key
         * 所以我们想要存储的对象实体一定要实现序列化接口 Serializable
         */
        // 存入对象
//        User user = new User();
//        user.setId(UUID.randomUUID().toString());
//        user.setName("小陈");
//        user.setAge(18);
//        user.setBir(new Date());
//        redisTemplate.opsForValue().set("user",user);
        // 获取对象
//        User user = (User) redisTemplate.opsForValue().get("user");
//        System.out.println(user); //输出：User(id=b312bd22-6053-4f13-a4e1-ae2dedc932fb, age=18, bir=Tue Mar 01 20:28:54 CST 2022, name=小陈)
        /**
         * 存进去的key、value都是序列化的话 这样对于我们是有局限性的
         * 我们想要的是存进去的key是String 对象是序列化的
         * 我们可以 修改我们的redisTemplate的序列化方式
         * 默认的我们的redisTemplate对象的使用的是jbk的序列化策略
         */
        // 可以打印出redisTemplate key的序列化方案
        RedisSerializer keySerializer = redisTemplate.getKeySerializer();
        System.out.println(keySerializer);
        /**
         * 如果我们想修改key不序列化的话，也就是存就去的是个字符串，用字符串去取可以取出来的话
         * 我们可以修改redisTemplate key的序列化策略
         */
        // 修改redisTemplate key的序列化策略
        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        User user = new User();
//        user.setId(UUID.randomUUID().toString());
//        user.setName("小陈");
//        user.setAge(18);
//        user.setBir(new Date());
//        redisTemplate.opsForValue().set("user",user);
//        redisTemplate.opsForList().leftPush("list",user);
//
//        redisTemplate.opsForSet().add("set",user);
//
//        redisTemplate.opsForZSet().add("zset",user,100);
        redisTemplate.opsForHash().put("map","user",user);
        /**
         * 发现问题
         * redisTemplate.opsForHash().put("map","user",user);
         * 设置的redis的key是没有被序列化的，但是hash里边的key是被序列化的，这也不是我们想要的
         * 于是我们可以修改redis.hash里边key的序列化策略
         */
        // 设置redis hash；里边key的序列化策略
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 存入redis key 和hash key均未必序列化对象
        redisTemplate.opsForHash().put("mapOne","user",user);
    }
}

import com.yang.redisboot.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.util.Date;
import java.util.UUID;
@SpringBootTest
class TestBoundAPI {
    // 注入StringRedisTemplate
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * spring data 为了方便我们对redis进行友好的操作，因此给我们提供了bound API 简化操作
     */
    @Test
    public void testbound(){
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        /**
         * 也就是 我们在操作同一个key的时候我们无时无刻都得带着这个key
         */
//        redisTemplate.opsForValue().set("name" , "张三");
//        redisTemplate.opsForValue().append("name","是一个好人");
//        redisTemplate.opsForValue().get("name");
        /**
         * 为了简化操作，我们可以通过bound绑定一个key，并返回一个绑定之后的对象，以后我们对这个对象的操作就是我们对这个key的操作
         */
        // 上边的代码可以简化为：
        BoundValueOperations name = redisTemplate.boundValueOps("name");
        name.set("张三");
        name.append("是个好人");
        String o = (String) name.get();
        System.out.println(o);
        /**
         * 其他数据类型以此类推
         */
        /**
         * 总结：
         * 1、针对于处理key、value 都是string类型使用StringRedisTemplate
         * 2、针对于处理key、value 存在对象 使用RedisTemplate
         * 3、针对于同一个key的多个操作 建议使用boundXXXOps() value、list、Set、Zset的api简化代码
         */
    }
}

* 为了尽可能的将key变的整洁写，使用MD5加密处理
    * 特点
        * 一切文件字符串等经过md5处理之后，都会生成32位16进制的字符串
        * 不同内容文件经过md5进行加密，加密的算法一定不一致
            * 面试题：有两个文件 a.txt 、b.txt 如何判断这两个文件的内容是否相同
            * 使用md5对两个文件进行处理，如果结果一直 那内容一定一致 
        * 相同内容的文件多次经过md5生成的结果始终一致
* 推荐：在redis整合mybatis过程中建议将key 进行md5优化处理

- master (主)
    port 6379
    bind 0.0.0.0
- slave1 (从1)
    port 6380
    bind 0.0.0.0
    slave masyterip masterport (slave 主redisIP 从redis端口)
- slave2 (从2)
    port 6381
    bind 0.0.0.0
    slave masyterip masterport (slave 主redisIP 从redis端口)

例如： sentinel monitor mySentinel 39.105.228.254  6379 1
 //   sentinel monitor mySentinel 39.105.228.254(主节点ip)  6379(主节点端口) 1(哨兵的数量)

# 配置redis 哨兵模式
# master 书写是使用哨兵监听的名称
spring.redis.sentinel.master=mymaster
# 连接的不再是一个具体的redis主机 书写的是多个哨兵节点
spring.redis.sentinel.nodes=yang.gunveda.top:26379
# 配置redis密码
spring.redis.password=root123456

sentinel myid 0f366835f15ad7e001a803891fb5c7af6eac41fd
bind 0.0.0.0
sentinel monitor mymaster 39.105.228.254 6379 1
# Generated by CONFIG REWRITE
port 26379
dir "/root/redis-master-slave/sentinel"
sentinel auth-pass mymaster root123456
sentinel config-epoch mymaster 1
sentinel leader-epoch mymaster 1
sentinel known-slave mymaster 39.105.228.254 6380
sentinel known-slave mymaster 39.105.228.254 6381
sentinel current-epoch 1

yum -install -y ruby rubygems
gem install redis

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

/**
 * @Description:
 * @Author: Guo.Yang
 * @Date: 2022/03/07/20:32
 */
@Configuration
@EnableRedisHttpSession // 将整个应用中使用session的数据全部交给redis管理
public class RedisSessionManage {
}

server.port=8090
server.servlet.context-path=/redis-session
# redis配置
spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=yang.gunveda.top:26379
spring.redis.password=root123456

/**
 * @Description:
 * @Author: Guo.Yang
 * @Date: 2022/03/07/20:33
 */
@RestController
@RequestMapping("/test")
public class TestController {
    /**
     * 使用redis的session管理  注意：当session中的数据发生变化是必须将session中变化的数据同步到redis中
     * @param request
     * @param response
     * @throws IOException
     */
    @RequestMapping("/test")
    public void test(HttpServletRequest request, HttpServletResponse response) throws IOException {
        List<String> list = (List<String>)request.getSession().getAttribute("list");
        if(list == null){
            list = new ArrayList<>();
        }
        list.add("XXXXX");
        request.getSession().setAttribute("list",list); // 每一次session变化都要同步
        response.getWriter().println("size: "+ list.size());
        response.getWriter().println("sessionid: " + request.getSession().getId());
    }
    @RequestMapping("/remove")
    void removeSessionAttribute(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.getWriter().println("sessionID: "+ request.getSession().getId());
        request.getSession().removeAttribute("list");
    }
    /**
     * 退出登陆，并会将redis的session也清除
     * @param request
     * @param response
     * @throws IOException
     */
    @RequestMapping("/logout")
    void logout(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 退出登陆
        request.getSession().invalidate(); // 注销session 使其失效
        response.getWriter().println("退出登录");
    }
}