java操作Redis（jedis和lettuce）

一.使用Jedis

1.初始化項目

創建Maven項目並導入jedis依賴和我們需要使用的fastjson依賴

依賴可在Maven倉庫中搜索找到：https://search.maven.org/

        <!--jedis依賴-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>

2.編程

1.測試連通

連接遠程服務器上的redis時，需要在配置文件中修改為相關配置使得允許遠程連接，若需要密碼授權也需要進行配置。

運行輸出 PONG，表示連通成功。

2.操作redis

jedis操作redis的方法就是redis的原生指令，幾乎沒有任何改變。

3.事務

package com.kuang;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * @Description:
 * @author: ZYQ
 * @date: 2020/10/18 17:18
 */
public class tesetTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("120.78.198.135", 6379);
        jedis.auth("dhsqj.1982");

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "kuangshen");
        String result = jsonObject.toJSONString();

        //開啟事務
        Transaction multi = jedis.multi();
        try {
            //入隊 此時還未執行
            multi.set("name", result);
            multi.set("age", result);
            //執行
            multi.exec();
            System.out.println(jedis.get("name"));
            System.out.println(jedis.get("age"));
        } catch (Exception e) {
            multi.discard();
            e.printStackTrace();
        } finally {
            jedis.close();
        }
    }
}

二.使用lettuce

1.初始化項目

新建SpringBoot項目，選擇redis依賴

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2.編寫配置文件

在SpringBoot2.x之后，redis依賴的底層實現用lettuce替換掉了jedis

jedis：采用的直連，多個線程操作的話，是不安全的；想要避免不安全，使用jedis pool連接池。更像BIO模式

lettuce：采用netty，實例可以在多個線程中共享，不存在線程不安全的情況；可以減少線程數量。更像NIO模式

源碼分析：

簡單配置一下

spring.redis.host=120.78.198.135
spring.redis.port=6379
spring.redis.password=dhsqj.1982

3.進行測試

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {

        /**
         * 獲取redis的連接對象象
         */
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();

        /**
         * opsForValue 操作String
         * opsForList 操作list
         * opsForSet 操作Set
         * opsForHash 操作Hash
         * opsForZset 操作Zset
         * opsForGeo
         * opsForHyperLogLog
         */
        redisTemplate.opsForValue().set("mykey", "kuangshen");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

}

發現僅在控制台上可以看到正確的結果，而在redis客戶端中查看到的序列化之后的結果是這樣的

點擊redisTemplate查看源碼

找到序列化默認的方式為jdk序列化方式，這種方式會將字符進行轉義，也就是上上圖看到的轉義之后的結果

通過redisTemplate上的conditionalOnMissingBean注解，表明我們可以通過自定義redisTemplate。

可以在自定義的redisTemplate中書寫序列化方法來覆蓋默認的序列化方法，從而解決這個轉義問題。

 

---

 

在未自定義redisTemplate之前，我們再進行測試來加深了解緣由

在pojo包中編寫一個最基礎的User對象，此時未進行序列化

在測試類中，嘗試直接將對象存儲在redis中，發現報錯，異常說明對象需要序列化。

解決方法：在User類中實現序列化接口 Serializable 即可，默認的redisTemplate具有jdk序列化的具體實現，因此在redis中查看到的鍵值對依然為轉義的結果。

 接下來我們嘗試將對象轉化成json數據格式進行存儲並讀取

 發現結果如下，因為目前我們還沒有覆蓋默認的序列化方法

 

---

 

測試完畢，此時對redisTemplate序列化這方面有了一定的了解。接下來我們去自定義redisTemplate

package com.example.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @Description:
 * @author: ZYQ
 * @date: 2020/10/18 22:17
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> template(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //配置具體的序列化方法
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value采用jackson序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value采用jackson序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

在測試中注入自定義的redisTemplate

    @Autowired
    @Qualifier("template")
    private RedisTemplate redisTemplate;

測試方法

注意：

1.pojo類可以不實現 Serialization 接口，自定義的jackson序列化會幫我們做好

2.pojo類必須有無參構造方法，否則會拋出異常

 運行后可以在redis客戶端中發現鍵值對符合我們的需求了

4.總結

 不管是jedis還是lettuce，其操作方法書寫起來都很簡單但繁瑣，我們可以自己去寫一個工具類來包裝一下常用的方法，使得代碼更簡潔。