spring—boot(整合redis)

整合redis

第一步导入数据源

<!--redis-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

RedisConfig（默认有RedisTemplate，下面为自定义）

 @Configuration
public class RedisConfig {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {// 配置redisTemplateRedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();redisTemplate.setConnectionFactory(redisConnectionFactory);RedisSerializer stringSerializer = new StringRedisSerializer();redisTemplate.setKeySerializer(stringSerializer); // key序列化redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); // value序列化redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); // Hash value序列化redisTemplate.afterPropertiesSet();return redisTemplate;}
​
}

编写yml配置文件，对redis进行配置

 spring:
     redis:
        host: 127.0.0.1
        port: 6379
        password:                //最基本的配置到此即可
        lettuce:
          pool:
            max-active: 8 #连接池最大连接数(使用负值表示没有限制)默认为8
            max-wait: -1ms #连接池最大阻塞等待时间(使用负值表示没有限制)默认为-1
            max-idle: 8 #连接池中的最大空闲连接 默认为8
            min-idle: 5 # 连接池中的最小空闲连接 默认为0

 创建服务层和实现类

public interface RedisService {
    void setObj(String key, Object obj, long timeout);
    void setObj(String key, Object obj);
    Object getObj(String key);
}

 

package com.zking.zmall.service.impl;import com.zking.zmall.service.RedisService;
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 java.io.Serializable;
import java.util.concurrent.TimeUnit;// 定义一个Redis服务实现类，用于操作Redis数据
@Service("redisService")
public class RedisServiceImpl implements RedisService {// 自动注入RedisTemplate，用于执行Redis操作@Autowiredprivate RedisTemplate redisTemplate;/*** 设置一个键值对对象到Redis中，并指定过期时间** @param key Redis中的键* @param obj 要保存的对象* @param timeout 对象的过期时间，单位：秒*/@Overridepublic void setObj(final String key, Object obj, long timeout) {// 获取操作Redis中值的操作对象ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();// 保存对象到Redis，并设置过期时间operations.set(key, obj, timeout, TimeUnit.SECONDS);}/*** 设置一个键值对对象到Redis中，使用默认过期时间** @param key Redis中的键* @param obj 要保存的对象*/@Overridepublic void setObj(String key, Object obj) {// 调用另一个setObj方法，并设置默认过期时间为15分钟setObj(key,obj,60*60*15);}/*** 从Redis中获取指定键的对象** @param key Redis中的键* @return 对应键的对象，如果不存在则返回null*/@Overridepublic Object getObj(final String key) {// 获取操作Redis中值的操作对象，并根据键获取对象Object o = redisTemplate.opsForValue().get(key);return o;}
}

 创建测试类测试 

package com.zking.zmall;import com.zking.zmall.service.RedisService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;@SpringBootTest
public class RedisTest {@Autowiredprivate RedisService redisService;@Testpublic void testRedisService(){redisService.setObj("name","zhangsan");}
}

测试结果  

 

做了RedisConfig配置 ，后结果（序列化配置）

利用redis提高性能 

案例二（结合redis）：

 

package com.zking.zmall.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zking.zmall.pojo.SysUser;
import com.zking.zmall.service.RedisService;
import com.zking.zmall.service.SysUserService;
import com.zking.zmall.mapper.SysUserMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.Serializable;

/**
* @author lenovo
* @description 针对表【sys_user(用户信息表)】的数据库操作Service实现
* @createDate 2024-11-03 15:24:57
*/
@Service
@Slf4j
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser>
    implements SysUserService {

    // 注入RedisService用于缓存操作
    @Autowired
    private RedisService redisService;

    /**
     * 根据用户ID获取用户信息，优先从缓存中获取，若缓存不存在则从数据库中获取并存入缓存
     * @param id 用户ID
     * @return 用户信息
     */
    @Override
    public SysUser getById(Serializable id){
        // 尝试从缓存中获取用户信息
        SysUser sysUser = (SysUser) redisService.getObj("zmall:sys:user:"+id);
        if (sysUser==null){
            // 若缓存中无数据，记录日志并从数据库中查询
            log.info("从数据库查询");
            sysUser = getBaseMapper().selectById(id);
            // 将从数据库中查询到的数据存入缓存
            redisService.setObj("zmall:sys:user:"+id,sysUser);
        }
        return sysUser;
    }
}

提高性能：
减少数据库访问：通过先从Redis缓存中获取用户信息，减少了对数据库的直接访问次数，从而减轻了数据库的负载，提高了系统的响应速度。
快速响应：缓存中的数据访问速度远快于数据库，因此能够快速返回用户信息，提升用户体验。

如何切换连接池

简单了解

Jedis vs Lettuce

Jedis 和 Lettuce 是 Java 操作 Redis 的客户端。在 Spring Boot 1.x 版本默认使用的是 jedis ，而在 Spring Boot 2.x 版本默认使用的就是Lettuce。关于 Jedis 跟 Lettuce 的区别如下：

Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个Jedis实例增加物理连接 Lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问，应为StatefulRedisConnection是线程安全的，所以一个连接实例（StatefulRedisConnection）就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

Lettuce

上面有

jedis

pom.xml

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
   <exclusions>//排除
       <exclusion>
           <groupId>io.lettuce</groupId>
           <artifactId>lettuce-core</artifactId>
       </exclusion>
   </exclusions>
</dependency>
​
<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
</dependency>

yml

spring:
    redis:
       host: 127.0.0.1
       port: 6379
       password:
       jedis:
         pool:
           max-active: 8 #连接池最大连接数(使用负值表示没有限制)默认为8
           max-wait: -1ms #连接池最大阻塞等待时间(使用负值表示没有限制)默认为-1
           max-idle: 8 #连接池中的最大空闲连接 默认为8
           min-idle: 5 # 连接池中的最小空闲连接 默认为0