当前位置：首页 > article >正文

spring—boot(整合redis)

article 2024/11/6 18:57:44

整合redis

第一步导入数据源

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

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

 @Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 配置redisTemplate
        RedisTemplate<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操作
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 设置一个键值对对象到Redis中，并指定过期时间
     *
     * @param key Redis中的键
     * @param obj 要保存的对象
     * @param timeout 对象的过期时间，单位：秒
     */
    @Override
    public 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 要保存的对象
     */
    @Override
    public void setObj(String key, Object obj) {
        // 调用另一个setObj方法，并设置默认过期时间为15分钟
        setObj(key,obj,60*60*15);
    }

    /**
     * 从Redis中获取指定键的对象
     *
     * @param key Redis中的键
     * @return 对应键的对象，如果不存在则返回null
     */
    @Override
    public 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 {
    @Autowired
    private RedisService redisService;
    @Test
    public 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

查看全文

http://www.kler.cn/a/381923.html