Bagaimana untuk melaksanakan seni bina cache yang diedarkan dalam Java

Cara melaksanakan seni bina cache teragih dalam Java

Dengan perkembangan pesat Internet, sejumlah besar data perlu diproses dan disimpan. Untuk meningkatkan kecekapan membaca dan menulis data, seni bina cache yang diedarkan telah menjadi penyelesaian biasa. Artikel ini akan memperkenalkan cara untuk melaksanakan seni bina cache yang diedarkan dalam Java dan memberikan contoh kod khusus.

1. Fahami prinsip asas caching teragih

Prinsip asas caching teragih ialah menyimpan data dalam berbilang pelayan dan menggunakan algoritma cincang yang konsisten untuk menentukan lokasi penyimpanan data. Apabila data perlu diperoleh, pelayan di mana data berada ditemui melalui algoritma cincang dan data dibaca dari pelayan.

2. Pilih perisian tengah cache

Langkah pertama dalam melaksanakan seni bina cache teragih dalam Java ialah memilih perisian tengah cache yang sesuai. Pada masa ini, perisian tengah cache yang lebih biasa digunakan ialah Redis dan Memcached. Kesemuanya menyediakan antara muka operasi yang kaya untuk operasi capaian data yang mudah.

3 Gunakan perpustakaan klien Java

Selepas memilih perisian tengah cache, kami boleh menggunakan perpustakaan klien Java untuk menyambung dan mengendalikan perisian tengah cache. Mengambil Redis sebagai contoh, kita boleh menggunakan Jedis sebagai perpustakaan pelanggan Java. Pertama, anda perlu mengimport pergantungan Jedis:

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

Kemudian anda boleh menggunakan contoh kod berikut untuk menyambung ke Redis dan membaca dan menulis data:

import redis.clients.jedis.Jedis;
 
public class RedisExample {
    public static void main(String[] args) {
        // 连接Redis服务器
        Jedis jedis = new Jedis("localhost");
 
        // 写入数据
        jedis.set("key", "value");
 
        // 读取数据
        String value = jedis.get("key");
        System.out.println(value);
 
        // 关闭连接
        jedis.close();
    }
}

Keempat, gunakan algoritma pencincangan yang konsisten

Dalam seni bina cache yang diedarkan, kita perlu untuk menggunakan ketekalan Algoritma pencincangan digunakan untuk menentukan tempat data disimpan. Algoritma pencincangan yang konsisten boleh memastikan pemindahan data diminimumkan apabila menambah atau mengurangkan pelayan cache. Berikut ialah contoh pelaksanaan algoritma pencincangan konsisten yang mudah:

import java.util.*;
import java.util.zip.CRC32;
 
public class ConsistentHashingExample {
    // 缓存服务器列表
    private List<String> serverList;
    // 虚拟节点哈希映射表
    private Map<Long, String> virtualNodeMap;
 
    public ConsistentHashingExample() {
        serverList = new ArrayList<>();
        virtualNodeMap = new HashMap<>();
    }
 
    // 添加缓存服务器
    public void addServer(String server) {
        serverList.add(server);
        // 添加虚拟节点到哈希映射表
        for (int i = 0; i < 100; i++) {
            long hash = getHash(server + "-" + i);
            virtualNodeMap.put(hash, server);
        }
        // 对哈希映射表进行排序
        List<Long> hashList = new ArrayList<>(virtualNodeMap.keySet());
        Collections.sort(hashList);
        virtualNodeMap.clear();
        // 只保留虚拟节点哈希映射表中最接近缓存服务器的前3个数据
        for (int i = 0; i < 3; i++) {
            long hash = hashList.get(i);
            String name = virtualNodeMap.get(hash);
            virtualNodeMap.put(hash, name);
        }
    }
 
    // 获取数据所在的缓存服务器
    public String getServer(String data) {
        long hash = getHash(data);
        // 查找大于等于数据哈希值的虚拟节点
        SortedMap<Long, String> tailMap = virtualNodeMap.tailMap(hash);
        if (tailMap.isEmpty()) {
            // 如果没有找到虚拟节点，则返回第一个虚拟节点
            return virtualNodeMap.get(virtualNodeMap.firstKey());
        }
        // 返回最接近的虚拟节点
        return tailMap.get(tailMap.firstKey());
    }
 
    // 计算字符串的哈希值
    private long getHash(String key) {
        CRC32 crc32 = new CRC32();
        crc32.update(key.getBytes());
        return crc32.getValue();
    }
 
    public static void main(String[] args) {
        ConsistentHashingExample example = new ConsistentHashingExample();
        example.addServer("server1");
        example.addServer("server2");
        example.addServer("server3");
 
        String data1 = "data1";
        String data2 = "data2";
        String data3 = "data3";
 
        String server1 = example.getServer(data1);
        String server2 = example.getServer(data2);
        String server3 = example.getServer(data3);
 
        System.out.println(data1 + " 存储在 " + server1);
        System.out.println(data2 + " 存储在 " + server2);
        System.out.println(data3 + " 存储在 " + server3);
    }
}

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan seni bina cache yang diedarkan dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!