Melaksanakan caching dalam aplikasi Java menggunakan Redis

Pasang dan jalankan Redis, dan mulakan perkhidmatan Redis menggunakan arahan Docker; 2. Tambah dependensi Redis untuk boot Jedis atau Spring dalam projek Maven; 3. Gunakan klien Jedis untuk menyambungkan Redis dan melaksanakan SetEx untuk menetapkan cache dengan masa tamat, perhatikan untuk menutup sambungan atau menggunakan kolam sambungan; 4. Konfigurasi parameter redis pada boot musim bunga melalui application.yml, aktifkan anotasi @enableCaching dan gunakan @cacheable, @cacheput, dan @cacheEvict untuk melaksanakan caching peringkat kaedah; 5. Sesuaikan semula Redistemplate untuk menggunakan Jackson2JSonRedisserializer untuk bersiri objek kompleks ke dalam format JSON untuk meningkatkan kebolehbacaan dan prestasi; 6. Ikuti Amalan Terbaik: Tetapkan TTL Untuk mengelakkan kebocoran memori, gunakan nama -nama utama yang bermakna, mengendalikan cache terlepas dengan anggun, gunakan kolam sambungan dalam persekitaran pengeluaran, dan memantau keadaan redis. Melalui langkah-langkah ini, aplikasi Java dapat mengintegrasikan cache Redis dengan cekap, dengan ketara mengurangkan beban pangkalan data dan meningkatkan kelajuan tindak balas, akhirnya mencapai lapisan akses data berprestasi tinggi.

Caching dalam aplikasi Java dapat meningkatkan prestasi dengan ketara dengan mengurangkan beban pangkalan data dan mempercepatkan masa tindak balas. Redis adalah salah satu kedai data dalam memori yang paling popular yang digunakan untuk caching kerana kelajuan, fleksibiliti, dan set ciri yang kaya. Berikut adalah cara melaksanakan caching berasaskan Redis dalam aplikasi Java.

1. Sediakan redis dan kebergantungan

Pertama, pastikan Redis dipasang dan berjalan. Anda boleh memuat turunnya dari redis.io atau menggunakan Docker:

 Docker Run -P 6379: 6379 -Nama Redis -server -d Redis

Kemudian, tambahkan kebergantungan yang diperlukan untuk pom.xml anda (untuk maven):

 <geterlihat>
    <groupId> redis.clients </groupId>
    <stistfactid> Jedis </artifactid>
    <version> 4.5.0 </versi> <!-Gunakan stabil terkini->
</ketergantungan>

Sebagai alternatif, jika anda menggunakan Spring Boot, termasuk:

 <geterlihat>
    <groupId> org.springframework.boot </groupId>
    <stifactid> Spring-Boot-Starter-Data-Redis </artifactid>
</ketergantungan>

2. Sambungkan ke Redis menggunakan Jedis (mandiri)

Jedis adalah pelanggan Redis yang ringan untuk Java. Berikut adalah contoh mudah untuk menyambung dan menggunakan Redis:

 import redis.clients.jedis.jedis;

Rediscache kelas awam {
    Jedis Jedis swasta;

    public redische () {
        this.jedis = New Jedis ("localhost", 6379);
    }

    set void awam (kunci rentetan, nilai rentetan) {
        Jedis.setex (Key, 3600, nilai); // cache selama 1 jam
    }

    rentetan awam get (kunci rentetan) {
        kembali jedis.get (kunci);
    }

    public void close () {
        jika (jedis! = null) {
            jedis.close ();
        }
    }
}

• setex(key, seconds, value) menetapkan kunci dengan masa tamat (TTL), yang penting untuk mengelakkan data basi.
• Sentiasa tutup sambungan atau gunakan kolam sambungan dalam pengeluaran.

3. Gunakan Redis dengan Spring Boot (disyorkan)

Spring Boot memudahkan integrasi Redis dengan caching berasaskan auto dan anotasi.

Konfigurasikan application.yml :

 Spring:
  Redis:
    Tuan rumah: Localhost
    Pelabuhan: 6379
  Cache:
    Jenis: Redis
    Redis:
      Masa-ke-Live: 3600000 # 1 jam dalam juta saat

Dayakan caching:

Tambahkan @EnableCaching ke kelas aplikasi utama anda:

 @Springbootapplication
@EnableCaching
Permohonan Kelas Awam {
    public static void main (string [] args) {
        SpringApplication.run (application.class, args);
    }
}

Gunakan anotasi caching:

Sapukan @Cacheable , @CachePut , dan @CacheEvict pada kaedah perkhidmatan:

 @Service
UserService Kelas Awam {

    @Cacheable (nilai = "pengguna", key = "#id")
    pengguna awam getUserbyId (id panjang) {
        System.out.println ("mengambil pengguna dari db:" id);
        // simulasi panggilan db
        kembali userrepository.findbyId (id) .orelse (null);
    }

    @Cacheput (nilai = "pengguna", key = "#user.id")
    UpdateUser Pengguna Awam (Pengguna Pengguna) {
        // kemas kini pengguna dan kemas kini cache
        kembali userrepository.save (pengguna);
    }

    @CacheEvict (nilai = "pengguna", key = "#id")
    public void deleteUser (id panjang) {
        userrepository.deletebyId (id);
    }
}

Ini secara automatik cache hasil getUserById() jadi panggilan berikutnya dengan ID yang sama melangkau pangkalan data.

4. Serialize objek kompleks

Secara lalai, Spring menggunakan Serialization JDK, yang tidak cekap. Sesuaikan templat Redis untuk menggunakan JSON:

 @Configuration
@EnableCaching
kelas awam Redisconfig {

    @Bean
    redistemplate awam <string, object> redistemplate (kilang redisconnectionFactory) {
        Redistemplate <string, object> template = redistemplate baru <> ();
        template.setConnectionFactory (kilang);

        // Gunakan jackson2jsonredisserializer untuk membaca yang lebih baik
        Jackson2jsonredisserializer <user> serializer = new Jackson2jsonRedisserializer <> (user.class);
        template.setValueserializer (Serializer);
        template.setKeySerializer (StringRedisserializer baru ());
        template.sethashKeyserializer (baru StringRedisserializer ());
        template.sethashValueSerializer (Serializer);
        template.afterPropertiesset ();

        Templat kembali;
    }
}

Sekarang, objek kompleks seperti User disimpan dalam format JSON yang boleh dibaca di Redis.

5. Amalan Terbaik

• Tetapkan TTL (Masa untuk hidup): Sentiasa tetapkan tamat pada data cache untuk mengelakkan kebocoran memori.
• Gunakan kekunci yang bermakna: Kekunci Struktur Seperti user::123 atau product:category:latest .
• Mengendalikan cache terlepas dengan anggun: Jika Redis turun, jatuh ke pangkalan data (dan log isu).
• Gunakan penyatuan sambungan: Dalam pengeluaran, konfigurasikan jedis atau salad dengan penyatuan.
• Pantau Redis: Gunakan redis-cli monitor seperti redissight untuk memeriksa penggunaan cache.

Kesimpulan

Menggunakan Redis untuk caching di Java -terutamanya dengan Spring Boot -boleh secara dramatik meningkatkan prestasi dengan perubahan kod minimum. Sama ada anda menggunakan Jedis Raw untuk kawalan baik atau caching deklaratif Spring untuk kesederhanaan, Redis menyediakan lapisan yang cepat dan boleh dipercayai antara aplikasi anda dan sumber data yang perlahan.

Pada asasnya: Sambungkan Redis, Hasil Kaedah Cache, bersiri dengan bijak, dan tamat data dengan bijak. Itulah teras.

Atas ialah kandungan terperinci Melaksanakan caching dalam aplikasi Java menggunakan Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!