Cara menggunakan Redis dalam SpringBoot

1. Ketergantungan

Ketergantungan Maven adalah seperti berikut. Perlu diingat bahawa spring-boot-starter-data-redis menggunakan salad sebagai pemacu klien redis secara lalai, tetapi salad sebenarnya kurang praktikal. . We Jedis biasanya digunakan sebagai pemandu pelanggan, jadi salad dikecualikan di sini dan jedis diperkenalkan:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

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

2. Ketergantungan

Hubungan bergantung dalam redis data musim bunga:

Apa yang ingin dinyatakan oleh hubungan pergantungan ini ialah Spring mengendalikan Redis melalui RedisConnection dan RedisConnection merangkum baris Jedis asli. Untuk mendapatkan objek antara muka RedisConnection dijana melalui RedisConnectionFactory.

3. Konfigurasi

Fail konfigurasi:

# Redis 连接配置
# 单机 Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
# 连接池配置
spring.redis.jedis.pool.max-idle=30
spring.redis.jedis.pool.max-total=50
spring.redis.jedis.pool.max-wait=2000ms

Konfigurasi kod:

@Configuration
public class RedisConfig {
    private RedisConnectionFactory connectionFactory = null;
 
    @Bean
    public RedisConnectionFactory initRedisConnectionFactory(){
        if(connectionFactory!=null){
            return connectionFactory;
        }
        JedisPoolConfig poolConfig =new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(30);
        //最大连接数
        poolConfig.setMaxTotal(50);
        //最大等待毫秒数
        poolConfig.setMaxWaitMillis(2000);
        //创建Jedis连接工厂
        JedisConnectionFactory connectionFactory=new JedisConnectionFactory(poolConfig);
        //获取单机的redis配置，如果是集群的话用集群配置类
        RedisStandaloneConfiguration rscfg=connectionFactory.getStandaloneConfiguration();
        connectionFactory.setHostName("127.0.0.1");
        connectionFactory.setPort(6379);
        return connectionFactory;
    }
}

4.RedisTemplate

Berikut adalah arahan Satu-satunya Perkara itu ialah jika kita menggunakan RedisConnection terus untuk mengendalikan redis, kita perlu pergi ke RedisConnectionFactory secara manual untuk mendapatkan RedisConnection, dan kita perlu menutup RedisConnection secara manual setiap kali. Oleh itu, Spring Data Redis menyediakan RedisTemplate untuk memudahkan operasi Ia dirangkumkan daripada jedis dan menyekat langkah pemerolehan dan pelepasan sumber.

Perkara utama yang perlu diberi perhatian apabila menggunakan RedisTemplate ialah RedisTemplate mempunyai pelbagai serializers yang berbeza menggunakan serialisasi dalam proses menulis nilai utama dan kaedahnya akan berbeza , dan hasil bersiri juga akan berbeza. Sebagai contoh, apabila memproses aksara, anda perlu menggunakan penyeri khusus rentetan, dan semasa memproses objek, anda perlu menggunakan penyeri bersiri khusus objek.

Penyeseri semasa adalah seperti berikut:

StringRedisSerializer:

StringRedisSerializer ialah Kunci lalai yang digunakan oleh RedisTemplate dan pensiri Value, yang mensirikan rentetan ke dalam tatasusunan bait, menggunakan pengekodan UTF-8. Memandangkan Kunci dan Nilai dalam Redis adalah kedua-dua rentetan, penyeseri StringRedisSerializer lalai boleh memenuhi keperluan kebanyakan situasi.

Jackson2JsonRedisSerializer:

Jackson2JsonRedisSerializer ialah penyeri bersiri berdasarkan Kunci dan Nilai Redis Jackson. Ia boleh menyerikan objek ke dalam rentetan format JSON dan menyimpannya ke dalam Redis. Untuk menggunakan penyeri Jackson2JsonRedisSerializer, anda perlu menambah kebergantungan Jackson Anda boleh menukar objek kepada rentetan berformat JSON, atau anda boleh menukar rentetan berformat JSON kepada objek.

JdkSerializationRedisSerializer:

JdkSerializationRedisSerializer ialah penyeri bersiri berdasarkan kaedah bersiri Java sendiri Ia boleh menyerikan objek ke dalam tatasusunan bait untuk penyimpanan. Walaupun JdkSerializationRedisSerializer mudah dan mudah digunakan, kecekapannya agak rendah, dan tatasusunan bait bersiri agak besar, menjadikannya tidak sesuai untuk menyimpan sejumlah besar data.

GenericJackson2JsonRedisSerializer:

GenericJackson2JsonRedisSerializer ialah Jackson2JsonRedisSerializer yang menyokong generik, yang boleh mensiri sebarang jenis objek dan mensirikan objek ke dalam rentetan format JSON. Ia memerlukan penentuan jenis sasaran kedua-dua semasa bersiri dan penyahserilan.

OxmSerializer:

OxmSerializer ialah penyeri bersiri berdasarkan rangka kerja pemetaan O/X Spring, yang menyokong penyirian objek ke dalam rentetan format XML. Walaupun OxmSerializer mempunyai fleksibiliti yang tinggi, prestasi bersiri dan penyahseriannya adalah rendah dan ia tidak sesuai untuk menyimpan sejumlah besar data.

Ringkasnya, apabila memilih serializer, anda perlu memilih berdasarkan situasi sebenar, dan memilih serializer yang sesuai berdasarkan jenis data dan keperluan prestasi.

Apabila menggunakannya, anda hanya boleh menetapkannya. Apabila menetapkan, anda diberi banyak pilihan untuk butiran kesan, sama ada ia berkesan untuk semua struktur data jenis redis, atau untuk jenis tertentu jenis struktur data redis:

Sebagai contoh, saya mahu menggunakan penyeri bertali, yang akan berkuat kuasa secara global:

@Bean
public RedisTemplate<Object,Object> initRedisTemplate(){
  RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
  redisTemplate.setDefaultSerializer(new StringRedisSerializer());
  return redisTemplate;
}

5 🎜>

Berikut ialah operasi redis menggunakan Kod RedisTemplate contoh jenis data asas:

Perlu diambil perhatian bahawa apabila @Bean mentakrifkan RedisTemplate, jenis generik mesti diselaraskan dengan jenis generik apabila digunakan .

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class RedisService {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
    public void setString(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }
 
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
 
    public void setHash(String key, String hashKey, Object value) {
        HashOperations<String, String, Object> hashOps = redisTemplate.opsForHash();
        hashOps.put(key, hashKey, value);
    }
 
    public Object getHash(String key, String hashKey) {
        HashOperations<String, String, Object> hashOps = redisTemplate.opsForHash();
        return hashOps.get(key, hashKey);
    }
 
    public void setList(String key, Object value) {
        ListOperations<String, Object> listOps = redisTemplate.opsForList();
        listOps.rightPush(key, value);
    }
 
    public Object getList(String key, long index) {
        ListOperations<String, Object> listOps = redisTemplate.opsForList();
        return listOps.index(key, index);
    }
 
    public void setSet(String key, Object value) {
        SetOperations<String, Object> setOps = redisTemplate.opsForSet();
        setOps.add(key, value);
    }
 
    public Object getSet(String key) {
        SetOperations<String, Object> setOps = redisTemplate.opsForSet();
        return setOps.members(key);
    }
 
    public void setZSet(String key, Object value, double score) {
        ZSetOperations<String, Object> zsetOps = redisTemplate.opsForZSet();
        zsetOps.add(key, value, score);
    }
 
    public Object getZSet(String key, long start, long end) {
        ZSetOperations<String, Object> zsetOps = redisTemplate.opsForZSet();
        return zsetOps.range(key, start, end);
    }
 
}

6 Transaksi

Berikut ialah contoh kod menggunakan transaksi:

@Autowired
private RedisTemplate<String, String> redisTemplate;
 
public void transactionalOperation() {
    // 开启 Redis 事务
    redisTemplate.multi();
 
    try {
        // 执行多个 Redis 命令
        redisTemplate.opsForValue().set("key1", "value1");
        redisTemplate.opsForValue().set("key2", "value2");
 
        // 提交事务
        redisTemplate.exec();
    } catch (Exception e) {
        // 回滚事务
        redisTemplate.discard();
    }
}

Atas ialah kandungan terperinci Cara menggunakan Redis dalam SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!