spring boot 简单使用redis缓存

application.yml配置文件

server:
  port: 8089
  max-http-header-size: 10240000

#spring:
#  datasource:
#    url: jdbc:mysql://localhost:3306/数据库名称?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=false
#    username: 用户名
#    password: 密码
#    driver-class-name: com.mysql.cj.jdbc.Driver
#    type: com.alibaba.druid.pool.DruidDataSource
#
#mybatis:
#  typeAliasesPackage: com.bltec.visual.pojo

#redis 配置
spring:
  jpa:
    show-sql: true
  redis:
    #服务器连接地址
    host: 192.168.43.128
    #服务器连接端口
    port: 6379
    #连接密码
    password: 123456
    #Redis 数据库索引 默认为0
    database: 0
    #最大连接时间
    timeout: 20000
    jedis:
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 3000
        #连接池中的最大空闲连接
        max-idle: 20
        #连接池中的最小空闲连接
        min-idle: 2

redis config配置类

package com.zrx.redis_demo.config;

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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * 可以使用配置文件 也可以不使用 直接使用 StringRedisTemplate 封装好的 模板里面已经实现了序列化*/



@Configuration
public class redisConfig {
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        参照StringRedisTemplate内部实现指定序列化器
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(keySerializer());
        redisTemplate.setHashKeySerializer(keySerializer());
        redisTemplate.setValueSerializer(valueSerializer());
        redisTemplate.setHashValueSerializer(valueSerializer());
        return redisTemplate;
    }

    private RedisSerializer<String> keySerializer(){
        return new StringRedisSerializer();
    }

    //使用Jackson序列化器
    private RedisSerializer<Object> valueSerializer(){
        return new GenericJackson2JsonRedisSerializer();
    }
}

redis工具类

package com.zrx.redis_demo.utlis;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;


@Component
public class RedisUtil {

    //注入redisTemplate
    @Autowired
    private StringRedisTemplate redisTemplate;


    public void setRedis(String key,String val) {
        //缓存中最常用的方法
        redisTemplate.opsForValue().set(key,val);
        //设置缓存过期时间为30   单位：秒　　　　 //关于TimeUnit下面有部分源码截图
        redisTemplate.opsForValue().set(key,val,30, TimeUnit.SECONDS);
        System.out.println("存入缓存成功");
    }

    public void getRedis(String key){
        String val = redisTemplate.opsForValue().get(key);

        System.out.println("取出缓存中val的数据是:"+val);

    }

    public void delRedis(String key) {
        //根据key删除缓存
        Boolean first1 = redisTemplate.delete(key);

        System.out.println("是否删除成功:"+first1);
    }
}

redis的基本类测试代码

package com.zrx.redis_demo.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;


@RunWith(SpringRunner.class)
@SpringBootTest
public class testDemo1 {
    //在MyRedisConfig文件中配置了redisTemplate的序列化之后， 客户端也能正确显示键值对了
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Test
    public void testKv(){
        //向缓存中写入键值对 K/V
        //注意这里使用了 JDK 的序列化器 ,所以 Redis 保存时不是整数, 不能运算
        redisTemplate.opsForValue().set("savaKey", "111111");
        //保存整数
        redisTemplate.opsForValue().increment("int", 1);
        //根据key取出整数
        Long res = redisTemplate.opsForValue().increment("int");
        System.out.println(res);
    }

    @Test
    public void testHash(){
        //向缓存中写入Hash 集合
        Map<String, Object> hash = new HashMap<>();
        hash.put("field1", "value1");
        hash.put("field2", "value2");
        //将Hashmap存储到redis中
        redisTemplate.opsForHash().putAll("hashTest", hash);
        //向map 中继续添加值
        redisTemplate.opsForHash().put("hashTest", "field3", "value3");

        //绑定散列操作的 key,这样可以连续对同一个散列数据类型进行操作
        BoundHashOperations hashOps = redisTemplate.boundHashOps("hashTest");
        //根据map中的键 删除对应元素
        hashOps.delete("field2", "field1");
        //添加元素
        hashOps.put("field4", "value4");
    }

    @Test
    public void testList(){
        //从左插入 链表从左到右的顺序为v10, v8, v6, v4, v2
        redisTemplate.opsForList().leftPushAll("list1", "v2","v4","v6","v8","v10");
        //从右插入 链表从左到右的顺序为v1, v3, v5, v7, v9
        redisTemplate.opsForList().rightPushAll("list2", "v1","v3","v5","v7","v9");

        //绑定list2操作链表
        BoundListOperations<String, String> listOps = redisTemplate.boundListOps("list2");
        //从右边弹出一个成员 当成员弹出时 成员则被从list中删除
        Object result1 = listOps.rightPop();
        assert result1 != null;
        System.err.println("list2的最右边元素为: "+result1.toString());

        //获取定位元素, 下标从0开始
        Object result2 = listOps.index(1);
        assert result2 != null;
        System.err.println("list2下标为1的元素为"+result2.toString());

        //从左边插入链表
        listOps.leftPush("v0");

        Long size = listOps.size();//求链表长
        System.err.println("list2的长度为: "+size);
    }

    @Test
    public void testSet(){
        //重复的元素不会被插入
        redisTemplate.opsForSet().add("set1", "v1","v1","v3","v5","v7","v9");
        redisTemplate.opsForSet().add("set2", "v2","v4","v6","v5","v10","v10");

        //绑定sert1集合操作
        BoundSetOperations<String, String> setOps = redisTemplate.boundSetOps("set1");
        setOps.add("v11", "v13");
        setOps.remove("v1", "v3");
        Set<String> set = setOps.members();//返回所有元素
        assert set != null;
        System.err.println("集合中所有元素: "+set.toString());

        Long size = setOps.size();//求成员数
        System.err.println("集合长度: "+ size);

        Set<String> inner = setOps.intersect("set2"); //求交集
        setOps.intersectAndStore("set2", "set1_set2");//求交集并用新的集合保存
        assert inner != null;
        System.err.println("集合的交集: "+inner.toString());

        Set<String> diff = setOps.diff("set2"); //求差集
        setOps.diffAndStore("set2","set1-set2"); //求差集并用新的集合保存
        assert diff != null;
        System.err.println("集合的差集: "+diff.toString());

        Set<String> union = setOps.union("set2"); //求并集
        setOps.unionAndStore("set2", "set1=set2"); //求并集并用新的集合保存
        assert union != null;
        System.err.println("集合的并集: "+union.toString());

    }

}

可以使用自己配置的redis模板，也可以使用包装好的redis模板，redis缓存过期的时间以redis服务器的时间为基准