SpringBoot 使用redis

一、pom.xml

二、application.properties

三、编写一个配置类用于解决乱码问题和对象真实的类型问题

四、代码案例

一、pom.xml

 <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>

二、application.properties

# 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;
    }
}

四、代码案例

4.1 model 准备因为有可能存对象

Student.java

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Student implements Serializable {
   private Integer id;
   private String name;
}

Product.java

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Product implements Serializable {
    private Integer id;
    private String name;
}

4.2 使用redis 操作string


@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);
        }
    }

4.3 使用redis 操作list


@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);
        }
    }

4.4 使用redis 操作hash

@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);
        }
    }

4.5 使用redis 操作set


@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);// 语文
        }
    }

4.6 使用redis 操作zset


@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());
            }
        });
    }

4.7 Redis 操作BitMap

@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);
    }
}