SpringBoot 使用redis

目录

一、pom.xml

二、application.properties

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

四、代码案例

[4.1 model 准备 因为有可能存对象](#4.1 model 准备 因为有可能存对象)

[4.2 使用redis 操作string](#4.2 使用redis 操作string)

[4.3 使用redis 操作list](#4.3 使用redis 操作list)

[4.4 使用redis 操作hash](#4.4 使用redis 操作hash)

[4.5 使用redis 操作set](#4.5 使用redis 操作set)

[4.6 使用redis 操作zset](#4.6 使用redis 操作zset)

[4.7 Redis 操作BitMap](#4.7 Redis 操作BitMap)

一、pom.xml

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

XML 复制代码
# 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

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

java 复制代码
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

java 复制代码
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Student implements Serializable {
   private Integer id;
   private String name;
}

Product.java

java 复制代码
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Product implements Serializable {
    private Integer id;
    private String name;
}

4.2 使用redis 操作string

java 复制代码
@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

java 复制代码
@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

java 复制代码
@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

java 复制代码
@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

java 复制代码
@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

java 复制代码
@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);
    }
}
相关推荐
尘浮生1 小时前
Java项目实战II基于微信小程序的南宁周边乡村游平台(开发文档+数据库+源码)
java·开发语言·数据库·spring boot·微信小程序·小程序·maven
程序员阿龙1 小时前
基于微信小程序的校园二手交易平台设计与实现,微信小程序(定制+讲解+咨询)校园二手商品在线交易系统、校园二手市场管理与推荐工具、智能化商品交易与推荐平台
spring boot·微信小程序·毕业设计·在线商品交易与搜索优化平台·在线二手商品交易与支付平台·商品管理与交易评价平台·二手商品分类与交易管理系统
痞老板A小安装C46 小时前
redis的大key和热key问题解决方案
数据库·redis·bootstrap
飞升不如收破烂~6 小时前
Redis的String类型和Java中的String类在底层数据结构上有一些异同点
java·数据结构·redis
feilieren6 小时前
DataGrip 连接 Redis、TongRDS
数据库·redis·缓存
苹果酱05676 小时前
windows安装redis, 修改自启动的redis服务的密码
java·开发语言·spring boot·mysql·中间件
液态不合群6 小时前
Redis中常见的数据类型及其应用场景
数据库·redis·wpf
孙克旭_6 小时前
第三章 分布式缓存Redis
redis·分布式·缓存
Allen Bright6 小时前
Jedis存储一个-以String的形式的对象到Redis
数据库·redis·缓存
feilieren6 小时前
信创改造 - TongRDS 替换 Redis
java·spring boot·后端