Comment mettre en cache les données de la base de données sur Redis via des annotations de cache personnalisées dans SpringBoot

Implémentation

Créez d'abord une nouvelle table bus_student dans Mysql

Utilisez ensuite la génération de code basée sur cette table, Vue frontale et la génération de code back-end pour chaque couche et ajoutez des menus.

Venons-en ensuite au code d'arrière-plan. Dans le framework d'arrière-plan, les dépendances et classes d'outils pertinentes pour faire fonctionner Redis ont été ajoutées.

Mais ici, vous devez également ajouter des dépendances d'aspect

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects --><dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.14.RELEASE</version>
        </dependency>

Créez ensuite des annotations pour ajouter le cache Redis

package com.ruoyi.system.redisAop;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;/*
 * @Author
 * @Description 新增redis缓存
 **/@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)public @interface AopCacheEnable {//redis缓存key    String[] key();//redis缓存存活时间默认值（可自定义）long expireTime() default 3600;

}

et supprimez les annotations pour le cache Redis

package com.ruoyi.system.redisAop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;/*
 * @Description 删除redis缓存注解
 **/@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)public @interface AopCacheEvict {//redis中的key值    String[] key();
}

où la classe de configuration est stockée

package com.ruoyi.system.redisAop;


import com.ruoyi.system.domain.BusStudent;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;/*
 * @Description 自定义缓存切面具体实现类
 **/@Aspect
@Componentpublic class CacheEnableAspect {

    @Autowiredpublic RedisTemplate redisCache;/**
     * Mapper层切点 使用到了我们定义的 AopCacheEnable 作为切点表达式。     */@Pointcut("@annotation(com.ruoyi.system.redisAop.AopCacheEnable)")public void queryCache() {
    }/**
     * Mapper层切点 使用到了我们定义的 AopCacheEvict 作为切点表达式。     */@Pointcut("@annotation(com.ruoyi.system.redisAop.AopCacheEvict)")public void ClearCache() {
    }

    @Around("queryCache()")public Object Interceptor(ProceedingJoinPoint pjp) {
        Object result = null;//注解中是否有#标识boolean spelFlg = false;//判断是否需要走数据库查询boolean selectDb = false;//redis中缓存的keyString redisKey = "";//获取当前被切注解的方法名Method method = getMethod(pjp);//获取当前被切方法的注解AopCacheEnable aopCacheEnable = method.getAnnotation(AopCacheEnable.class);//获取方法参数值Object[] arguments = pjp.getArgs();//从注解中获取字符串String[] spels = aopCacheEnable.key();for (String spe1l : spels) {if (spe1l.contains("#")) {//注解中包含#标识，则需要拼接spel字符串,返回redis的存储redisKeyredisKey = spe1l.substring(1) + arguments[0].toString();
            } else {//没有参数或者参数是List的方法，在缓存中的keyredisKey = spe1l;
            }//取出缓存中的数据result = redisCache.opsForValue().get(redisKey);//缓存是空的，则需要重新查询数据库if (result == null || selectDb) {try {
                    result =  pjp.proceed();//从数据库查询到的结果不是空的if (result != null && result instanceof ArrayList) {//将redis中缓存的结果转换成对象listList<BusStudent> students = (List<BusStudent>) result;//判断方法里面的参数是不是BusStudentif (arguments[0] instanceof BusStudent) {//将rediskey-students 存入到redisredisCache.opsForValue().set(redisKey, students, aopCacheEnable.expireTime(), TimeUnit.SECONDS);
                        }
                    }
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        }return result;
    }/*** 定义清除缓存逻辑，先操作数据库，后清除缓存*/@Around(value = "ClearCache()")public Object evict(ProceedingJoinPoint pjp) throws Throwable {//redis中缓存的keyMethod method = getMethod(pjp);// 获取方法的注解AopCacheEvict cacheEvict = method.getAnnotation(AopCacheEvict.class);//先操作dbObject result = pjp.proceed();// 获取注解的key值String[] fieldKeys = cacheEvict.key();for (String spe1l : fieldKeys) {//根据key从缓存中删除            redisCache.delete(spe1l);
        }return result;
    }/**
     * 获取被拦截方法对象     */public Method getMethod(ProceedingJoinPoint pjp) {
        Signature signature = pjp.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method targetMethod = methodSignature.getMethod();return targetMethod;
    }
}

Créez ensuite une nouvelle implémentation d'aspect de cache personnalisée class CacheEnableAspect

Storage location

    @AopCacheEnable(key = "BusStudent",expireTime = 40)public List<BusStudent> selectBusStudentList(BusStudent busStudent);

Faites attention à queryCache et ClearCache ici, les expressions pointcut à l'intérieur

correspondent respectivement aux deux AopCacheEnable et AopCacheEvict personnalisés.

Ensuite, avant et après l'exécution de la méthode queryCache entourant la notification,

obtient les paramètres de la méthode cut et la clé dans le paramètre, puis interroge redis en fonction de la clé

Si elle ne peut pas être trouvée, convertissez la. renvoie le résultat de la méthode dans la liste d'objets et stockez-le dans redis

S'il peut être trouvé, le résultat sera renvoyé.

Recherchez ensuite la méthode de requête et la couche de mappage de cette table. Par exemple, si vous souhaitez stocker les résultats de la requête dans redis

    /**
     * 新增学生
     *
     * @param busStudent 学生
     * @return 结果     */@AopCacheEvict(key = "BusStudent")public int insertBusStudent(BusStudent busStudent);/**
     * 修改学生
     *
     * @param busStudent 学生
     * @return 结果     */@AopCacheEvict(key = "BusStudent")public int updateBusStudent(BusStudent busStudent);/**
     * 删除学生
     *
     * @param id 学生ID
     * @return 结果     */@AopCacheEvict(key = "BusStudent")public int deleteBusStudentById(Integer id);

Ajoutez ensuite

rrreee

aux méthodes de mappage pour ajouter, modifier et supprimer cette table. Faites attention aux annotations ici. La clé doit être cohérente avec la clé de l'annotation de la requête ci-dessus.

Ensuite, démarrez le projet, s'il vous invite au démarrage :

Envisagez de marquer l'un des beans comme @Primary, en mettant à jour

le consommateur pour qu'il acce

Parce que sringboot a constaté qu'il existe plusieurs classes d'implémentation de l'interface via @ Autowired, c'est-à-dire que plusieurs classes héritent de cette interface et que le conteneur Spring ne sait pas laquelle utiliser.

Trouvez la classe de configuration de redis, ajoutez l'annotation @Primary sur le RedisTemplate

Vérifiez l'utilisation de l'annotation

Démarrez le projet avec debug, interrogez le point d'arrêt dans l'annotation dans CacheEnableAspect, puis appelez la requête méthode,

vous pouvez voir Une fois que vous pouvez entrer le point d'arrêt, vous pouvez modifier les annotations selon la logique et l'effet souhaités.

🎜🎜

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!