学习-15

1. 回顾

1. Redis持久化方式：--把内存中的数据持久化到磁盘中的过程。--防止数据丢失。
    (1)RDB:快照模式 [1]save [2]bgsave [3]配置文件自动触发
    (2)AOF:把写命令追加到日志文件中.
2. Redis集群的模式: 1.主从模式 2.哨兵模式 3.集群模式。

2. 正文

1. java连接redis
2. springboot连接redis操作。
3. 完成缓存操作

3. 连接redis

默认有三种方式连接redis.

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

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

第三种:springboot连接redis

3.1 jedis操作redis服务器

（1）引入jedis依赖

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

（2）编写相关的代码

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

//        对string数据类型操作
        jedis.set("k1", "蔡徐坤");
        String k1 = jedis.get("k1");
        System.out.println("k1: " + k1);
        jedis.setex("k2",60,"律师函");
        String k2 = jedis.get("k2");
        System.out.println("k2: " + k2);

//        对hash数据类型操作
        Map<String, String> map = new HashMap<>();
        map.put("name","蔡徐坤");
        map.put("age","48");
        map.put("hobby","ctrl");
        jedis.hset("k3",map);
        Map<String, String> k3 = jedis.hgetAll("k3");
        System.out.println(k3);

//        对list类型数据操作
        jedis.lpush("k4","蔡徐坤","律师函","ctrl","香翅捞饭","香精煎鱼");
        List<String> k4 = jedis.lrange("k4", 0, -1);
        System.out.println(k4);

        jedis.close();
    }

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

3.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.100.128",6379);


        Jedis jedis = jedisPool.getResource();
        //清空当前库
        jedis.flushDB();

        String set = jedis.set("k1", "v1");
        String k1 = jedis.get("k1");
        System.out.println(k1);

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

3.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.100.128",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.100.128",6379);
            String ping = jedis.ping();
            jedis.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));

    }

3.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.data.redis.host=192.168.100.128
spring.data.redis.port=6379
#最多获取数
spring.data.redis.lettuce.pool.max-active=8
spring.data.redis.lettuce.pool.max-wait=-1ms
spring.data.redis.lettuce.pool.max-idle=8
spring.data.redis.lettuce.pool.min-idle=0

测试:

@SpringBootTest
class SpringBootRedisApplicationTests {
    //因为springboot整合redis时会把StringRedisTemplate创建并交于spring容器管理
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        /*//关于key的操作
        Set<String> keys = redisTemplate.keys("*");//获取所有的key
        System.out.println("keys: "+keys);
        Boolean hasKey = redisTemplate.hasKey("k1");//判断是否存在指定的key
        System.out.println("判断是否存在指定的key: "+hasKey);
        Boolean k1 = redisTemplate.delete("k1");//删除指定的key
        System.out.println("是否删除指定key成功: "+k1);

        //操作字符串===StringRedisTemplate会把对每一种数据的操作单独封装成一个类。
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();//ValueOperations专门操作字符串
        forValue.set("k1","蔡徐坤");

        String k11 = forValue.get("k1");
        System.out.println("k1: "+k11);
        Boolean aBoolean = forValue.setIfAbsent("k2", "律师函");
        System.out.println("是否存入成功:"+aBoolean);
        //incr decr
        Long k3 = forValue.increment("k3",20);
        System.out.println("k3: "+k3);*/


        //可以hash操作
        HashOperations<String, Object, Object> forHash = redisTemplate.opsForHash();
        forHash.put("k1","name","蔡徐坤");
        forHash.put("k1","age","48");
        forHash.put("k1","sex","男");
        Map<String,String> map=new HashMap<>();
        map.put("name","律师函");
        map.put("age","25");
        map.put("sex","信");
        forHash.putAll("k2",map);

        Map<Object, Object> k1 = forHash.entries("k1");
        System.out.println(k1);

        Set<Object> k11 = forHash.keys("k1");
        System.out.println(k11);

        System.out.println(forHash.values("k1"));

        Map<Object, Object> k2 = forHash.entries("k2");
        System.out.println("k2:" + k2);
    }
}

3.4.2 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
    public void test01(){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("student",new Student(1,"蔡徐坤",48,8));

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

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

package com.hzy.springbootredis.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;

@Configuration
public class RedisConfig {

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

上面的连接都是连接的单机版的redis,真实项目它们的redis都是集群模式.

3.5 springboot连接集群

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

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

4. redis的应用场景

4.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>3.0.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hzy</groupId>
    <artifactId>spring-boot-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-redis</name>
    <description>spring-boot-redis</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <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>

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

        <!--mysql-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>

        <!--swagger3依赖-->
        <!-- https://mvnrepository.com/artifact/com.github.xiaoymin/knife4j-openapi3-jakarta-spring-boot-starter -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
            <version>4.1.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/cn.hutool/hutool-all -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.16</version>
        </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>

(3)配置文件

server.port=8888

spring.datasource.url=jdbc:mysql:///company
spring.datasource.password=root
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.100.128
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

(3)servie

@Service
public class StudentServiceImpl implements StudentService {
    @Resource
    private StudentDao studentDao;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public Student getById(Integer sid) {
        ValueOperations<String, Object> forValue = redisTemplate.opsForValue();
        // 1.查询缓存
        Object o = forValue.get("student::" + sid);
        if (o != null) {// 缓存命中
            return (Student) o;
        }
        Student student = studentDao.selectById(sid);
        // 2.查询到放入缓存中
        if (student != null) {
            forValue.set("student::" + sid,student);
        }
        return student;
    }
}
posted @   av404  阅读(19)  评论(0)  编辑  收藏  举报
相关博文：
·  学习-16
·  学习-14
·  springboot连接redis
·  14.Spring Boot与缓存
·  Redis学习(详细版)
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 使用C#创建一个MCP客户端
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现
点击右上角即可分享
微信分享提示
AI IDE Trae