springboot整合redis_springboot 两个redis-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_77560707/article/details/130352830

1.连接redis的方式

（1）jedis-----传统的项目--ssm

（2）lettuce-------刚出来没多久就被springboot整合进来

（3）springboot连接redis

1.1 jedis操作redis服务器

（1）引入jedis依赖

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

（2）编写相关的代码

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

 @Test
    public  void test01(){
        Jedis jedis = new Jedis("192.168.220.130",6379);
        //对string数据类型操作
        String set = jedis.set("k3", "v3");
        System.out.println("set==="+set);
        String v3 = jedis.get("k3");
        System.out.println("v3===="+v3);
        jedis.setex("k4",60,"v4");

        //对hash数据类型操作
        Map<String,String> map=new HashMap<String,String>();
        map.put("name","shi");
        map.put("age","24");
        map.put("sex","男");
        jedis.hset("k5",map);

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

        //list队列
        jedis.lpush("k6","王","乔","石","丁");
        List<String> k6 = jedis.lrange("k6", 0, -1);
        System.out.println(k6);
        jedis.close();

    }

1.2 jedis连接池的使用

@Test
    public void testPool(){
        JedisPool jedisPool=new JedisPool(config,"192.168.220.130",6379);
        Jedis jedis = jedisPool.getResource();
        jedis.flushDB();       //清空当前库

        String set = jedis.set("k1", "v1");
        String k1 = jedis.get("k1");
        System.out.println(k1);
        jedis.close();//归还连接池

    }

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

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

 @Test
    public void test02(){
        long start = System.currentTimeMillis();
        //Jedis(String host, int port)
        for(int i=0;i<10000;i++){
            Jedis jedis=new Jedis("192.168.220.130",6379);
            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.220.130
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

测试:

  @Autowired
    private StringRedisTemplate redisTemplate;
    @Test
    void contextLoads() {
       //关于key的操作
        Set<String> keys = redisTemplate.keys("*");  //获取所有的key:  key*
        System.out.println("keys=== " + keys);
        Boolean k2 = redisTemplate.hasKey("k2");        //key是否存在： exists key
        System.out.println("k2是否存在： " + k2);
        Boolean k21 = redisTemplate.delete("k2");  //删除key ： del key
        System.out.println("是否已经删除k2"+k21);

        //------------------string 类型--------------------------
        //操作字符串===StringRedisTemplate会把对每一种数据的操作单独封装成一个类。
        ValueOperations<String, String> forValue = redisTemplate.opsForValue(); //专门操作字符串类型
        forValue.set("k3","3");   //添加key ： set key value
        String k3 = forValue.get("k3");     // 获取key的值 ：  get key
        System.out.println("字符串操作获取k3："+k3);

        forValue.setIfAbsent("k5" , "vv5");//如果key不存在时，会添加key的值： setnx key value
        System.out.println(forValue.get("k5"));

        Long k31 = forValue.increment("k3");//设置指定key的数字值+1
        System.out.println("k3+1 =:"+k31);

        Long decrement = forValue.decrement("k3");//设置指定的key的数字值-1
        System.out.println("k3-1="+decrement);

        //同时设置多个key的值
        Map<String ,String> map = new HashMap();
        map.put("name","shitou");
        map.put("age","123");
        map.put("sex","男");
        forValue.multiSet(map);
        //同时获取多个key的值：  mget key key.....
        List<String> list = new ArrayList<>();
        list.add("name");
        list.add("age");
        list.add("sex");
        List<String> strings = forValue.multiGet(list);
        System.out.println("多个key的值："+strings);


        //--------------------hash类型-------------------------

        HashOperations<String, Object, Object> forHash = redisTemplate.opsForHash();
        //将hash表中的key的字段设置value值------hset key field value
        forHash.put("k4","name","qiao");
        forHash.put("k4","age","23");
        forHash.put("k4","sex","男");
        //获取key的指定字段的值 ---- hget key field
        System.out.println("key4的name值："+forHash.get("k4", "name"));

        //获取key的所有字段和value ----hgetall key
        Map<Object, Object> k4 = forHash.entries("k4");
        System.out.println("k4:"+k4);

        //获取key所有的字段----- hkeys key
        Set<Object> k41 = forHash.keys("k4");
        System.out.println("获取k4所有的字段："+k41);
        //获取key所有的value-----hvals key
        List<Object> k42 = forHash.values("k4");
        System.out.println("获取k4所有的value："+k42);


        //------------------------------list队列----------------------------------

        ListOperations<String, String> forList= redisTemplate.opsForList();
        //添加数据--------  lpush key value value value.....
        forList.leftPushAll("k6","v61","v62","v73");
        //获取数据---------lrange key start end
        List<String> k6 = forList.range("k6", 0, -1);
        System.out.println("k6: "+k6);


        //------------------------------set集合类型-------------------------------

        SetOperations<String, String> forSet = redisTemplate.opsForSet();
        //向集合中添加一个或者多个成员-----sadd key value value.....
        forSet.add("k7","k71","k72","k73");
        //获取集合中所有成员----smembers key
        Set<String> k7 = forSet.members("k7");
        System.out.println("k7:" + k7);
        //在集合中随机获取一个成员------srandmember key
        List<String> k71 = forSet.randomMembers("k7", 1);
        System.out.println("k7随机获取一个："+k71);

        //返回指定所有集合的交集------sinter key key
        forSet.add("k8","K71","k81");
        Set<String> intersect = forSet.intersect("k7", "k8");
        System.out.println(intersect);


        //-------------------------sort set有序集合类型------------------------------
        ZSetOperations<String, String> forZSet = redisTemplate.opsForZSet();
        //在集合中添加数据-------zadd key score value score value
        forZSet.add("k9","Chinese" , 100);
        forZSet.add("k9","math" , 900);
        forZSet.add("k9","english" , 80);
        //通过索引区间返回有序集合指定区间内的成员 ----- zrange key start stop
        Set<String> k9 = forZSet.range("k9", 0, -1);
        System.out.println("k9:" + k9);
        //返回有序集合中指定成员的排名，按照score 分数递减排序-----zrevrange key start end
        Set<String> set = forZSet.reverseRange("k9", 0, -1);
        System.out.println("k9递减排序：" + set);

    }

RedisTemplate：

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

 @Autowired
    private StringRedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        //因为user对象在jvm内存中，---放入redis服务器---持久化到磁盘上。---要该对象的类必须序列化
        //key和value都是乱码---因为它默认采用的序列化方式jdk的序列化方式。但是阅读不方便。我们一般不是jdk的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        ValueOperations forValue = redisTemplate.opsForValue();
        forValue.set("user",new User(1,"乔","北京"));
        Object user = forValue.get("user");
        System.out.println(user);
    }

如果每次使用都人为指定序列化方式，统一设置redisTemplate的序列化：

package com.qwq.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @program: springboot-qy163
 * @author: 乔文庆
 * @create: 2023-04-24 16:25
 **/
@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);
        return template;
    }
}

1.5springboot连接集群

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.220.130:7001,192.168.220.130:7002,192.168.220.130:7003,192.168.220.130:7004,192.168.220.130:7005,192.168.220.130:7006

测试：

2.redis的应用场景

2.1 redis可以作为缓存

（1）缓存原理：

（2）缓存作用：减少访问数据库的频率-----提高系统的性能

（3）什么样的数据适合放入缓存：

1.查询频率高的数据 ------2. 修改频率低的-------3.数据安全性要求低的

（4）如何使用缓存：

依赖：

<?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.qwq</groupId>
    <artifactId>springboot-redis2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-redis2</name>
    <description>springboot-redis2</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <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>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</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>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

（5）配置文件：

server.port=8888
spring.datasource.url=jdbc:mysql:///db3
spring.datasource.password=wenqing.
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.220.130
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

service层：

package com.qwq.service.impl;

import com.qwq.mapper.StudentMapper;
import com.qwq.pojo.Student;
import com.qwq.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PostMapping;

/**
 * @program: springboot-redis2
 * @author: 乔文庆
 * @create: 2023-04-24 20:40
 **/
@Service
public class StidentServiceImpl implements StudentService {
    @Autowired
    private StudentMapper studentMapper;
    @Autowired
    private RedisTemplate redisTemplate;


    public Student getById(Integer sid){
        ValueOperations forValue = redisTemplate.opsForValue();
        //redis先查询缓存
        Object o = forValue.get("student::" + sid);
        if(o != null){
            return (Student) o;
        }
        Student student = studentMapper.selectById(sid);
        if(student != null){
            //如果可以查出来数据，先添加到缓存中
            forValue.set("student::"+sid,student);
        }
        return student;

    }
}

Controller层：

package com.qwq.controller;

import com.qwq.pojo.Student;
import com.qwq.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @program: springboot-redis2
 * @author: 乔文庆
 * @create: 2023-04-24 20:35
 **/
@RestController
@RequestMapping("/student")
public class StudentController {
    @Autowired
    private StudentService studentService;

    @GetMapping("findID/{sid}")
    public Student getById(@PathVariable Integer sid){
        return studentService.getById(sid);
    }

}

配置序列化方式：

package com.qwq.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @program: springboot-redis2
 * @author: 乔文庆
 * @create: 2023-04-24 21:10
 **/
@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);
        return template;
    }
}

测试：