1.连接redis

最新推荐文章于 2025-05-09 01:00:00 发布

zimoxuejava

最新推荐文章于 2025-05-09 01:00:00 发布

阅读量2.9k

点赞数

CC 4.0 BY-SA版权

文章标签： redis spring boot java

本文链接：https://blog.youkuaiyun.com/zimoxuejava/article/details/130372147

本文详细介绍了如何在Spring Boot项目中整合并使用Redis，从Jedis操作Redis服务器，包括对String、Hash、List、Set和SortSet等数据类型的处理，到Jedis连接池的使用和性能测试。接着探讨了Spring Boot中的RedisTemplate和StringRedisTemplate，强调了统一设置序列化方式的重要性。此外，还讲解了Spring Boot连接Redis集群的方法，并讨论了Redis作为缓存的应用场景和选择合适数据放入缓存的策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

默认有三种方式连接redis.

第一种:jedis---传统的项目--ssm

第二种:lettuce:---->刚出现没有多久就被springboot整合进来。

第三种:springboot连接redis

1.1 jedis操作redis服务器

（1）引入jedis依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>

（2）编写相关的代码

1.对String数据类型进行操作

 @Test
    public void test01() {
        //底层使用Jedis(String host, int port)
        Jedis jedis = new Jedis("192.168.179.208", 6379);
        //该类包含了很多对redis的操作方法 而这些方法和我们原来使用的命令一样
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);

        //对string数据类型操作
        String set = jedis.set("k0", "giao华");
        System.out.println("set===" + set);
        String k0 = jedis.get("k0");
        System.out.println("get===" + k0);
        //设置失效时间
        jedis.setex("k66", 60, "hello giao华");
        //删除
        jedis.del("k0");
        System.out.println("删除--" +k0);

        //查看剩余时间
        long k66 = jedis.ttl("k66");
        System.out.println("剩余时间"+k66);

        //测试是否存在
        boolean k3 = jedis.exists("k3");
        System.out.println(k3);

        //不存在，直接存入
        long setnx = jedis.setnx("k3", "99");
        System.out.println("k3"+setnx);

        //指定数值增加数值
        long k31 = jedis.incrBy("k3", 1);
        String k32 = jedis.get("k3");
        System.out.println(k32);

        //指定数值减少数值
        long k30 = jedis.decrBy("k3", 1);
        String k39 = jedis.get("k3");
        System.out.println(k39);

        jedis.close();
    }

2.对hash数据类型进行操作

 @Test
    public void test02(){
        Jedis jedis = new Jedis("192.168.179.208",6379);
        //对hash数据类型操作
        HashMap<String,String> map = new HashMap<>();
        map.put("name","坤坤");
        map.put("age","90");
        map.put("set","男");
        jedis.hset("k22",map);

        Map<String, String> k22 = jedis.hgetAll("k22");
        System.out.println(k22);

        //list队列
        jedis.lpush("k33","鸡哥","坤坤","giao华","giao林");
        //0开始 -1结束查全部
        List<String> list = jedis.lrange("k33", 0, -1);
        System.out.println(list);

        //获取表中字段的数量
        long k33 = jedis.hlen("k33");
        System.out.println(k33);

        //获取所有给定字段的值
        List<String> hmget = jedis.hmget("k33", "name", "age");
        System.out.println(hmget);

        jedis.close();

    }

3.操作list

 @Test
    public void test04(){
        Jedis jedis = new Jedis("192.168.179.208",6379);
        //操作list
        //添加数据
        long lpush = jedis.lpush("k99", "c", "t", "r", "l");

        //获取数据
        List<String> k99 = jedis.lrange("k99", 0, -1);
        System.out.println(k99);

        //获取列表长度
        long k991 = jedis.llen("k99");
        System.out.println(k991);

        //获取最后一个元素并移除
        String k992 = jedis.rpop("k99");
        List<String> k993 = jedis.lrange("k99", 0, -1);
        System.out.println(k993);

        //通过索引获取列表中的元素
        String k994 = jedis.lindex("k99", 3);
        System.out.println(k994);

        jedis.close();

    }

4.操作set集合

 @Test
    public void test05(){
        Jedis jedis = new Jedis("192.168.179.208",6379);
        //对 set 集合进行操作

        //添加数据
        long sadd = jedis.sadd("k88", "a", "b", "c", "d", "e", "f");
        long sbdd = jedis.sadd("k77", "e", "f", "c", "d", "a", "f");
        System.out.println(sadd);

        //取数据
        Set<String> k88 = jedis.smembers("k88");
        System.out.println(k88);

        //取出交集
        Set<String> sinter = jedis.sinter("k88", "k77");
        System.out.println(sinter);

        //返回给定所有集合的差集
        Set<String> sdiff = jedis.sdiff("k77", "k88");
        System.out.println(sdiff);

        jedis.close();
    }

5.sortset集合

 @Test
    public void test06() {
        Jedis jedis = new Jedis("192.168.179.208", 6379);

        //对 sortset集合进行操作
        //添加数据
        HashMap<String, Double> hashMap = new HashMap<>();
        hashMap.put("kk",11.0);
        hashMap.put("jj",22.0);
        hashMap.put("jg",33.0);
        hashMap.put("kg",66.0);
        hashMap.put("ao",80.0);

        long k66 = jedis.zadd("k66", hashMap);
        System.out.println(k66);

        //返回区间之内的
        List<String> k661 = jedis.zrange("k66", 0, -1);
        System.out.println(k661);

        //返回有序集合中指定的成员的排名，有序集合成员分数值递减
        Long zrevrank = jedis.zrevrank("k66", "jj");
        System.out.println(zrevrank);

        //获取有序集合的成员数
        long k662 = jedis.zcard("k66");
        System.out.println(k662);

        //返回有序集中指定区间内的成员，通过索引，分数从高到底
        List<String> k663 = jedis.zrevrange("k66", 0, -1);
        System.out.println(k663);

        jedis.close();

    }

每次使用jedis对象时都需要自己创建，当使用完后，需要关闭该对象。===>jedis中也存在连接池.

1.2 jedis连接池的使用

 @Test
    public void testpool(){
        //连接池的配置信息
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(10);//最多的连接个数
        config.setMaxIdle(10);//最多空闲的连接个数
        config.setMinIdle(2);//最小的空闲个数
        config.setTestOnBorrow(true);//在获取连接对象时是否验证该连接对象的连通性
        //创建连接池对象
        JedisPool jedisPool = new JedisPool(config,"192.168.179.208",6379);

        Jedis jedis = jedisPool.getResource();
        //清空当前库
        jedis.flushDB();
        String set = jedis.set("k3", "v3");
        String k3 = jedis.get("k3");
        System.out.println(k3);

        jedis.close();//归还连接池
    }

1.3 测试jedis使用和不使用连接池的效率

 @Test
    public void test03(){
        //连接池的配置信息
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(10);//最多的连接个数
        config.setMaxIdle(10);//最多空闲的连接个数
        config.setMinIdle(2);//最小的空闲个数
        config.setTestOnBorrow(true);//在获取连接对象时是否验证该连接对象的连通性
        //创建连接池对象
        JedisPool jedisPool = new JedisPool(config,"192.168.179.208",6379);
        long start = System.currentTimeMillis();
        for (int i=0; i<2000;i++){
            Jedis jedis = jedisPool.getResource();
            String ping = jedis.ping();
            jedis.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end-start));

    }

1.4 springboot整合redis

springboot在整合redis时提高两个模板类,StringRedisTemplate和RedisTemplate.以后对redis的操作都在该模板类中。StringRedisTemplate是RedisTemplate的子类。

<!--redis相关的依赖-->
        <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>

修改配置文件

#redis的配置信息
spring.redis.host=192.168.179.208
spring.redis.port=6379
#最多获取数
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

测试:

@SpringBootTest
class SpringbootRedisApplicationTests {
    //因为springboot整合redis时StringRedisTemplate创建并交于spring容器管理
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Test
    void contextLoads() {
       //操作String
        Set<String> keys = redisTemplate.keys("*");//获取所有的key
        System.out.println("keys=="+keys);
        Boolean k3 = redisTemplate.hasKey("k3");//判断是否存在指定的key
        System.out.println("判断是否存k3"+k3);
        Boolean key = redisTemplate.delete("k3");//删除指定的key
        System.out.println("是否删除指定key成功"+key);

        //操作字符串StringRedisTemplate会把对每一种数据的操作单独封装成一个类
        ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();//专门操作字符串
        opsForValue.set("k1","坤坤");
        String k1 = opsForValue.get("k1");
        System.out.println("k1===="+k1);
        Boolean k2 = opsForValue.setIfAbsent("k2", "giao华");
        System.out.println("判断k2是否存入成功"+k2);
        //incr decr
        Long k31 = opsForValue.increment("k3", 18);
        System.out.println("k3===="+k31);

        //删除



        //可以hash操作
        HashOperations<String, Object, Object> opsForHash = redisTemplate.opsForHash();
        opsForHash.put("k33","name","坤坤");
        opsForHash.put("k33","age","18");
        opsForHash.put("k33","sex","男");

        Map<String,String> hashMap = new HashMap<>();
        hashMap.put("name","giaohua");
        hashMap.put("age","23");
        hashMap.put("sex","男");
        opsForHash.putAll("k23",hashMap);

        Map<Object, Object> k11 = opsForHash.entries("k33");
        System.out.println(k11);

        Set<Object> k12 = opsForHash.keys("k33");
        System.out.println(k12);

        System.out.println(opsForHash.values("k33"));
    }

}

1.5 RedisTemplate

它是StringRedisTemplate的父类，它类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。jdk序列化方式阅读能力差，而且占用空间大. 我们在使用是一般需要人为指定序列化方式。

@SpringBootTest
class SpringbootRedisApplicationTests2 {
    //因为springboot整合redis时StringRedisTemplate创建并交于spring容器管理
    @Autowired
    private RedisTemplate redisTemplate;
    //org.springframework.core.serializer.support.SerializationFailedException
    //因为user对象在jvm内存中，--放入redis服务器--持久化到磁盘上。---要该对象的类必须序列化
    //key和value都是乱码---因为他们默认采用的序列化方式jdk的序列华方式。但是阅读不方便。我们一般不采用jdk的序列化方式
    @Test
    void test() {
        //redisTemplate.setKeySerializer(new StringRedisSerializer());
        //redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("user",new User(1,"坤坤",18));

        Object user = valueOperations.get("user");
        System.out.println(user);


    }

}

如果每次使用都人为指定序列化方式，统一设置redisTemplate的序列化 (常用，很重要)

@Configuration
public class RedisConfig {
    //比如验证码
    @Bean //该方法的返回对象交于spring容器管理
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        //field序列化  key field  value
        template.setHashKeySerializer(redisSerializer);
        return template;
    }
}

1.6springboot连接集群

开启集群

配置文件

spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
# 设置redis重定向的次数---根据主节点的个数
spring.redis.cluster.max-redirects=3

spring.redis.cluster.nodes=192.168.179.208:7001,192.168.179.208:7002,192.168.179.208:7003,192.168.179.208:7004,192.168.179.208:7005,192.168.179.208:7006

测试

@SpringBootTest
class SpringbootRedisApplicationTests3 {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test(){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("k1","giaohua");
        System.out.println(valueOperations.get("k1"));
    }

}

2. redis的应用场景

2.1 redis可以作为缓存

(2)缓存的作用:

减少访问数据库的频率。--提高系统的性能。

(3)什么样的数据适合放入缓存

查询频率高的

修改频率低的

数据安全性要求低的。

(4)如何使用缓存

xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wzt</groupId>
    <artifactId>springboot-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-redis</name>
    <description>springboot-redis</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>

        <!--redis相关的依赖-->
        <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>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>


</project>

配置文件

server.port=8888

spring.datasource.url=jdbc:mysql:///student
spring.datasource.password=abc123
spring.datasource.username=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#redis?????
spring.redis.host=192.168.179.208
spring.redis.port=6379
#?????
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

serverimpl

/**
 * @program: springboot-redis2
 * @author: 涛
 * @create: 2023-04-25 10:48
 **/
@Service
public class StudentServerImpl implements StudentServer {
    @Resource
    private StudentMapper studentMapper;

    @Resource
    private RedisTemplate<String,Object> redisTemplate;

    @Override
    public Student getById(Integer sid){
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        //1.查询缓存
        Object o = valueOperations.get("student::" + sid);
        if (o!=null){//缓存命中
            return (Student) o;
        }
        Student student = studentMapper.selectById(sid);
        //2.查到应该放入到缓存
        if (student!=null){
            valueOperations.set("student::"+sid,student);
        }
        return student;
    }