Prólogo: Comparta brevemente mi intercambio técnico sobre cómo usar SpringBoot para operar la base de datos de Redis en el desarrollo real. ¡He proporcionado el código completo y puede copiarlo y usarlo según sea necesario!
Tabla de contenido
1. Importar dependencias de pom
Dos, archivo de configuración yml
3. Utilice la serialización FastJson
Cuarto, la clase de configuración central.
6. Clase de entidad de usuario
Siete, cinco tipos de datos básicos
1. Importar dependencias de pom
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- lombok依赖 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- redis依赖 对象池 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- pool 对象池 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.11.1</version>
</dependency>
<!-- 阿里JSON解析器 -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.34</version>
</dependency>
</dependencies>Dos, archivo de configuración yml
spring:
redis:
host: localhost
port: 6379
database: 0
password:
timeout: 10s
lettuce:
pool:
min-idle: 0
max-idle: 8
max-active: 8
max-wait: -1ms
3. Utilice la serialización FastJson
Esta clase FastJson2JsonRedisSerializer implementa la interfaz RedisSerializer de Spring Redis, que se utiliza para serializar y deserializar objetos usando FastJson.
1. En el método de construcción, se pasa la clase genérica Class<T>, que indica el tipo de objeto que debe serializarse.
private Class<T> clazz;
public FastJson2JsonRedisSerializer(Class<T> clazz)
{
super();
this.clazz = clazz;
}2. El método serializar implementa la serialización, convierte el objeto en una cadena JSON y lo convierte en una matriz de bytes. Utilice la función JSONWriter.Feature.WriteClassName para escribir el nombre de la clase durante la serialización, lo cual es conveniente para la deserialización.
@Override
public byte[] serialize(T t) throws SerializationException
{
if (t == null)
{
return new byte[0];
}
return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);
}3. El método deserialize implementa la deserialización, convierte la matriz de bytes en una cadena y luego la deserializa en un objeto usando el método parseObject de FastJson y usa la función JSONReader.Feature.SupportAutoType para seleccionar automáticamente el tipo de clase durante la deserialización.
@Override
public T deserialize(byte[] bytes) throws SerializationException
{
if (bytes == null || bytes.length <= 0)
{
return null;
}
String str = new String(bytes, DEFAULT_CHARSET);
return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);
}Código completo:
package com.example.redis.config;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONReader;
import com.alibaba.fastjson2.JSONWriter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import java.nio.charset.Charset;
/**
* Redis使用FastJson序列化
*/
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private Class<T> clazz;
public FastJson2JsonRedisSerializer(Class<T> clazz)
{
super();
this.clazz = clazz;
}
@Override
public byte[] serialize(T t) throws SerializationException
{
if (t == null)
{
return new byte[0];
}
return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);
}
@Override
public T deserialize(byte[] bytes) throws SerializationException
{
if (bytes == null || bytes.length <= 0)
{
return null;
}
String str = new String(bytes, DEFAULT_CHARSET);
return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);
}
}
Cuarto, la clase de configuración central.
1. Cree un objeto RedisTemplate.
RedisTemplate<Object, Object> template = new RedisTemplate<>();2. Configure la fábrica de conexiones de Redis.
template.setConnectionFactory(redisConnectionFactory);3. Cree un serializador JSON utilizando FastJson.
FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);4. Establezca el método de serialización de Key en StringRedisSerializer.
template.setKeySerializer(new StringRedisSerializer());5. Establezca el método de serialización de Valor en el serializador JSON creado anteriormente.
template.setValueSerializer(serializer);6. Configure el método de serialización de la clave de tipo Hash.
template.setHashKeySerializer(new StringRedisSerializer());7. Establezca el método de serialización del valor de tipo Hash.
template.setHashValueSerializer(serializer);8. Inicialice el objeto de plantilla.
template.afterPropertiesSet();Código completo:
package com.example.redis.config;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* redis配置
*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{
@Bean
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
{
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(serializer);
// Hash的key也采用StringRedisSerializer的序列化方式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(serializer);
template.afterPropertiesSet();
return template;
}
}
5. Herramientas
Código completo:
package com.example.redis.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* spring redis 工具类
**/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
{
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout)
{
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit)
{
return redisTemplate.expire(key, timeout, unit);
}
/**
* 获取有效时间
*
* @param key Redis键
* @return 有效时间
*/
public long getExpire(final String key)
{
return redisTemplate.getExpire(key);
}
/**
* 判断 key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public Boolean hasKey(String key)
{
return redisTemplate.hasKey(key);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key)
{
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key)
{
return redisTemplate.delete(key);
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public boolean deleteObject(final Collection collection)
{
return redisTemplate.delete(collection) > 0;
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <T> long setCacheList(final String key, final List<T> dataList)
{
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <T> List<T> getCacheList(final String key)
{
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
{
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
Iterator<T> it = dataSet.iterator();
while (it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
{
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key)
{
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value)
{
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <T> T getCacheMapValue(final String key, final String hKey)
{
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
{
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
/**
* 删除Hash中的某条数据
*
* @param key Redis键
* @param hKey Hash键
* @return 是否成功
*/
public boolean deleteCacheMapValue(final String key, final String hKey)
{
return redisTemplate.opsForHash().delete(key, hKey) > 0;
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern)
{
return redisTemplate.keys(pattern);
}
/**
* 存储有序集合
* @param key 键
* @param value 值
* @param score 排序
*/
public void zSet(Object key, Object value, double score){
redisTemplate.opsForZSet().add(key, value, score);
}
/**
* 存储值
* @param key 键
* @param set 集合
*/
public void zSet(Object key, Set set){
redisTemplate.opsForZSet().add(key, set);
}
/**
* 获取key指定范围的值
* @param key 键
* @param start 开始位置
* @param end 结束位置
* @return 返回set
*/
public Set zGet(Object key, long start, long end){
Set set = redisTemplate.opsForZSet().range(key, start, end);
return set;
}
/**
* 获取key对应的所有值
* @param key 键
* @return 返回set
*/
public Set zGet(Object key){
Set set = redisTemplate.opsForZSet().range(key, 0, -1);
return set;
}
/**
* 获取对用数据的大小
* @param key 键
* @return 键值大小
*/
public long zGetSize(Object key){
Long size = redisTemplate.opsForZSet().size(key);
return size;
}
}
6. Clase de entidad de usuario
Necesidad de implementar una interfaz de serialización
package com.example.redis.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable{
private String username;
private String password;
}
Siete, cinco tipos de datos básicos
A continuación se muestra un ejemplo de cómo utilizar cada etiqueta.
7.1, tipo de cadena
@Autowired
private RedisCache redisCache;
public void string(){
User user = new User("mike","123456");
redisCache.setCacheObject("user",user);
User redisUser = redisCache.getCacheObject("user");
System.out.println(redisUser);
}7.2, tipo de lista
@Autowired
private RedisCache redisCache;
public void list(){
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
redisCache.setCacheList("list",list);
List<Object> redisList = redisCache.getCacheList("list");
System.out.println(redisList);
}7.3, tipo de configuración
@Autowired
private RedisCache redisCache;
public void set(){
Set<String> set = new HashSet<>();
set.add("aaa");
set.add("bbb");
redisCache.setCacheSet("set",set);
Set<String> redisSet = redisCache.getCacheSet("set");
System.out.println(redisSet);
}7.4 Tipo de mapa
@Autowired
private RedisCache redisCache;
public void map(){
User user = new User("mike","123456");
Map<String,String> map = new HashMap<>(16);
map.put("username", user.getUsername());
map.put("password", user.getPassword());
redisCache.setCacheMap("map",map);
Map<String,String> redisMap = redisCache.getCacheMap("map");
System.out.println(redisMap);
}7.5, tipo ZSet
@Autowired
private RedisCache redisCache;
public void ZSet(){
String key = "ZSet_key";
User user1 = new User("Tom", "123");
User user2 = new User("Jack", "123");
Set<User> hashSet = new HashSet<>();
hashSet.add(user1);
hashSet.add(user2);
redisCache.zSet(key,user1,0);
redisCache.zSet(key,user2,1);
Set set = redisCache.zGet(key, 0, -1);
System.out.println(set);
}8. Código fuente de Gitee
He subido el código fuente a la nube de códigos, puedes extraerlo si lo necesitas:
Dirección: SpringBoot integra RedisTemplate para operar el intercambio completo de código de datos de Redis
Nueve Resumen
Lo anterior es un código compartido común sobre cómo SpringBoot opera la base de datos de Redis en el desarrollo real del proyecto. Si tiene alguna pregunta, ¡bienvenido a discutirla en el área de comentarios!