Usando Spring Boot para integrar redis, su esencia es usar Spring Data Redis de Spring para procesar la implementación. Antes de usar, asegúrese de que la instalación de redis esté completa e inicie su servidor, y luego debe agregar las dependencias correspondientes de redis y el grupo de conexiones de redis en el arranque de primavera al marco, y luego escribir el archivo de configuración correspondiente, escribir una demostración simple, puede llamar directamente al resorte siempre que RedisTemplate se use para implementar operaciones crudas simples. Tenga en cuenta que el almacenamiento de objetos debe serializarse y no se puede almacenar directamente. La clase Serializable se puede implementar en la clase de objeto.
1. Agregar dependencia
Abra un proyecto de arranque de primavera, hay dos dependencias muy importantes aquí, una es la dependencia de redis en el arranque de primavera y la otra es la dependencia requerida por el grupo de conexiones de redis
<!-- redis依赖包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
En segundo lugar, escriba el archivo de configuración.
Aquí se utiliza principalmente para configurar la configuración básica de redis y la configuración de las propiedades del grupo de conexiones
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. Escriba una pequeña demostración para
agregar un objeto a redis, con la clave en String y el valor en el objeto.
La redisTemplate proporcionada por Spring ya ha encapsulado algunas cosas, y puede llamar y usar directamente la operación simple de redis CRUD. En términos generales, esta clase se convertirá en una clase de herramienta para facilitar el uso de la capa de servicio.
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;
}
}
Escriba la clase de objeto y serialícela (porque para almacenar en redis el contenido, el objeto debe serializarse antes de que pueda almacenarse). La serialización se serializará cuando se almacene y se deserializará cuando se elimine.
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;
}
En la capa de servicio, escriba la implementación directamente, no la interfaz.
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");
}
}
Llamada a la capa del 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 de la ejecución
Esta es solo la demostración más simple Las operaciones de serialización internas y los cinco tipos de datos admitidos por redis están en proceso de aprendizaje.