Bagaimana untuk melaksanakan cache berbilang peringkat Redis berdasarkan Java

1. Cache berbilang peringkat

1. Penyelesaian caching tradisional

Selepas permintaan mencapai tomcat, ia mula-mula pergi ke redis untuk mendapatkan cache ke mysql untuk mendapatkannya

2 Bilangan permintaan serentak penyelesaian caching berbilang peringkat

• tomcat ialah. jauh lebih kecil daripada redis, jadi tomcat akan menjadi hambatan

• Gunakan setiap pautan pemprosesan permintaan untuk menambah cache masing-masing untuk mengurangkan tekanan pada tomcat dan meningkatkan prestasi perkhidmatan

2. JVM Local cache

Cache disimpan dalam memori dan kelajuan membaca data lebih pantas, yang boleh mengurangkan akses kepada pangkalan data dan mengurangkan tekanan pada pangkalan data

Cache teragih, seperti redis
- Kelebihan: Kapasiti storan yang besar, kebolehpercayaan yang baik, boleh dikongsi dalam kelompok
- Kelemahan: Terdapat ialah overhed rangkaian untuk mengakses cache
- Senario: Jumlah data cache yang besar, kebolehpercayaan yang tinggi, data yang perlu dikongsi dalam kelompok

Proses cache setempat, seperti HashMap , GuavaCache
- Kelebihan: baca memori tempatan, tiada overhed rangkaian, lebih pantas
- Kelemahan: kapasiti storan terhad, kebolehpercayaan Rendah (seperti hilang selepas dimulakan semula), tidak boleh dikongsi dalam kelompok
- Senario: tinggi keperluan prestasi, sejumlah kecil data cache

1 Kes praktikal

• Kafein ialah perpustakaan cache tempatan berprestasi tinggi yang dibangunkan berdasarkan java8 yang menyediakan hampir kadar pukulan terbaik

• Ini digunakan untuk cache dalaman musim bunga

<dependency>
     <groupId>com.github.ben-manes.caffeine</groupId>
     <artifactId>caffeine</artifactId>
     <version>3.0.5</version>
 </dependency>

package com.erick.cache;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import java.time.Duration;

public final class CacheUtil {
    private static int expireSeconds = 2;
    public static Cache<String, String> cacheWithExpireSeconds;

    private static int maxPairs = 1;
    public static Cache<String, String> cacheWithMaxPairs;

    static {
        /*过期策略，写完60s后过期*/
        cacheWithExpireSeconds = Caffeine.newBuilder()
                .expireAfterWrite(Duration.ofSeconds(expireSeconds))
                .build();

        /*过期策略，达到最大值后删除
         * 1. 并不会立即删除，等一会儿才会删除
         * 2. 会将之前存储的数据删除掉*/
        cacheWithMaxPairs = Caffeine.newBuilder()
                .maximumSize(maxPairs)
                .build();
    }

    /*从缓存中获取数据
     * 1. 如果缓存中有，则直接从缓存中返回
     * 2. 如果缓存中没有，则去数据查询并返回结果*/
    public static String getKeyWithExpire(String key) {
        return cacheWithExpireSeconds.get(key, value -> {
            return getResultFromDB();
        });
    }

    public static String getKeyWithMaxPair(String key) {
        return cacheWithMaxPairs.get(key, value -> {
            return getResultFromDB();
        });
    }

    private static String getResultFromDB() {
        System.out.println("数据库查询");
        return "db result";
    }
}

package com.erick.cache;

import java.util.concurrent.TimeUnit;

public class Test {

    @org.junit.Test
    public void test01() throws InterruptedException {
        CacheUtil.cacheWithExpireSeconds.put("name", "erick");
        System.out.println(CacheUtil.getKeyWithExpire("name"));
        TimeUnit.SECONDS.sleep(3);
        System.out.println(CacheUtil.getKeyWithExpire("name"));
    }

    @org.junit.Test
    public void test02() throws InterruptedException {
        CacheUtil.cacheWithMaxPairs.put("name", "erick");
        CacheUtil.cacheWithMaxPairs.put("age", "12");

        System.out.println(CacheUtil.getKeyWithMaxPair("name"));
        System.out.println(CacheUtil.getKeyWithMaxPair("age"));

        TimeUnit.SECONDS.sleep(2);

        System.out.println(CacheUtil.getKeyWithMaxPair("name")); // 查询不到了
        System.out.println(CacheUtil.getKeyWithMaxPair("age"));
    }
}

3. Konsistensi cache

1

1.1 Tetapkan tempoh sah

• Tetapkan tempoh sah untuk cache, kepada Dipadamkan secara automatik selepas tamat tempoh. Ia boleh dikemas kini apabila membuat pertanyaan lagi

• Kelebihan: mudah dan mudah

• Kelemahan: ketepatan masa yang lemah, cache mungkin tidak konsisten sebelum tamat tempoh

• Senario: Perniagaan dengan kekerapan kemas kini yang rendah dan keperluan ketepatan masa yang rendah

1.2 Tulisan berganda segerak

• Mengubah suai pangkalan data Pada masa yang sama, ubah suai terus cache

• Kelebihan: pencerobohan kod, konsistensi yang kuat antara cache dan pangkalan data

• Kelemahan: kod pencerobohan, gandingan tinggi

• Senario: Data cache dengan ketekalan tinggi dan keperluan ketidaksahihan

1.3 Pemberitahuan tak segerak

• Hantar pemberitahuan acara apabila pangkalan data diubah suai, dan perkhidmatan yang berkaitan mengubah suai data cache selepas mendengarnya

• Kelebihan: Gandingan rendah, perkhidmatan cache berbilang boleh dimaklumkan di masa yang sama

• Kelemahan: Ketepatan masa adalah terhad, mungkin terdapat isu ketidakkonsistenan cache

• Senario: Ketepatan masa adalah purata, terdapat pelbagai perkhidmatan yang memerlukan untuk disegerakkan

2 🎜> ialah projek sumber terbuka di bawah Alibaba, berdasarkan Pembangunan java

• Berdasarkan analisis log tambahan pangkalan data, menyediakan langganan dan penggunaan data tambahan

• Idea sandaran tuan-hamba berdasarkan mysql

• 2.1 replikasi tuan-hamba mysql

2.2 prinsip kerja terusan

canal mensimulasikan protokol Interaksi hamba MySQL, berpura-pura menjadi hamba MySQL dan menghantar protokol dump kepada induk MySQL

• Induk MySQL menerima permintaan dump dan mula menolak log binari kepada hamba (iaitu terusan)

• kanal menghuraikan objek log binari (asalnya aliran bait)

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan cache berbilang peringkat Redis berdasarkan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!