Usando o Spring boot para integrar o redis, sua essência é usar o Spring Data Redis do Spring para processar a implementação. Antes de usar, certifique-se de que a instalação do redis esteja concluída e inicie seu servidor, e então você precisa adicionar as dependências correspondentes do redis e do pool de conexão do redis na inicialização do Spring ao framework e, em seguida, escrever o arquivo de configuração correspondente, escrever uma demonstração simples, você pode chamar diretamente o spring fornecido RedisTemplate é usado para implementar operações crud simples. Observe que o armazenamento de objeto precisa ser serializado e não pode ser armazenado diretamente. A classe Serializable pode ser implementada na classe de objeto.
1. Adicionar dependência
Abra um projeto de boot do spring, há duas dependências muito importantes aqui, uma é a dependência do redis no spring boot e a outra é a dependência exigida pelo pool de conexão do redis
<!-- redis依赖包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
Em segundo lugar, escreva o arquivo de configuração.
Aqui é principalmente para definir a configuração básica do redis e a configuração das propriedades do pool de conexão
spring:
#redis
redis:
host: 127.0.0.1
port: 6379
database: 0
timeout: 5000
#连接池
jedis:
pool:
max-idle: 20
min-idle: 2
max-wait: 3000
max-active: 50
3. Escreva uma pequena demonstração para
adicionar um objeto ao redis, com a chave sendo String e valor sendo o objeto.
O redisTemplate fornecido pelo spring já encapsulou algumas coisas, e você pode chamar e usar diretamente a operação simples do redis CRUD. De modo geral, essa classe será transformada em uma classe de ferramenta para facilitar o uso da camada de serviço.
package com.example.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.logging.Logger;
@Component
public class RedisUtils {
@Autowired
private RedisTemplate<Object, Object> redisTemplate;
Logger log = Logger.getLogger("RedisUtils.class");
/**
* 读取缓存
*/
public Object get(final Object key) {
return redisTemplate.opsForValue().get(key);
}
/**
* 写入缓存
*/
public boolean set(final Object key, Object value) {
boolean result = false;
try {
redisTemplate.opsForValue().set(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 更新缓存
*/
public boolean getAndSet(final Object key, Object value) {
boolean result = false;
try {
redisTemplate.opsForValue().getAndSet(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 删除缓存
*/
public boolean delete(final Object key) {
boolean result = false;
try {
redisTemplate.delete(key);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
}
Escreva a classe do objeto e serialize-a (porque para armazenar no redis o conteúdo, o objeto deve ser serializado antes de ser armazenado). A serialização será serializada quando armazenada e desserializada quando removida!
package com.example.model;
import lombok.Data;
import java.io.Serializable;
/*
* 对象存储到redis中需要先序列化
* */
@Data
public class User1 implements Serializable {
private int id;
private String name;
private int age;
}
Na camada de serviço, escreva a implementação diretamente, não a interface
package com.example.serviceimpl;
import com.example.model.User1;
import com.example.util.RedisUtils;
import com.example.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class RedisServiceimpl implements RedisService {
@Autowired
private RedisUtils redisUtils;
public void setUser(){
User1 u = new User1();
u.setAge(1);
u.setId(1);
u.setName("tom");
redisUtils.set("user001",u);
}
public Object getByKey(){
return redisUtils.get("user001");
}
}
Chamada de camada de controlador
package com.example.controller;
import com.example.model.User;
import com.example.model.User1;
import com.example.service.RedisService;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import java.util.List;
import java.util.logging.Logger;
@Controller
public class HelloController {
Logger log = Logger.getLogger("HelloController.class");
@Autowired
UserService userService;
@Autowired
RedisService redisService;
@GetMapping(value = "/hello")
public String hello(){
redisService.setUser();
User1 u = (User1) redisService.getByKey();
log.info(String.valueOf(u));
return "hello";
}
}
Resultados da execução
Esta é apenas a demonstração mais simples. As operações de serialização internas e os cinco tipos de dados suportados pelo redis estão todos no processo de aprendizagem.