Este filme apresentará o uso básico do Redis em Java
Diretório de artigos
1. Use jedis para operar redis
1.1 Introdução aos Jedis
Jedis é um kit de ferramentas cliente Redis desenvolvido em linguagem Java, que é usado para interagir com dados Redis em linguagem Java.
Endereço do site oficial do Jedi no github: https://github.com/redis/jedis#readme
Jedis é apenas um encapsulamento de comandos Redis, e você pode facilmente começar a usar Jedis dominando os comandos Redis.
Jedis é desenvolvido seguindo a especificação do protocolo RESP e possui boa versatilidade e legibilidade.
1.2. Apresente a dependência Maven de jedis
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.4.3</version>
</dependency>
1.2. Obtenha conexão
Para muitos aplicativos, é necessário conectar-se ao Redis. É melhor usar um pool de conexões. Um pool de conexões Jedis pode ser instanciado assim:
JedisPool pool = new JedisPool("localhost", 6379);
Para a instância JedisPool, você pode usar o bloco try-With-resources para obter a conexão e executar o comando Redis (desta forma, você não precisa fechá-lo manualmente).
try (Jedis jedis = pool.getResource()) {
// 运行单个 SET 命令
jedis.set("clientName", "Jedis");
}
1.3. Exemplos de uso
Escreva o seguinte código:
public static void main(String[] args) {
// Redis服务端IP和端口号
JedisPool pool = new JedisPool("127.0.0.1", 6379);
try (Jedis jedis = pool.getResource()) {
// 使用相关Redis的命令
// 选择第0个数据库进行操作
jedis.select(0);
// 向0号数据库写入,字符串数据
jedis.set("Java", "best");
jedis.set("PHP", "good");
// 查询是否写入
System.out.println(jedis.get("Java"));
System.out.println(jedis.get("PHP"));
}
}
Execute o caso de teste:
A instância Jedis implementa a maioria dos comandos Redis. Para esses comandos, você pode consultar os métodos correspondentes aos comandos em https://www.javadoc.io/doc/redis.clients/jedis/latest/redis/clients/jedis/ Jedis.htmlApI .
2. Para uso do JedisPooled
2.1. Usar JedisPooled
Usar um bloco try-with-resources para cada comando pode ser complicado, então podemos considerar o uso do JedisPooled.
JedisPooled jedis = new JedisPooled("localhost", 6379);
Código detalhado:
public static void main(String[] args) {
JedisPooled pool = new JedisPooled("127.0.0.1", 6379, null, null);
pool.set("Java", "best");
pool.set("PHP", "good");
System.out.println(pool.get("Java"));
System.out.println(pool.get("PHP"));
}
resultado em execução:
2.2, sobre o pool de conexões
Usar o pool de conexões é a maneira oficialmente recomendada de usá-lo. Você pode usar Jedis melhor por meio do pool de conexões. Podemos configurar o pool de conexões por meio do GenericObjectPoolConfig. Documentação da API GenericObjectPoolConfig: https://commons.apache.org/proper/commons- pool/apidocs/org/apache/commons/pool2/impl/GenericObjectPoolConfig.html
Configure o pool de conexões através do objeto GenericObjectPoolConfig, o código específico é o seguinte:
public static void main(String[] args) {
GenericObjectPoolConfig config = new JedisPoolConfig();
// 设置连接池中最多允许放100个Jedis对象
config.setMaxTotal(100);
// 设置连接池中最大允许空闲连接
config.setMaxIdle(100);
// 设置连接池中最小允许的连接数
config.setMinIdle(10);
// 借出连接的时候是否测试有效性,推荐false
config.setTestOnBorrow(false);
// 归还时是否测试,推荐false
config.setTestOnReturn(false);
// 创建时是否测试有效 开发的时候设置为false,实践运行的时候设置为true
config.setTestOnCreate(false);
// 当连接池内jedis无可用资源时,是否等待资源,true
config.setBlockWhenExhausted(true);
// 没有获取资源时最长等待1秒,1秒后没有还没有的话就报错
config.setMaxWaitMillis(1000);
JedisPool pool = new JedisPool(config, "127.0.0.1", 6379);
try (Jedis jedis = pool.getResource()) {
// 使用相关Redis的命令
// 选择第0个数据库进行操作
jedis.select(0);
// 向0号数据库写入,字符串数据
jedis.set("Java", "best");
jedis.set("PHP", "good");
// 查询是否写入
System.out.println(jedis.get("Java"));
System.out.println(jedis.get("PHP"));
}
}
resultado em execução:
3. Use Redis no SpringBoot
3.1. Apresentando dependências do Maven
Primeiro, você precisa adicionar dependências do Redis ao arquivo pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
Essa dependência inclui Spring Data Redis, bem como a implementação de dois clientes Redis, Jedis e Lettuce.
3.2. Configurar conexão Redis
No projeto SpringBoot, você pode configurar as informações de conexão do Redis no arquivo application.properties ou application.yml. Aqui está um exemplo:
spring:
data:
redis:
timeout: 3000
database: 0
password: password
port: 6379
host: localhost
Entre eles, host e porta são o endereço e número da porta do servidor Redis respectivamente, senha é a senha do Redis (se não houver senha, pode deixar em branco), timeout é o tempo limite da conexão Redis, e jedis .pool é a configuração relacionada do pool de conexões.
3.3. Criar modelo Redis
Para operar Redis com Spring Data Redis, a classe RedisTemplate geralmente é usada. Por conveniência, podemos criar uma classe de ferramenta para gerenciar a criação e uso do RedisTemplate. Aqui está um exemplo:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtils {
/**
* 如果使用 @Autowired 注解完成自动装配 那么
* RedisTemplate要么不指定泛型,要么泛型 为<Stirng,String> 或者<Object,Object>
* 如果你使用其他类型的 比如RedisTemplate<String,Object>
* 那么请使用 @Resource 注解
* */
@Resource
private RedisTemplate<String,Object> redisTemplate;
private Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* 缓存value
*
* @param key -
* @param value -
* @param time -
* @return -
*/
public boolean cacheValue(String key, Object value, long time) {
try {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
valueOperations.set(key, value);
if (time > 0) {
// 如果有设置超时时间的话
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Throwable e) {
logger.error("缓存[" + key + "]失败, value[" + value + "] " + e.getMessage());
}
return false;
}
/**
* 缓存value，没有设置超时时间
*
* @param key -
* @param value -
* @return -
*/
public boolean cacheValue(String key, Object value) {
return cacheValue(key, value, -1);
}
/**
* 判断缓存是否存在
*
* @param key
* @return
*/
public boolean containsKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Throwable e) {
logger.error("判断缓存是否存在时失败key[" + key + "]", "err[" + e.getMessage() + "]");
}
return false;
}
/**
* 根据key，获取缓存
*
* @param key -
* @return -
*/
public Object getValue(String key) {
try {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
return valueOperations.get(key);
} catch (Throwable e) {
logger.error("获取缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
}
return null;
}
/**
* 移除缓存
*
* @param key -
* @return -
*/
public boolean removeValue(String key) {
try {
redisTemplate.delete(key);
return true;
} catch (Throwable e) {
logger.error("移除缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
}
return false;
}
/**
* 根据前缀移除所有以传入前缀开头的key-value
*
* @param pattern -
* @return -
*/
public boolean removeKeys(String pattern) {
try {
Set<String> keySet = redisTemplate.keys(pattern + "*");
redisTemplate.delete(keySet);
return true;
} catch (Throwable e) {
logger.error("移除key[" + pattern + "]前缀的缓存时失败", "err[" + e.getMessage() + "]");
}
return false;
}
}
Neste exemplo, @Resourceinjetamos automaticamente um RedisTemplate<String, Object>objeto usando anotações. Em seguida, fornecemos três métodos para operar no Redis: o método cacheValue é usado para armazenar dados em cache, o método getValue é usado para obter dados armazenados em cache e o método removeValue é usado para excluir dados armazenados em cache. Esses métodos são implementados por meio do objeto redisTemplate.
Deve-se observar que ao usar RedisTemplate, o tipo de par chave-valor precisa ser especificado. Neste exemplo, especificamos que a chave é do tipo String e o valor é do tipo Object.
3.4, use RedisTemplate
No exemplo acima, criamos um objeto RedisTemplate e fornecemos alguns métodos para operar no Redis. Agora, podemos usar esta classe de ferramenta em qualquer lugar do projeto SpringBoot para operações de cache. Aqui está um exemplo:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@Autowired
private RedisUtils redisUtils;
@Autowired
private UserService userService;
@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
String key = "user_" + id;
User user = (User) redisUtils.getValue(key);
if (user == null) {
user = userService.getUserById(id);
redisUtils.cacheValue(key, user);
}
return user;
}
}
Neste exemplo, criamos uma classe UserController para lidar com solicitações HTTP. No método getUserById, primeiro construímos uma chave em cache e, em seguida, usamos redisUtils.getValue o método para obter os dados em cache do Redis. Se não houver dados no cache, chamamos userService.getUserByIdo método para obter os dados do banco de dados e usamos redisUtils.cacheValueo método para armazenar os dados no cache Redis. Por fim, retorne os dados obtidos.
Através deste exemplo, podemos ver o processo de utilização do Redis como cache no projeto SpringBoot. Primeiro precisamos adicionar dependências do Redis e, em seguida, configurar as informações de conexão do Redis no arquivo de configuração. A seguir, criamos uma classe de ferramenta RedisUtil para gerenciar a criação e uso do RedisTemplate. Finalmente, usamos RedisUtils no controlador para armazenar em cache o Redis.