Springboot使用Jedis

1、導包

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

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

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
    <scope>provided</scope>
</dependency>

2、添加 application.properties 配置

#ip地址
redis.host=192.168.25.131
#端口號
redis.port=6379
#如果有密碼
redis.password=123456
#客戶端超時時間單位是毫秒 默認是2000
redis.timeout=3000
#數據庫，默認的是0
redis.database=0
#最大空閑數
redis.maxIdle=300  
#連接池的最大數據庫連接數。設為0表示無限制,如果是jedis 2.4以后用redis.maxTotal
redis.maxActive=1000
#控制一個pool可分配多少個jedis實例,用來替換上面的redis.maxActive,如果是jedis 2.4以后用該屬性
redis.maxTotal=1000
#最大建立連接等待時間。如果超過此時間將接到異常。設為-1表示無限制。
redis.maxWaitMillis=1000
#在空閑時檢查有效性, 默認false
redis.testOnBorrow=false
#連接耗盡是否阻塞,false代表拋異常,true代表阻塞直到超時,默認為true
redis.blockWhenExhausted=false
#是否啟用pool的jmx管理功能, 默認true
redis.JmxEnabled=true
 
#下面的不是必須的配置
#連接的最小空閑時間 默認1800000毫秒(30分鍾)
minEvictableIdleTimeMillis=300000  
#每次釋放連接的最大數目,默認3
numTestsPerEvictionRun=1024  
#逐出掃描的時間間隔(毫秒) 如果為負數,則不運行逐出線程, 默認-1
timeBetweenEvictionRunsMillis=30000  
#是否在從池中取出連接前進行檢驗,如果檢驗失敗,則從池中去除連接並嘗試取出另一個,數據量大的時候建議關閉
testWhileIdle=true

3、編寫 RedisConfig 配置文件

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@PropertySource("classpath:application.properties")
public class RedisConfig {
    @Value("${redis.host}")
    private String host;

    @Value("${redis.port}")
    private int port;

    @Value("${redis.password}")
    private int password;

    @Value("${redis.database}")
    private int database;

    @Value("${redis.timeout}")
    private int timeout;

    @Value("${redis.maxIdle}")
    private int maxIdle;

    @Value("${redis.maxWaitMillis}")
    private int maxWaitMillis;

    @Value("${redis.blockWhenExhausted}")
    private Boolean blockWhenExhausted;

    @Value("${redis.JmxEnabled}")
    private Boolean JmxEnabled;

    @Bean
    public JedisPool jedisPoolFactory() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        // 連接耗盡時是否阻塞, false報異常,true阻塞直到超時, 默認true
        jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);
        // 是否啟用pool的jmx管理功能, 默認true
        jedisPoolConfig.setJmxEnabled(JmxEnabled);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout,password,database);
        return jedisPool;
    }
}

使用常量

package com.common.constants;

/**
 * @author z
 */
public interface RedisConstants {

    String HOST = "XX.XX.XX.XX";
    int PORT = 6379;
    String PASSWORD = "";
    int TIME_OUT = 5000;
    int MAX_ACTIVE = 200;
    int MAX_IDLE = 8;
    int MIN_IDLE = 0;
    int MAX_WAIT_MILLIS = -1;
    int DATA_BASE = 2;
}

package com.common.config;

import com.common.constants.RedisConstants;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author z
 */
@Configuration
public class RedisConfig {

    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(RedisConstants.MAX_IDLE);
        jedisPoolConfig.setMaxWaitMillis(RedisConstants.MAX_WAIT_MILLIS);
        jedisPoolConfig.setMaxTotal(RedisConstants.MAX_ACTIVE);
        jedisPoolConfig.setMinIdle(RedisConstants.MIN_IDLE);
        return jedisPoolConfig;
    }

    @Bean
    public JedisPool jedisPool() {
        JedisPoolConfig jedisPoolConfig = jedisPoolConfig();
        return new JedisPool(jedisPoolConfig, RedisConstants.HOST, RedisConstants.PORT, RedisConstants.TIME_OUT, RedisConstants.PASSWORD, RedisConstants.DATA_BASE);
    }

}

4、編寫RedisUtil工具類

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.params.SetParams;


@Component
public class RedisUtil {

    @Autowired
    private JedisPool jedisPool;

    /**
     * 向Redis中存值，永久有效
     */
    public String set(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.set(key, value);
        } catch (Exception e) {
            return "0";
        } finally {
            jedis.close();
        }
    }

    /**
     * 根據傳入Key獲取指定Value
     */
    public String get(String key) {
        Jedis jedis = null;
        String value;
        try {
            jedis = jedisPool.getResource();
            value = jedis.get(key);
        } catch (Exception e) {
            return "0";
        } finally {
            jedis.close();
        }
        return value;
    }

    /**
     * 校驗Key值是否存在
     */
    public Boolean exists(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.exists(key);
        } catch (Exception e) {
            return false;
        } finally {
            jedis.close();
        }
    }

    /**
     * 刪除指定Key-Value
     */
    public Long del(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.del(key);
        } catch (Exception e) {
            return 0L;
        } finally {
            jedis.close();
        }
    }

    /**
     * 分布式鎖
     * @param key
     * @param value
     * @param time 鎖的超時時間，單位：秒
     *
     * @return 獲取鎖成功返回"OK"，失敗返回null
     */
    public String getDistributedLock(String key,String value,int time){
        Jedis jedis = null;
        String ret = "";
        try {
            jedis = jedisPool.getResource();

            ret = jedis.set(key, value, new SetParams().nx().ex(time));
            return ret;
        } catch (Exception e) {
            return null;
        } finally {
            jedis.close();
        }
    }
}

使用jackson進行對象的序列化與反序列化

            // 序列化對象存入redis
            ObjectMapper om = new ObjectMapper();
            String s = om.writeValueAsString(userVO);
            redisUtil.set(redisKey, s);

            // 反序列化成對象
            ObjectMapper om = new ObjectMapper();
            UserVO userVO = om.readValue(user, UserVO.class);
            String username = userVO.getUsername();

進行反序列化時出現： Cannot construct instance of java.time.LocalDate、Could not read JSON: Expected array or string.

原因：

存入redis中時應該時間格式應該是 1998-07-01 和 2021-01-30 03:00:51這樣的時間格式，但是默認存的卻是默認格式的。
LocalDateTime、LocalDate、LocalTime沒有格式化成yyyy-MM-dd HH:mm:ss類似這樣的格式，還有要將LocalDateTime、LocalDate、LocalTime的反序列化方式設置一下，因為它們默認的反序列化方式是序列化成了一個數組類型

解決：在序列化實體屬性添加注解

    /**
     * 創建時間
     */
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private LocalDateTime createTime;

5、使用 springboot 默認 RedisTemplate

• 導包

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

• 配置 application.properties

spring:
  redis:
    host: 192.168.1.111
    port: 6379

由於Springboot-data-redis幫我們自動裝載了RedisTemplate對象，所以我們無需注冊該bean。但是，如果用默認的 RedisTemplate ，那么在序列化存到redis中就會發現，key 就變的“不正常”了。
比如，存之前key為"test" ，進入redis看，key就變成了"\xac\xed\x00\x05t\x00\x04test" 。這與RedisTemplate默認提供的序列化協議有關。為了使其更符合我們的需求，我們需要訂制序列化協議。

• 選擇Springboot自帶的Jackson為序列化協議，進行配置

@Configuration
public class RedisConfiguration {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize 替換默認序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 設置value的序列化規則和 key的序列化規則
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

• 測試使用

@RunWith(SpringRunner.class)
@SpringBootTest(classes = EdApplication.class)
public class FenCiUtilText {
    @Autowired
    private RedisTemplate redisTemplate;
    //測試放入
    @Test
    public void testRedisSet() {
        try {
            redisTemplate.opsForValue().set("test","This is a Springboot-Redis test!");
        } catch (Exception e){
            System.out.println(e.toString());
        }
 
    }
    //測試拿出
    @Test
    public void testRedisGet() {
        try {
            String key="test";
            Boolean isHas = redisTemplate.hasKey(key);
            if (isHas){
                Object test = redisTemplate.opsForValue().get(key);
                System.out.println(test);
            }else {
                System.out.println("抱歉！不存在key值為"+key);
            }
        } catch (Exception e){
            System.out.println(e.toString());
        }
    }
}

---

參考鏈接：
https://www.cnblogs.com/yuqingya/p/12881712.html
https://www.cnblogs.com/beanbag/p/13081444.html