Introdução ao uso do redis integrado springBoot (caso detalhado)

Language 2023-10-04 22:28:56 views: null

Visualização do artigo:

Introdução

StringRedisTemplate é usado no caso. As razões pelas quais RedisTemplate não é usado são as seguintes:
Em projetos de produção reais, mais StringRedisTemplate é usado para armazenar dados em cache;
análise de casos usando RedisTemplate

Depois de especificarmos o método de serialização para RedisTemplate ( key为RedisSerializer.string(), value为GenericJackson2JsonRedisSerializer), quando armazenarmos o valor como um objeto de classe de entidade , ocorrerá o seguinte fenômeno:
Insira a descrição da imagem aqui
Isso ocorre porque quando o valor que passamos for um objeto de classe de entidade , GenericJackson2JsonRedisSerializerum serializador será usado para java对象转为JSON格式e, em seguida, armazená-lo na biblioteca Redis. Quando usamos para obter dados, desserializamos em um objeto JAVA redisTemplate.opsForValue().get方法por meio dos atributos armazenados .@classJSON

Desta forma, podemos ver os dados intuitivamente no controlador IDEA, mas também há uma desvantagem -> desperdício de memória, pois precisamos armazenar os dados extras de @class para desserializar a string JSON.

Para economizar memória, Valuenão a usamos durante o processamento GenericJackson2JsonRedisSerializer序列化器, mas sim RedisSerializer.string序列化器. Dessa forma, precisamos apenas converter manualmente o objeto JAVA em uma string de formato JSON ao armazenar dados e, em seguida, converter o JSON de volta em um objeto JAVA ao buscar os dados.

A chave e o valor de StringRedisTemplate são String por padrão, portanto, não precisamos definir nós mesmos a classe de configuração de RedisTemplate.

1. Crie um projeto springboot (usando o método esqueleto)

1.使用 StringRedisTemplate
2.写入 Redis 时,手动把对象序列化为 JSON
3.读取 Redis 时,手动把读取到的 JSON 反序列化为对象

O código fonte do caso
Insira a descrição da imagem aqui
Insira a descrição da imagem aqui
Insira a descrição da imagem aqui
Insira a descrição da imagem aqui
Insira a descrição da imagem aqui
Insira a descrição da imagem aqui
é criado;
vamos analisar o conteúdo do arquivo pom:
as principais dependências utilizadas:

 <!--springBoot集成redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.5.4</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.5.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

2. Arquivo de configuração

server.port=8088
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=123456
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=30000

3. Use redis

package com.example.redis.cache;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @author wxl
 * @date 2021-08-15 18:44
 */
@Slf4j
@Component
public class CacheService {
    
    
    @Autowired
    private StringRedisTemplate redisTemplate;

    private final String DEFAULT_KEY_PREFIX = "";
    private final int EXPIRE_TIME = 1;
    private final TimeUnit EXPIRE_TIME_TYPE = TimeUnit.DAYS;


    /**
     * 数据缓存至redis
     *
     * @param key
     * @param value
     * @return
     */
    public <K, V> void add(K key, V value) {
    
    
        try {
    
    
            if (value != null) {
    
    
                redisTemplate
                        .opsForValue()
                        .set(DEFAULT_KEY_PREFIX + key, JSON.toJSONString(value));
            }
        } catch (Exception e) {
    
    
            log.error(e.getMessage(), e);
            throw new RuntimeException("数据缓存至redis失败");
        }
    }

    /**
     * 数据缓存至redis并设置过期时间
     *
     * @param key
     * @param value
     * @return
     */
    public <K, V> void add(K key, V value, long timeout, TimeUnit unit) {
    
    
        try {
    
    
            if (value != null) {
    
    
                redisTemplate
                        .opsForValue()
                        .set(DEFAULT_KEY_PREFIX + key, JSON.toJSONString(value), timeout, unit);
            }
        } catch (Exception e) {
    
    
            log.error(e.getMessage(), e);
            throw new RuntimeException("数据缓存至redis失败");
        }
    }

    /**
     * 写入 hash-set,已经是key-value的键值，不能再写入为hash-set
     *
     * @param key    must not be {@literal null}.
     * @param subKey must not be {@literal null}.
     * @param value  写入的值
     */
    public <K, SK, V> void addHashCache(K key, SK subKey, V value) {
    
    
        redisTemplate.opsForHash().put(DEFAULT_KEY_PREFIX + key, subKey, value);
    }

    /**
     * 写入 hash-set,并设置过期时间
     *
     * @param key    must not be {@literal null}.
     * @param subKey must not be {@literal null}.
     * @param value  写入的值
     */
    public <K, SK, V> void addHashCache(K key, SK subKey, V value, long timeout, TimeUnit unit) {
    
    
        redisTemplate.opsForHash().put(DEFAULT_KEY_PREFIX + key, subKey, value);
        redisTemplate.expire(DEFAULT_KEY_PREFIX + key, timeout, unit);
    }

    /**
     * 获取 hash-setvalue
     *
     * @param key    must not be {@literal null}.
     * @param subKey must not be {@literal null}.
     */
    public <K, SK> Object getHashCache(K key, SK subKey) {
    
    
        return  redisTemplate.opsForHash().get(DEFAULT_KEY_PREFIX + key, subKey);
    }


    /**
     * 从redis中获取缓存数据，转成对象
     *
     * @param key   must not be {@literal null}.
     * @param clazz 对象类型
     * @return
     */
    public <K, V> V getObject(K key, Class<V> clazz) {
    
    
        String value = this.get(key);
        V result = null;
        if (!StringUtils.isEmpty(value)) {
    
    
            result = JSONObject.parseObject(value, clazz);
        }
        return result;
    }

    /**
     * 从redis中获取缓存数据，转成list
     *
     * @param key   must not be {@literal null}.
     * @param clazz 对象类型
     * @return
     */
    public <K, V> List<V> getList(K key, Class<V> clazz) {
    
    
        String value = this.get(key);
        List<V> result = Collections.emptyList();
        if (!StringUtils.isEmpty(value)) {
    
    
            result = JSONArray.parseArray(value, clazz);
        }
        return result;
    }

    /**
     * 功能描述：Get the value of {@code key}.
     *
     * @param key must not be {@literal null}.
     * @return java.lang.String
     * @date 2021/9/19
     **/
    public <K> String get(K key) {
    
    
        String value;
        try {
    
    
            value = redisTemplate.opsForValue().get(DEFAULT_KEY_PREFIX + key);
        } catch (Exception e) {
    
    
            log.error(e.getMessage(), e);
            throw new RuntimeException("从redis缓存中获取缓存数据失败");
        }
        return value;
    }

    /**
     * 删除key
     */
    public void delete(String key) {
    
    
        redisTemplate.delete(key);
    }

    /**
     * 批量删除key
     */
    public void delete(Collection<String> keys) {
    
    
        redisTemplate.delete(keys);
    }

    /**
     * 序列化key
     */
    public byte[] dump(String key) {
    
    
        return redisTemplate.dump(key);
    }

    /**
     * 是否存在key
     */
    public Boolean hasKey(String key) {
    
    
        return redisTemplate.hasKey(key);
    }

    /**
     * 设置过期时间
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
    
    
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 设置过期时间
     */
    public Boolean expireAt(String key, Date date) {
    
    
        return redisTemplate.expireAt(key, date);
    }


    /**
     * 移除 key 的过期时间，key 将持久保持
     */
    public Boolean persist(String key) {
    
    
        return redisTemplate.persist(key);
    }

    /**
     * 返回 key 的剩余的过期时间
     */
    public Long getExpire(String key, TimeUnit unit) {
    
    
        return redisTemplate.getExpire(key, unit);
    }

    /**
     * 返回 key 的剩余的过期时间
     */
    public Long getExpire(String key) {
    
    
        return redisTemplate.getExpire(key);
    }
}

1. Adicione string ao redis

    /**
     * 功能描述：添加字符串到redis
     */
    @Test
    void add() {
    
    
        cacheService.add("test", 1234);
    }

resultado:
Insira a descrição da imagem aqui

2. Converta o objeto em jsonString e armazene-o em redis

    /**
     * 功能描述：添加对象至redis
     */
    @Test
    void addObject() {
    
    
        User user = User.builder()
                .id(ID)
                .name("小萌")
                .age(AGE)
                .build();
        cacheService.add(user.getId(), user);
    }

resultado:Insira a descrição da imagem aqui

3. Converta a coleção de objetos em jsonString, defina o tempo de expiração e salve-o no redis

    /**
     * 功能描述：添加对象集合至redis
     */
    @Test
    void addObjects() {
    
    
        ArrayList<User> users = new ArrayList<>();
        User user = User.builder()
                .id(ID)
                .name("小萌")
                .age(AGE)
                .build();
        users.add(user);
        cacheService.add("key", users, 1, TimeUnit.HOURS);
    }

resultado:
Insira a descrição da imagem aqui

4. Pegue o objeto

  /**
     * 功能描述：获取对象
     */
    @Test
    void getObject() {
    
    
        User object = cacheService.getObject(ID, User.class);
        System.out.println("object = " + object);
    }

resultado:

object = User(id=123, name=小萌, age=12)

5. Obtenha a coleção de objetos

   /**
     * 功能描述：获取对象集合
     */
    @Test
    void getObjects() {
    
    
        List<User> users = cacheService.getList("key", User.class);
        System.out.println("users = " + users);
    }

resultado:

users = [User(id=123, name=小萌, age=12)]

6. Adicionar conjunto de hash

    /**
     * 功能描述：添加 hash-set
     */
    @Test
    void addHashCache() {
    
    
        cacheService.addHashCache("hashKey", "key", "value");
    }

resultado:
Insira a descrição da imagem aqui

7. Obtenha o valor definido de hash

   /**
     * 功能描述：获取 hash-set
     */
    @Test
    void getHashCache() {
    
    
        Object hashCache = cacheService.getHashCache("hashKey", "key");
        System.out.println("hashCache = " + hashCache);
    }

resultado:

hashCache = value

Quatro códigos-fonte de casos

springBoot integra código-fonte redis

Artigo anterior: SpringDataRedis

Acho que você gosta

Origin blog.csdn.net/weixin_43811057/article/details/120382906
Recomendado
Clasificación
Diario
Más
2024-05-26(0)
2024-05-25(0)
2024-05-24(11)
2024-05-23(35)
2024-05-22(9)
2024-05-21(34)
2024-05-20(5)
2024-05-19(0)
2024-05-18(32)
2024-05-17(5)

Code World

© 2018 codetd.com