Analyse de code d'exemple de cache Redis

1. Introduction

1. Scénario

Étant donné que le dictionnaire de données ne change pas très fréquemment et que le système accède au dictionnaire de données plus fréquemment, il est nécessaire de stocker les données dans le dictionnaire de données dans le cache pour réduire la base de données. Pression et améliorer la vitesse d'accès. Ici, nous utilisons Redis comme middleware de cache distribué du système.

2. RedisTemplate

Dans le projet Spring Boot, Spring Data Redis est intégré par défaut. Spring Data Redis fournit un modèle d'opération très pratique pour Redis, RedisTemplate et peut gérer automatiquement le pool de connexions.

2. Présentez Redis

1. Intégrez Redis dans le projet

Ajoutez une dépendance Redis dans le module de base de service Spring Boot 2.0 et supérieur, connectez-vous à Redis via le pool de connexion commons-pool2 par défaut

<!-- spring boot redis缓存引入 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 缓存连接池-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<!-- redis 存储 json序列化 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

2. Configuration de la connexion Redis

service -Ajoutez la configuration suivante à application.yml de -core

#spring :
redis:
hôte : 192.168.100.100
port : 6379
base de données : 0
mot de passe : 123456 #La valeur par défaut est vide
timeout : 3000 ms #Temps d'attente maximum, S'il expire, une exception sera levée, sinon la demande continuera d'attendre
lettuce:
pool:
max-active : 20 #Nombre maximum de connexions, une valeur négative signifie aucune limite, par défaut 8
max-wait : -1 #Temps d'attente de blocage maximum, valeur négative Indique aucune limite, par défaut -1
max-idle : 8 #Connexion inactive maximale, par défaut 8
min-idle : 0 #Connexion inactive minimale, par défaut 0

3. Démarrez le service Redis

Connectez-vous à distance au serveur Linux, ici local Utilisez redis sur la machine virtuelle centos

#Démarrez le service
cd /usr/local/redis-5.0.7
bin/redis -server redis.conf

3. Test RedisTemplate

1. Test de dépôt

Créez la classe de test RedisTemplateTests dans test

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisTemplateTests {
    @Resource
    private RedisTemplate redisTemplate;
    @Resource
    private DictMapper dictMapper;
    @Test
    public void saveDict(){
        Dict dict = dictMapper.selectById(1);
        //向数据库中存储string类型的键值对, 过期时间5分钟
        redisTemplate.opsForValue().set("dict", dict, 5, TimeUnit.MINUTES);
    }
}

J'ai découvert que RedisTemplate utilise la méthode de sérialisation JDK pour stocker les clés et les valeurs par défaut, ce qui n'est pas lisible

2. Ajoutez RedisConfig au fichier de configuration Redis

service-base Nous pouvons ajouter RedisConfig dans Le schéma de sérialisation Redis est configuré dans ce fichier de configuration

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //首先解决key的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //解决value的序列化方式
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //序列化时将类的数据类型存入json，以便反序列化的时候转换成正确的类型
        ObjectMapper objectMapper = new ObjectMapper();
        //objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        // 解决jackson2无法反序列化LocalDateTime的问题
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.registerModule(new JavaTimeModule());
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

Testez à nouveau, la clé utilise le stockage de chaîne, et la valeur utilise le stockage json

3. Value test

@Test
public void getDict(){
    Dict dict = (Dict)redisTemplate.opsForValue().get("dict");
    System.out.println(dict);
}

4. Stockez le dictionnaire de données dans redis

DictServiceImpl

Remarque : lorsque le serveur Redis est en panne, nous ne devons pas lancer d'exception, mais exécuter le suivre les processus normalement afin que l'entreprise puisse fonctionner normalement

@Resource
private RedisTemplate redisTemplate;
@Override
public List<Dict> listByParentId(Long parentId) {
    //先查询redis中是否存在数据列表
    List<Dict> dictList = null;
    try {
        dictList = (List<Dict>)redisTemplate.opsForValue().get("srb:core:dictList:" + parentId);
        if(dictList != null){
            log.info("从redis中取值");
            return dictList;
        }
    } catch (Exception e) {
        log.error("redis服务器异常：" + ExceptionUtils.getStackTrace(e));//此处不抛出异常，继续执行后面的代码
    }
    log.info("从数据库中取值");
    dictList = baseMapper.selectList(new QueryWrapper<Dict>().eq("parent_id", parentId));
    dictList.forEach(dict -> {
        //如果有子节点，则是非叶子节点
        boolean hasChildren = this.hasChildren(dict.getId());
        dict.setHasChildren(hasChildren);
    });
    //将数据存入redis
    try {
        redisTemplate.opsForValue().set("srb:core:dictList:" + parentId, dictList, 5, TimeUnit.MINUTES);
        log.info("数据存入redis");
    } catch (Exception e) {
        log.error("redis服务器异常：" + ExceptionUtils.getStackTrace(e));//此处不抛出异常，继续执行后面的代码
    }
    return dictList;
}

Résumé Redis intégré :

(1) Importer les dépendances associées

(2) Configurer les informations de connexion Redis

(3) Tester la connexion, tester la valeur et ; test de valeur de sauvegarde ;

(4) Configurez le sérialiseur en fonction de vos propres besoins, sinon le sérialiseur jdk est utilisé par défaut.

Résumé commercial de redis :

(1) Demandez d'abord s'il existe des informations de cache correspondantes dans redis, et s'il y en a, elles seront récupérées et renvoyées directement sans exécution (2), si redis ne peut pas être connecté pour une raison quelconque, telle que en cas de temps d'arrêt, imprimez à ce moment le journal des erreurs et continuez à interroger la base de données ;

(2) Sinon, interrogez la base de données, stockez les données dans Redis et renvoyez les données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!