Membina sistem caching yang stabil dan boleh dipercayai: Berkongsi pengalaman dalam reka bentuk dan pelaksanaan mekanisme caching Java

Membina sistem caching yang boleh dipercayai: Perkongsian reka bentuk dan pengalaman praktikal mekanisme caching Java

Pengenalan:
Dalam kebanyakan aplikasi, caching data ialah kaedah biasa untuk meningkatkan prestasi sistem. Caching mengurangkan akses kepada sumber data asas, meningkatkan masa tindak balas aplikasi dengan ketara. Di Java, kami boleh melaksanakan mekanisme caching dalam pelbagai cara Artikel ini akan memperkenalkan beberapa corak reka bentuk caching biasa dan pengalaman praktikal, dan memberikan contoh kod khusus.

1. Corak reka bentuk cache:

1. Caching berasaskan memori
   Caching berasaskan memori ialah corak reka bentuk cache yang paling biasa. Ia menyimpan data dalam ingatan untuk mendapatkan semula cepat apabila aplikasi memerlukannya, biasanya menggunakan HashMap atau ConcurrentHashMap. Berikut ialah contoh cache berasaskan memori yang ringkas:

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class InMemoryCache<T> {
    private final Map<String, CacheEntry<T>> cache;
    private final long expirationTime;

    private static class CacheEntry<T> {
        private final T value;
        private final long createTime;

        CacheEntry(T value) {
            this.value = value;
            this.createTime = System.currentTimeMillis();
        }

        boolean isExpired(long expirationTime) {
            return System.currentTimeMillis() - createTime > expirationTime;
        }
    }

    public InMemoryCache(long expirationTime) {
        this.cache = new HashMap<>();
        this.expirationTime = expirationTime;
    }

    public void put(String key, T value) {
        cache.put(key, new CacheEntry<>(value));
    }

    public T get(String key) {
        CacheEntry<T> entry = cache.get(key);
        if (entry != null && !entry.isExpired(expirationTime)) {
            return entry.value;
        } else {
            cache.remove(key);
            return null;
        }
    }

    public static void main(String[] args) {
        InMemoryCache<String> cache = new InMemoryCache<>(TimeUnit.MINUTES.toMillis(30));
        cache.put("key1", "value1");
        String value = cache.get("key1");
        System.out.println(value);
    }
}

2. Cache berasaskan cakera
   Cache berasaskan cakera menyimpan data dalam fail cakera supaya ia boleh dibaca apabila aplikasi memerlukannya. Corak reka bentuk cache ini berfungsi dengan baik untuk set data yang lebih besar, tetapi lebih perlahan untuk dibaca daripada cache berasaskan memori. Berikut ialah contoh cache berasaskan cakera yang ringkas:

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class DiskCache<T> {
    private final Map<String, File> cache;

    public DiskCache() {
        this.cache = new HashMap<>();
    }

    public void put(String key, T value) {
        try {
            File file = new File("cache/" + key + ".bin");
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
            outputStream.writeObject(value);
            outputStream.close();
            cache.put(key, file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public T get(String key) {
        File file = cache.get(key);
        if (file != null && file.exists()) {
            try {
                ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
                T value = (T) inputStream.readObject();
                inputStream.close();
                return value;
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        cache.remove(key);
        return null;
    }

    public static void main(String[] args) {
        DiskCache<String> cache = new DiskCache<>();
        cache.put("key1", "value1");
        String value = cache.get("key1");
        System.out.println(value);
    }
}

2. Pengalaman praktikal caching:

1. Pemilihan strategi caching
   Apabila memilih strategi caching, anda perlu mempertimbangkan saiz cache, kitaran hayat data, dan keperluan aplikasi Corak capaian data. Untuk data yang kerap diakses dan berkapasiti kecil, anda boleh memilih caching berasaskan memori untuk set data berkapasiti lebih besar, anda boleh menggunakan caching berasaskan cakera.
2. Pembersihan cache dan pemprosesan tamat tempoh
   Untuk mengelakkan data cache daripada luput, pembersihan cache dan pemprosesan tamat tempoh perlu dilakukan dengan kerap. Anda boleh menetapkan masa tamat tempoh berdasarkan saiz dan kapasiti cache, atau menggunakan strategi penyingkiran (seperti yang paling kurang digunakan baru-baru ini) untuk pembersihan data.
3. Pemprosesan cache teragih
   Dalam sistem teragih, ketekalan data cache perlu dipertimbangkan apabila berbilang nod berkongsi data cache. Anda boleh menggunakan sistem cache teragih (seperti Redis) untuk melaksanakan pemprosesan cache teragih dan memastikan ketekalan data.

3. Kesimpulan:
Dengan mereka bentuk dan menggunakan mekanisme caching dengan betul, prestasi dan kelajuan tindak balas aplikasi boleh dipertingkatkan dengan ketara. Apabila membina sistem cache yang boleh dipercayai, pilih strategi cache yang sesuai, lakukan pembersihan cache dan tamat tempoh dengan kerap, dan pertimbangkan ketekalan cache yang diedarkan. Artikel ini menyediakan contoh kod khusus bagi corak reka bentuk caching berasaskan memori dan cakera, dengan harapan dapat membantu pembaca membina sistem caching yang boleh dipercayai.

Rujukan:

Javatpoint (2019 Java Cache) https://www.javatpoint.com/java-cache
• (2021). com/data-spring-redis-cache

Atas ialah kandungan terperinci Membina sistem caching yang stabil dan boleh dipercayai: Berkongsi pengalaman dalam reka bentuk dan pelaksanaan mekanisme caching Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!