Bagaimana untuk cache data pangkalan data ke Redis melalui anotasi cache tersuai dalam SpringBoot

Pelaksanaan

Mula-mula buat jadual bas_pelajar baharu dalam Mysql

Kemudian gunakan penjanaan kod berdasarkan jadual ini, dan Vue bahagian hadapan dan belakang -penjanaan kod akhir digabungkan Tambah menu.

Kemudian datang ke kod latar belakang Dalam rangka kerja latar belakang, kebergantungan yang berkaitan dan kelas alat untuk operasi redis telah ditambahkan.

Tetapi di sini anda juga perlu menambah kebergantungan aspek

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

dan kemudian mencipta anotasi untuk menambah 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;

}

dan memadam cache redis

di mana konfigurasi kelas disimpan. di sini, dan titik potong di dalam Ungkapan

masing-masing sepadan dengan dua AopCacheEnable dan AopCacheEvict tersuai di atas.

Kemudian sebelum dan selepas kaedah queryCache bagi pemberitahuan sekeliling dilaksanakan,

mendapatkan parameter kaedah potong, kunci dalam parameter, dan kemudian pergi ke redis untuk membuat pertanyaan mengikut kunci,

Jika Jika ia tidak ditemui, tukarkan hasil pulangan kaedah kepada Senarai objek dan simpan dalam redis

Jika ia boleh ditemui, hasilnya akan dikembalikan.

Kemudian cari kaedah pertanyaan dan lapisan pemeta jadual ini, contohnya, jika anda ingin menyimpan hasil pemulangan pertanyaan dalam 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();
}

, kemudian tambah kaedah pemeta untuk menambah, mengedit dan memadamkan jadual ini

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

Perhatikan bahawa kunci anotasi di sini mesti konsisten dengan kunci anotasi pertanyaan di atas.

Kemudian mulakan projek, jika ia menggesa:

Pertimbangkan untuk menandakan salah satu kacang sebagai @Utama, mengemas kini

pengguna untuk mengakses

Kerana apabila sringboot menyuntik kelas pelaksanaan antara muka melalui @Autowired, ia mendapati terdapat beberapa kelas pelaksanaan, iaitu, terdapat beberapa kelas yang mewarisi antara muka ini, dan bekas spring tidak tahu yang mana satu untuk digunakan .

Cari kelas konfigurasi redis dan tambah anotasi @Primary pada RedisTemplate

Sahkan penggunaan anotasi

nyahpepijat mulakan projek, dalam CacheEnableAspect Query titik putus dalam anotasi, kemudian panggil kaedah pertanyaan,

, anda boleh melihat bahawa titik putus boleh dimasukkan, dan kemudian anda boleh mengubah suai anotasi mengikut logik dan kesan yang anda mahukan.

Atas ialah kandungan terperinci Bagaimana untuk cache data pangkalan data ke Redis melalui anotasi cache tersuai dalam SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!