Cara SpringBoot menggunakan @Cacheable untuk caching dan perolehan nilai

Gunakan @Cacheable untuk caching dan nilai

1. Peranan @Cacheable

Langkah untuk menggunakan caching ialah menggunakan anotasi @Cacheable untuk melaksanakan caching. Jadi kita boleh bercakap terlebih dahulu tentang langkah-langkah untuk menggunakan cache:

Gunakan anotasi @EnableCaching pada kelas permulaan utama SpringBoot untuk mendayakan cache berasaskan anotasi.

Hanya tandai anotasi cache

Langkah 1: Dayakan cache berasaskan anotasi dan gunakan @EnableCaching anotasi pada kelas permulaan utama springboot

//开启基于注解的缓存
@EnableCaching   
@EnableRyFeignClients
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class ZfjgAuthApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZfjgAuthApplication.class, args);
    }
}

Langkah 2: Tandai anotasi cache

@Repository
public interface DeviceMapper {
    @Cacheable(cacheNames = "DeviceDO.deviceId")
    DeviceDO get(String deviceId);
    @CacheEvict(cacheNames = "DeviceDO.deviceId", key = "#record.deviceId")
    int insert(DeviceDO record);
}

Nota: Anotasi @Cacheable boleh digunakan di sini untuk cache hasil yang sedang dijalankan Pada masa hadapan, data yang sama boleh ditanya terus daripada cache tanpa kaedah memanggil.

2. Penerangan tentang atribut biasa

Berikut ialah pengenalan kepada beberapa atribut yang biasa digunakan bagi anotasi @Cacheable:

• cacheNames/ value: Digunakan untuk menentukan nama komponen cache

• key: kunci yang digunakan semasa menyimpan data, anda boleh menggunakannya untuk menentukan. Lalai ialah menggunakan nilai parameter kaedah. (Anda boleh menggunakan ungkapan spEL untuk menulis kunci ini)

• keyGenerator: Penjana kunci. Gunakan sama ada kunci atau keyGenerator

• cacheManager: boleh digunakan untuk menentukan pengurus cache. Daripada pengurus cache mana untuk mendapatkan cache.

• condition: Boleh digunakan untuk menentukan caching hanya apabila syarat dipenuhi

• unless: Meniadakan caching. Apabila syarat yang ditentukan oleh melainkan benar, nilai pulangan kaedah tidak akan dicache. Sudah tentu, anda juga boleh mendapatkan keputusan untuk penghakiman. (Dapatkan hasil kaedah melalui #hasil)

• sync: Sama ada hendak menggunakan mod tak segerak.

Arahan untuk menggunakan Cacheable dalam SpringBoot

Penerangan fungsi

Apabila anotasi @Cacheable digunakan pada kaedah, ini bermakna hasil dikembalikan oleh kaedah boleh dicache. Maksudnya, hasil pulangan kaedah ini akan diletakkan dalam cache, supaya apabila kaedah dipanggil dengan parameter yang sama pada masa hadapan, nilai dalam cache akan dikembalikan tanpa benar-benar melaksanakan kaedah tersebut.

Perhatikan bahawa satu perkara ditekankan di sini: parameter adalah sama. Ini sepatutnya mudah difahami, kerana cache tidak mengambil berat tentang logik pelaksanaan kaedah Apa yang boleh ditentukan adalah: untuk kaedah yang sama, jika parameter adalah sama, hasil pulangan juga sama. Tetapi jika parameter berbeza, cache hanya boleh menganggap bahawa keputusan adalah berbeza, jadi untuk kaedah yang sama, berapa banyak kombinasi parameter digunakan untuk memanggil kaedah semasa menjalankan program anda, secara teorinya berapa banyak kunci cache akan dijana ( sudah tentu, parameter gabungan ini merujuk kepada kunci yang dijana). Mari kita lihat beberapa parameter @Cacheable:

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {
    @AliasFor("cacheNames")
    String[] value() default {};
    @AliasFor("value")
    String[] cacheNames() default {};
    String key() default "";
    String keyGenerator() default "";
    String cacheManager() default "";
    String cacheResolver() default "";
    String condition() default "";
    String unless() default "";
    boolean sync() default false;
}

1 cacheNames & value

Anda boleh memilih untuk menggunakan salah satu nilai atau cacheNames untuk menentukan nama cache, yang boleh dicapai melalui. @Boleh cache . Ini ialah contoh penggunaan paling mudah bagi @Cacheable:

@Override
@Cacheable("menu")
public Menu findById(String id) {
    Menu menu = this.getById(id);
    if (menu != null){
        System.out.println("menu.name = " + menu.getName());
    }
    return menu;
}

Dalam contoh ini, cache menu dikaitkan dengan kaedah yang dipanggil findById. Jika sudah ada hasil dalam cache menu, ia tidak akan dilaksanakan semasa memanggil kaedah ini, tetapi hasil cache akan digunakan secara langsung.

2. Kaitkan berbilang nama cache

Malah, menurut dokumentasi rasmi, @Cacheable menyokong kaedah yang sama untuk mengaitkan berbilang cache. Dalam kes ini, sebelum melaksanakan kaedah, setiap cache yang berkaitan ini akan diperiksa dan selagi sekurang-kurangnya satu daripada cache mencecah , nilai dalam cache ini akan dikembalikan.

Contoh:

@Override
    @Cacheable({"menu", "menuById"})
    public Menu findById(String id) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }
---------
@GetMapping("/findById/{id}")
public Menu findById(@PathVariable("id")String id){
    Menu menu0 = menuService.findById("fe278df654adf23cf6687f64d1549c0a");
    Menu menu2 = menuService.findById("fb6106721f289ebf0969565fa8361c75");
    return menu0;
}

Demi gerak hati, tulis parameter id terus ke dalam kod. Sekarang, mari kita uji dan lihat hasilnya:

3 kunci & keyGenerator

Nama cache sepadan dengan kaedah beranotasi, tetapi kaedah Parameter yang berbeza. mungkin diluluskan, dan hasilnya akan berbeza. Bagaimana kita harus membezakannya? Ini memerlukan penggunaan kunci. Dalam rangka kerja Spring, nilai utama boleh dijana dalam dua cara: dinyatakan secara eksplisit dan secara automatik menggunakan penjana kunci.

3.1 KeyGenerator menjana secara automatik

Apabila kami mengisytiharkan @Cacheable tanpa menyatakan parameter kunci, semua kunci di bawah nama cache akan dijana secara automatik menggunakan KeyGenerator berdasarkan parameter. Spring mempunyai SimpleKeyGenerator lalai, yang akan disuntik secara lalai dalam konfigurasi automatik but spring. Peraturan penjanaan adalah seperti berikut:

• Jika kaedah cache tidak mempunyai parameter, kembalikan SimpleKey.EMPTY;

• Jika kaedah cache mempunyai satu parameter, kembalikan Contoh parameter;

• Jika kaedah cache mempunyai berbilang parameter, kembalikan SimpleKey yang mengandungi semua parameter; Memerlukan hujah untuk mempunyai pelaksanaan kaedah hashCode() dan equals() yang sah. Sebagai alternatif, anda boleh menyesuaikan keyGenerator dan menentukannya melaluinya. Saya tidak akan memberikan pengenalan terperinci kepada KeyGenerator di sini Jika anda berminat, anda boleh melihat kod sumber Sebenarnya, ia menggunakan kod cincang untuk melakukan operasi penambahan dan pendaraban. Sama seperti pengiraan cincang untuk String dan ArrayList.

3.2 Nyatakan kunci dengan jelas

相较于使用 KeyGenerator 生成，spring 官方更推荐显式指定 key 的方式，即指定 @Cacheable 的 key 参数。

即便是显式指定，但是 key 的值还是需要根据参数的不同来生成，那么如何实现动态拼接呢？SpEL（Spring Expression Language，Spring 表达式语言） 能做到这一点。下面是一些使用 SpEL 生成 key 的例子。

@Override
    @Cacheable(value = {"menuById"}, key = "#id")
    public Menu findById(String id) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }
    @Override
    @Cacheable(value = {"menuById"}, key = "'id-' + #menu.id")
    public Menu findById(Menu menu) {
        return menu;
    }
    @Override
    @Cacheable(value = {"menuById"}, key = "'hash' + #menu.hashCode()")
    public Menu findByHash(Menu menu) {
        return menu;
    }

官方说 key 和 keyGenerator 参数是互斥的，同时指定两个会导致异常。

4. cacheManager & cacheResolver

缓存管理器CacheManager用于管理（寻找）某种缓存。通常来讲，缓存管理器是与缓存组件类型相关联的。我们知道，spring 缓存抽象的目的是为使用不同缓存组件类型提供统一的访问接口，以向开发者屏蔽各种缓存组件的差异性。那么 CacheManager 就是承担了这种屏蔽的功能。spring 为其支持的每一种缓存的组件类型提供了一个默认的 manager，如：RedisCacheManager 管理 redis 相关的缓存的检索、EhCacheManager 管理 ehCache 相关的缓等。

CacheResolver，缓存解析器是用来管理缓存管理器的，CacheResolver 保持一个 cacheManager 的引用，并通过它来检索缓存。CacheResolver 与 CacheManager 的关系有点类似于 KeyGenerator 跟 key。spring 默认提供了一个 SimpleCacheResolver，开发者可以自定义并通过 @Bean 来注入自定义的解析器，以实现更灵活的检索。

大多数情况下，我们的系统只会配置一种缓存，所以我们并不需要显式指定 cacheManager 或者 cacheResolver。Spring允许我们在系统中配置多个缓存组件，这时我们需要进行明确的指定。指定的方式是使用 @Cacheable 的 cacheManager 或者 cacheResolver 参数。

按照官方文档，cacheManager 和 cacheResolver 是互斥参数，同时指定两个可能会导致异常。

5. sync

是否同步，true/false。在一个多线程的环境中，某些操作可能被相同的参数并发地调用，这样同一个 value 值可能被多次计算（或多次访问 db），这样就达不到缓存的目的。针对这些可能高并发的操作，我们可以使用 sync 参数来告诉底层的缓存提供者将缓存的入口锁住，这样就只能有一个线程计算操作的结果值，而其它线程需要等待，这样就避免了 n-1 次数据库访问。

sync = true 可以有效的避免缓存击穿的问题。

6. condition

调用前判断，缓存的条件。有时候，我们可能并不想对一个方法的所有调用情况进行缓存，我们可能想要根据调用方法时候的某些参数值，来确定是否需要将结果进行缓存或者从缓存中取结果。例如，当我查询用户时按年龄分组，我只需缓存那些年龄大于 35 的结果。那么 condition 能实现这种效果。

SpEL 支持的表达式可以作为 condition 的值，结果为 true 或 false。如果表达式结果为 true，则调用方法时会执行正常的缓存逻辑（查缓存-有就返回-没有就执行方法-方法返回不空就添加缓存）；否则，调用方法时就好像该方法没有声明缓存一样（即无论传入了什么参数或者缓存中有些什么值，都会执行方法，并且结果不放入缓存）。下面举个例子：

我们看一下数据库，以这两条数据为例：

　　

我们首先定义一个带条件的缓存方法：

@Override
    @Cacheable(value = {"menuById"}, key = "#id", condition = "#conditionValue > 1")
    public Menu findById(String id, Integer conditionValue) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }

然后分两种情况调用（为了直观可见，直接将 id 写在代码中）：

@GetMapping("/findById/{id}")
    public Menu findById(@PathVariable("id")String id){
        Menu menu0 = menuService.findById("fe278df654adf23cf6687f64d1549c0a", 0);
        Menu menu2 = menuService.findById("fb6106721f289ebf0969565fa8361c75", 2);
        return menu0;
    }

虽然两次请求都调用了方法，但只有第二次请求缓存了"微服务测试2"。只有在满足条件 condition 的情况下才会进行调用，这样才能将结果缓存。接下来我们再请求一遍，看下结果和打印：

可以看到，“微服务测试2”由于已经有了缓存，所以没有再执行方法体。而“微服务测试0”又一次执行了。

7. unless

执行后判断，不缓存的条件。SpEL 可以支持表达式结果为 true 或 false，用于 unless。当结果为 true 时，不缓存。举个例子：

我们先清除 redis 中的数据。然后看看 mysql 中的数据：

　　

然后编写一个缓存方法（在该方法中，result代表方法的返回值。关于）：

@Override
    @Cacheable(value = {"menuById"}, key = "#id", unless = "#result.type == 'folder'")
    public Menu findById(String id) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }

然后调用该方法：

@GetMapping("/findById/{id}")
    public Menu findById(@PathVariable("id")String id){
        Menu menu0 = menuService.findById("fe278df654adf23cf6687f64d1549c0a");
        Menu menu2 = menuService.findById("fb6106721f289ebf0969565fa8361c75");
        return menu0;
    }

可以看到，两次都执行了方法体（其实，unless 条件就是在方法执行完毕后调用，所以它不会影响方法的执行），但是结果只有 menu.type = ‘page’ 的缓存了，说明 unless 参数生效了。

8. condition VS unless ？

既然 condition 和 unless 都能决定是否进行缓存，那么同时指定这两个参数并且结果相冲突的时候，会怎么样呢？我们来试一试。

首先清除 redis 数据，然后在缓存方法上加上 condition=“true”，如：

@Override
    @Cacheable(value = {"menuById"}, key = "#id", condition = "true", unless = "#result.type == 'folder'")
    public Menu findById(String id) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }

其它代码不变，我们来看一下缓存结果和打印：

可以看到，虽然两次调用都执行了，但是，type=‘folder’ 的还是被排除了。在这种情况下，unless 的优先级高于 condition。接着，我们将condition设为“false”，再进行尝试，结果是：

可以看到，两次调用的结果都没有缓存。在这种情况下，优先使用condition而不是unless。总结起来就是：

• condition 不指定相当于 true，unless 不指定相当于 false

• condition = false，一定不会缓存；

• condition = true，且 unless = true，不缓存；

• condition = true，且 unless = false，缓存；

Atas ialah kandungan terperinci Cara SpringBoot menggunakan @Cacheable untuk caching dan perolehan nilai. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!