摘要：本文介绍了如何在 Spring Boot 项目中集成 Redis，并利用 Redis 实现缓存功能。文章包括配置 Redis 连接、使用 Jedis 和 RedisTemplate 两种方式进行操作的示例代码，并探讨了它们的优缺点。
随着互联网应用的不断发展，对于数据的高效读写和缓存处理变得越来越重要。而 Redis 作为一款高性能的缓存数据库，被广泛应用于各种大型系统中。本文将介绍如何在 Spring Boot 项目中集成 Redis，并利用 Redis 实现缓存功能。
一、配置 Redis 连接
在 Spring Boot 项目中，我们可以通过配置文件来指定 Redis 的连接参数。以 YAML 格式的配置文件为例，示例如下：
spring:
redis:
database: 3
password: xxxx
timeout: 60000 #连接超时
host: 10.xxx.14.40
port: 6379
jedis:
pool:
max-idle: 6 #最大空闲数
max-active: 100 #最大连接数
min-idle: 2 #最小空闲数
以上配置了 Redis 的数据库编号、密码、连接超时时间以及连接池的相关参数。
二、使用 Jedis 操作 Redis
Jedis 是 Java 操作 Redis 的一款常用客户端库。下面是使用 Jedis 进行操作的示例代码。
首先，我们需要创建一个 JedisConfig 类，用于配置 Jedis 连接池：
@Slf4j
@Configuration
public class JedisConfig {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.timeout}")
private Integer timeout;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.database}")
private Integer database;
@Value("${spring.redis.jedis.pool.max-active}")
private int maxActive;
@Value("${spring.redis.jedis.pool.max-idle}")
private int maxIdle;
@Value("${spring.redis.jedis.pool.min-idle}")
private int minIdle;
@Bean
public JedisPool jedisPool() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMinIdle(minIdle);
jedisPoolConfig.setMaxTotal(maxActive);
JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, "default", password, database);
log.info("JedisPool Connection Success:" + host + "\t" + port);
return jedisPool;
}
}
在上述代码中，我们通过@Configuration 注解将 JedisConfig 类标识为配置类，并通过@Bean 注解将 jedisPool 方法返回的 JedisPool 对象注册为 Spring 的 Bean。
接下来，我们可以创建一个 JedisUtils 类，用于获取 Jedis 资源和释放连接：
@Component
public class JedisUtils {
@Autowired
private JedisPool jedisPool;
/**
* 获取Jedis资源
*/
public Jedis getJedis() {
return jedisPool.getResource();
}
/**
* 释放Jedis连接
*/
public void close(Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
}
在上述代码中，我们通过@Autowired 注解将 JedisPool 对象注入到 JedisUtils 类中。通过调用 getJedis 方法，我们可以获取一个 Jedis 资源对象，用于后续的操作。在完成操作后，调用 close 方法释放 Jedis 连接，以便连接可以被连接池重复利用。
接下来，我们可以创建一个 JedisClient 类，用于具体的操作 Redis：
@Slf4j
@Component
public class JedisClient {
@Autowired
private JedisUtils jedisUtils;
/**
* 根据key查询value值
*/
public String get(String key) {
Jedis jedis = jedisUtils.getJedis();
try {
if (!jedis.exists(key)) {
log.info("key:{}在Redis中查不到数据.", key);
} else {
return jedis.get(key);
}
} catch (Exception e) {
log.error("Jedis get操作出错", e);
} finally {
jedisUtils.close(jedis);
}
return null;
}
/**
* 设置key-value
*/
public void set(String key, String value) {
Jedis jedis = jedisUtils.getJedis();
try {
jedis.set(key, value);
} catch (Exception e) {
log.error("Jedis set操作出错", e);
} finally {
jedisUtils.close(jedis);
}
}
/**
* 删除key
*/
public void delete(String key) {
Jedis jedis = jedisUtils.getJedis();
try {
jedis.del(key);
} catch (Exception e) {
log.error("Jedis delete操作出错", e);
} finally {
jedisUtils.close(jedis);
}
}
}
在上述代码中，我们通过@Autowired 注解将 JedisUtils 对象注入到 JedisClient 类中，以获取 Jedis 资源。然后，我们可以定义一些常见的 Redis 操作方法，例如 get、set 和 delete。
最后，我们可以在需要使用缓存的地方调用 JedisClient 类进行 Redis 操作。例如：
@RestController
public class UserController {
@Autowired
private JedisClient jedisClient;
@GetMapping("/user/{id}")
public User getUserById(@PathVariable("id") String id) {
String key = "user:" + id;
String value = jedisClient.get(key);
if (value != null) {
return JSON.parseObject(value, User.class);
} else {
User user = userService.getUserById(id);
if (user != null) {
jedisClient.set(key, JSON.toJSONString(user));
}
return user;
}
}
}
在上述代码中，我们首先根据缓存的 key 值查询 Redis 中是否存在对应的 value 值。如果存在，则直接从 Redis 中获取缓存数据。如果不存在，则从数据库中获取数据，并将数据存入 Redis 中以供下次使用。
三、使用 RedisTemplate 操作 Redis
除了使用 Jedis 进行 Redis 操作外，Spring Boot 还提供了另一种方式：使用 RedisTemplate。下面是使用 RedisTemplate 进行操作的示例代码。
首先，我们需要创建一个 RedisConfig 类，用于配置 RedisTemplate：
@Configuration
public class RedisConfig {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.timeout}")
private Integer timeout;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.database}")
private Integer database;
@Bean
public RedisConnectionFactory redisConnectionFactory() {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(host, port);
config.setDatabase(database);
config.setPassword(RedisPassword.of(password));
LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(config);
connectionFactory.setTimeout(timeout);
return connectionFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(connectionFactory);
// 设置key和value的序列化方式
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
return redisTemplate;
}
}
在上述代码中，我们通过@Configuration 注解将 RedisConfig 类标识为配置类，并通过@Bean 注解分别注册了 redisConnectionFactory 和 redisTemplate 对象。在 redisTemplate 方法中，我们设置了 key 和 value 的序列化方式，这里使用了 StringRedisSerializer 和 GenericJackson2JsonRedisSerializer。
接下来，我们可以在需要使用缓存的地方注入 RedisTemplate 对象，并调用相应的方法进行 Redis 操作。例如：
@RestController
public class UserController {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@GetMapping("/user/{id}")
public User getUserById(@PathVariable("id") String id) {
String key = "user:" + id;
User user = (User) redisTemplate.opsForValue().get(key);
if (user != null) {
return user;
} else {
user = userService.getUserById(id);
if (user != null) {
redisTemplate.opsForValue().set(key, user);
}
return user;
}
}
}
在上述代码中，我们通过 RedisTemplate 的 opsForValue 方法获取 ValueOperations 对象，并调用 get 方法从 Redis 中获取缓存数据。如果数据不存在，则从数据库中