SpringBoot如何使用redis

 <dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-data-redis</artifactid>
        </dependency>
        <dependency>
            <groupid>org.apache.commons</groupid>
            <artifactid>commons-pool2</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
 </dependencies>

# redis服务器地址
spring.redis.host=192.168.11.84
# redis服务器连接端口
spring.redis.port=6379
# redis服务器连接密码（默认为空）
spring.redis.password=
# redis数据库索引（默认为0） 共15个
spirng.redis.database=0
## 连接超时时间（毫秒）
spring.redis.timout=30000
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=1
#连接池中最大空闲等待时间，3s没有活干的时候直接驱逐该链接
spring.redis.lettuce.pool.min-evicate-idle-time-millis=3000
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1

package com.by.config;

import com.fasterxml.jackson.databind.objectmapper;
import org.springframework.boot.autoconfigure.condition.conditionalonmissingbean;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.data.redis.connection.redisconnectionfactory;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.serializer.jackson2jsonredisserializer;
import org.springframework.data.redis.serializer.stringredisserializer;

import java.net.unknownhostexception;

@configuration
public class redisconfig {
    @bean
    @conditionalonmissingbean(name = "redistemplate")
    public redistemplate<object, object> redistemplate(redisconnectionfactory redisconnectionfactory)
            throws unknownhostexception {
        redistemplate<object, object> template = new redistemplate<>();
        template.setconnectionfactory(redisconnectionfactory);
        // key序列化方式
        template.setkeyserializer(stringredisserializer.utf_8);
        //jackson2jsonredisserializer 序列化方式 来代替自来的jdk序列化方式，因为后者会乱码
        jackson2jsonredisserializer jack = new jackson2jsonredisserializer(object.class);
        template.setvalueserializer(jack);
        template.sethashkeyserializer(stringredisserializer.utf_8);
        template.sethashvalueserializer(jack);
        /**
         * 使用objeck设置对象的类型为真实的对象类型 而不是hsash
         */
        objectmapper mapper=new objectmapper();
        // 启用默认类型推理，将类型信息作为属性写入json
        // 就是把对象的全类名写入json
        mapper.activatedefaulttyping(mapper.getpolymorphictypevalidator(), objectmapper.defaulttyping.non_final);
         // 将类型的信息作为属性传给json
        jack.setobjectmapper(mapper);
        return template;
    }
}

@data
@allargsconstructor
@noargsconstructor
@builder
public class student implements serializable {
   private integer id;
   private string name;
}

@data
@allargsconstructor
@noargsconstructor
@builder
public class product implements serializable {
    private integer id;
    private string name;
}

@slf4j
@springboottest
class stringtest {
    /**
     * 使用redis 操作string
     */
    @autowired
    private stringredistemplate str;
    // 自动序列化，用 @autowired报错
    @resource(name ="redistemplate")
    private redistemplate<string,student> redistemplate;
    private  final  string key ="zhouxingxing";

    /**
     * 将对象序列化 不用手动将对象转成字符串
     */
    @test
    void m8() {
        // jdk 序列化
        student student = student.builder().id(1).name("张三").build();
//        jdkserializationredisserializer serializer =new jdkserializationredisserializer();
//        byte[] serialize = serializer.serialize(student);
//        string s=new string(serialize);
        // s乱码
        redistemplate.opsforvalue().set("student", student);
        student student1 =  redistemplate.opsforvalue().get("student");
        system.out.println(student1.getname());

    }
    /**
     * string里的get set 方法
     */
    @test
    void m1() {
        str.opsforvalue().set("xiaolong", "帅呆了");
        string xiaolong = str.opsforvalue().get("xiaolong");
        log.info("xiaolong:{}", xiaolong);
    }

    /**
     * string里的strlen 方法
     * append 方法：追加字符串
     */
    @test
    void m2() {
        str.opsforvalue().set("xiaolong", "帅呆了");
        string xiaolong = str.opsforvalue().get("xiaolong");
        log.info("xiaolong:{}", xiaolong);
        // 追加字符串
        str.opsforvalue().append("xiaolong", "哈哈");
        // 获取长度
        long size = str.opsforvalue().size("xiaolong");
        log.info("长度为:{}", size);//15
    }

    /**
     * string里的incr 方法
     * incrby 方法：增加指定值
     */
    @test
    void m3() {
        str.opsforvalue().set("xiaolong", "100");
        long xiaolong = str.opsforvalue().decrement("xiaolong", 2);
        log.info("xiaolong:{}", xiaolong); //98
    }

    /**
     * 将student 对象存到redis 里
     * jsonutil.tojsonstr(对象)--->将对象转成序列化的json字符串
     */
    @test
    void m4() {
        student student = student.builder().id(1).name("张三").build();
        str.opsforvalue().set("student", jsonutil.tojsonstr(student));
        log.info("student:{}", str.opsforvalue().get("student"));//student:{"id":1,"name":"张三"}
    }
    @test
    public void m7() {
        str.opsforhash().put(key,"20220325","郑州");
        str.opsforhash().put(key,"20220326","洛阳");
        // 拿到所有小key的值
        list<object> values = str.opsforhash().values(key);
        for (object value : values) {
            system.out.println(value);
        }
    }

@springboottest
@slf4j
public class listtest {
    @autowired
    private stringredistemplate redistemplate;
    private final string key = "xiaolong";
    /**
     * 给list左推元素和又推元素
     * 从右方删除元素并返回删除的元素
     */
    @test
    void m1() {
        redistemplate.opsforlist().leftpush(key, "g1");
        redistemplate.opsforlist().leftpush(key, "g2");
        redistemplate.opsforlist().leftpush(key, "g3");
        redistemplate.opsforlist().rightpush(key, "g4");//顺序为 g3 g2 g1 g4
        // 从右边删除元素 并返回删除的元素
        string s = redistemplate.opsforlist().rightpop(key);
        log.info("删除元素为：{}", s);// g4
    }

    @test
    public void m2() {
        list<object> obj = redistemplate.executepipelined((rediscallback<object>) connection -> {
            //队列没有元素会阻塞操作，直到队列获取新的元素或超时
            return connection.blpop(600, "list1".getbytes());
        }, new stringredisserializer());
        for (object str : obj) {
            system.out.println(str);
        }
    }

@slf4j
@springboottest
public class hashtest {
    @autowired
    private stringredistemplate redistemplate;
    // 自动序列化
    @resource(name ="redistemplate")
    private redistemplate<string, student> redistemplate1;
    // 设置大key
    private final string key = "xiaolong";
    @test
     void m10() {
        student student = student.builder().id(1).name("张三").build();
        redistemplate1.opsforhash().put(key, "g1", student);
        object o = redistemplate1.opsforhash().get(key, "g1");
    }
 // 设置商品黑名单
    @test
    public void m9() {
        product p1 = product.builder().id(1).name("华为").build();
        product p2 = product.builder().id(2).name("小米").build();
        redistemplate1.opsforhash().put("黑名单","名单列表1",p1);
        redistemplate1.opsforhash().put("黑名单","名单列表2",p2);
    }

    /**
     * 获取大key里所有小key的值
     */
    @test
    public void m1() {
        redistemplate.opsforhash().put(key, "g1", "小芳");
        redistemplate.opsforhash().put(key, "g2", "小红");
        // 拿到所有小key的值
        list<object> values = redistemplate.opsforhash().values(key);
        for (object value : values) {
            log.info("所有小key的值为："+value);
        }
    }

@springboottest
@slf4j
public class settest {
  @autowired
   private stringredistemplate redistemplate;
   private final string xiaoming = "xiaoming";
   private final string xiaohong = "xiaohong";
  @test// 交集
    void m1()
    {
        // 添加小明同学感兴趣的学科
        redistemplate.opsforset().add(xiaoming, "语文", "数学","物理");
        // 添加小红同学感兴趣的学科
        redistemplate.opsforset().add(xiaohong, "语文", "英语");
        // 获取两位同学共同感兴趣的学科
        set<string> tong = redistemplate.opsforset().intersect(xiaohong, xiaoming);
        for (string s : tong) {
           log.info("小明和小红共同感兴趣的学科为："+s);// 语文
        }
    }
    @test//并集
    void m2()
    {
        // 添加小明同学感兴趣的学科
        redistemplate.opsforset().add(xiaoming, "语文", "数学","物理");
        // 添加小红同学感兴趣的学科
        redistemplate.opsforset().add(xiaohong, "语文", "英语");
        // 获取两位同学共同感兴趣的学科
        set<string> tong = redistemplate.opsforset().union(xiaohong, xiaoming);
        for (string s : tong) {
            log.info("小明和小红共同感兴趣的学科为："+s);// 语文
        }
    }

@springboottest
@slf4j
public class zsettest {
    @autowired
    private stringredistemplate redistemplate;
    @resource(name = "redistemplate")
    private redistemplate<string, integer> redistemplate1;
    private string key = "xiaolong";
    /**
     * zset有序集合唯一 去重 适用于今日头条和热搜
     * 给xiaolong 添加三门得成绩
     */
    @test
    public void m1() {
        redistemplate.opsforzset().add(key, "语文", 90);
        redistemplate.opsforzset().add(key, "数学", 100);
        redistemplate.opsforzset().add(key, "英语", 80);
        long along = redistemplate.opsforzset().zcard(key);
        log.info("{科目数量为:}", along);
        // 获取xiaolong的最高分 spring 没有给我们封装
        redistemplate.execute(new rediscallback<object>() {
            @override
            public object doinredis(redisconnection connection) throws dataaccessexception {
                return connection.blpop(5, key.getbytes());
            }
        });
    }

@component
public class bitmapdemo {
    @autowired
    private stringredistemplate stringredistemplate;
    private final  string key ="sign#2022#zhouxingxing";
    public void test(){
       //设置签到
        stringredistemplate.opsforvalue().setbit(key,2,true);
        stringredistemplate.opsforvalue().setbit(key,85,true);
        //获取周星星同学的签到天数
        rediscallback<long> callback = connection -> { return  connection.bitcount(key.getbytes(),0,365);};
        long count = stringredistemplate.execute(callback);
        //打印周星星2022年签到天数
        system.out.println("周星星2022年一共签到天数："+count);
    }
}