So zwischenspeichern Sie Datenbankdaten in Redis durch benutzerdefinierte Cache-Anmerkungen in SpringBoot

Implementierung

Erstellen Sie zunächst eine neue Tabelle bus_student in MySQL

Verwenden Sie dann die Codegenerierung basierend auf dieser Tabelle, Front-End-Vue und Back-End-Codegenerierung für jede Ebene und fügen Sie Menüs hinzu.

Dann kommen Sie zum Hintergrundcode. Im Hintergrundframework wurden die relevanten Abhängigkeiten und Toolklassen für den Betrieb von Redis hinzugefügt.

Aber hier müssen Sie auch Aspektabhängigkeiten hinzufügen

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

Dann erstellen Sie Annotationen zum Hinzufügen des Redis-Cache

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;

}

und löschen Sie Annotationen für den Redis-Cache

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();
}

, in dem die Konfigurationsklasse gespeichert ist

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;
    }
}

Erstellen Sie dann eine neue benutzerdefinierte Cache-Aspektimplementierung Klasse CacheEnableAspect

Speicherort

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

Achten Sie hier auf queryCache und ClearCache, die darin enthaltenen Pointcut-Ausdrücke

entsprechen den beiden angepassten AopCacheEnable bzw. AopCacheEvict.

Vor und nach der Ausführung der queryCache-Methode, die die Benachrichtigung umgibt, ruft

die Parameter der Cut-Methode und den Schlüssel im Parameter ab und fragt dann Redis entsprechend dem Schlüssel ab.

Wenn er nicht gefunden werden kann, konvertieren Sie ihn Geben Sie das Ergebnis der Methode in die Objektliste zurück und speichern Sie es in Redis.

Wenn es gefunden werden kann, wird das Ergebnis zurückgegeben.

Suchen Sie dann die Abfragemethode und die Mapper-Ebene dieser Tabelle. Wenn Sie beispielsweise die Ergebnisse der Abfragerückgabe in Redis speichern möchten

    /**
     * 新增学生
     *
     * @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);

Dann fügen Sie

rrreee

zu den Mapper-Methoden zum Hinzufügen, Bearbeiten und Löschen dieser Tabelle hinzu. Achten Sie hier auf die Anmerkungen. Der Schlüssel muss mit dem Schlüssel der Anmerkung der obigen Abfrage übereinstimmen.

Dann starten Sie das Projekt, wenn es beim Start dazu auffordert:

Erwägen Sie, eine der Beans als @Primary zu markieren und

den Verbraucher auf Zugriff zu aktualisieren

Weil sringboot festgestellt hat, dass es über @ mehrere Implementierungsklassen der Schnittstelle gibt AutowiredDas heißt, es gibt mehrere Klassen, die diese Schnittstelle erben, und der Federcontainer weiß nicht, welche er verwenden soll.

Suchen Sie die Konfigurationsklasse von Redis, fügen Sie die @Primary-Annotation zu RedisTemplate hinzu

Überprüfen Sie die Verwendung der Annotation

Starten Sie das Projekt mit Debug, fragen Sie den Haltepunkt in der Annotation in CacheEnableAspect ab und rufen Sie dann die Abfragemethode auf

Sie können sehen: Sobald Sie den Haltepunkt eingegeben haben, können Sie die Anmerkungen entsprechend der gewünschten Logik und dem gewünschten Effekt ändern.

🎜🎜

Das obige ist der detaillierte Inhalt vonSo zwischenspeichern Sie Datenbankdaten in Redis durch benutzerdefinierte Cache-Anmerkungen in SpringBoot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!