Spring學(xué)習(xí)筆記之RedisTemplate的配置與使用教程

更新時間：2018年06月12日 10:59:21 作者：一灰灰

這篇文章主要給大家介紹了關(guān)于Spring學(xué)習(xí)筆記之RedisTemplate配置與使用的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家學(xué)習(xí)或者使用spring具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

Spring針對Redis的使用，封裝了一個比較強(qiáng)大的Template以方便使用；之前在Spring的生態(tài)圈中也使用過redis，但直接使用Jedis進(jìn)行相應(yīng)的交互操作，現(xiàn)在正好來看一下RedisTemplate是怎么實現(xiàn)的，以及使用起來是否更加便利

I. 基本配置

1. 依賴

依然是采用Jedis進(jìn)行連接池管理，因此除了引入 spring-data-redis之外，再加上jedis依賴，pom文件中添加

<dependency>
 <groupId>org.springframework.data</groupId>
 <artifactId>spring-data-redis</artifactId>
 <version>1.8.4.RELEASE</version>
</dependency>

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

如果需要指定序列化相關(guān)參數(shù)，也可以引入jackson，本篇為簡單入門級，就不加這個了

2. 配置文件

準(zhǔn)備redis相關(guān)的配置參數(shù)，常見的有host, port, password, timeout…，下面是一份簡單的配置，并給出了相應(yīng)的含義

redis.hostName=127.0.0.1
redis.port=6379
redis.password=https://blog.hhui.top
# 連接超時時間
redis.timeout=10000

#最大空閑數(shù)
redis.maxIdle=300
#控制一個pool可分配多少個jedis實例,用來替換上面的redis.maxActive,如果是jedis 2.4以后用該屬性
redis.maxTotal=1000
#最大建立連接等待時間。如果超過此時間將接到異常。設(shè)為-1表示無限制。
redis.maxWaitMillis=1000
#連接的最小空閑時間 默認(rèn)1800000毫秒(30分鐘)
redis.minEvictableIdleTimeMillis=300000
#每次釋放連接的最大數(shù)目,默認(rèn)3
redis.numTestsPerEvictionRun=1024
#逐出掃描的時間間隔(毫秒) 如果為負(fù)數(shù),則不運行逐出線程, 默認(rèn)-1
redis.timeBetweenEvictionRunsMillis=30000
#是否在從池中取出連接前進(jìn)行檢驗,如果檢驗失敗,則從池中去除連接并嘗試取出另一個
redis.testOnBorrow=true
#在空閑時檢查有效性, 默認(rèn)false
redis.testWhileIdle=true

說明

redis密碼請一定記得設(shè)置，特別是在允許遠(yuǎn)程訪問的時候，如果沒有密碼，默認(rèn)端口號，很容易就被是掃描注入腳本，然后開始給人挖礦（親身經(jīng)歷…）

II. 使用與測試

根據(jù)一般的思路，首先是得加載上面的配置，創(chuàng)建redis連接池，然后再實例化RedisTemplate對象，最后持有這個實力開始各種讀寫操作

1. 配置類

使用JavaConfig的方式來配置，主要是兩個Bean，讀取配置文件設(shè)置各種參數(shù)的RedisConnectionFactory以及預(yù)期的RedisTemplate

@Configuration
@PropertySource("classpath:redis.properties")
public class RedisConfig extends JCacheConfigurerSupport {
 @Autowired
 private Environment environment;

 @Bean
 public RedisConnectionFactory redisConnectionFactory() {
 JedisConnectionFactory fac = new JedisConnectionFactory();
 fac.setHostName(environment.getProperty("redis.hostName"));
 fac.setPort(Integer.parseInt(environment.getProperty("redis.port")));
 fac.setPassword(environment.getProperty("redis.password"));
 fac.setTimeout(Integer.parseInt(environment.getProperty("redis.timeout")));
 fac.getPoolConfig().setMaxIdle(Integer.parseInt(environment.getProperty("redis.maxIdle")));
 fac.getPoolConfig().setMaxTotal(Integer.parseInt(environment.getProperty("redis.maxTotal")));
 fac.getPoolConfig().setMaxWaitMillis(Integer.parseInt(environment.getProperty("redis.maxWaitMillis")));
 fac.getPoolConfig().setMinEvictableIdleTimeMillis(
 Integer.parseInt(environment.getProperty("redis.minEvictableIdleTimeMillis")));
 fac.getPoolConfig()
 .setNumTestsPerEvictionRun(Integer.parseInt(environment.getProperty("redis.numTestsPerEvictionRun")));
 fac.getPoolConfig().setTimeBetweenEvictionRunsMillis(
 Integer.parseInt(environment.getProperty("redis.timeBetweenEvictionRunsMillis")));
 fac.getPoolConfig().setTestOnBorrow(Boolean.parseBoolean(environment.getProperty("redis.testOnBorrow")));
 fac.getPoolConfig().setTestWhileIdle(Boolean.parseBoolean(environment.getProperty("redis.testWhileIdle")));
 return fac;
 }

 @Bean
 public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
 RedisTemplate<String, String> redis = new RedisTemplate<>();
 redis.setConnectionFactory(redisConnectionFactory);
 redis.afterPropertiesSet();
 return redis;
 }
}

2. 測試與使用

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RedisConfig.class})
public class RedisTest {

 @Autowired
 private RedisTemplate<String, String> redisTemplate;
 
 @Test
 public void testRedisObj() {
 Map<String, Object> properties = new HashMap<>();
 properties.put("123", "hello");
 properties.put("abc", 456);
 
 redisTemplate.opsForHash().putAll("hash", properties);
 
 Map<Object, Object> ans = redisTemplate.opsForHash().entries("hash");
 System.out.println("ans: " + ans);
 }
}

執(zhí)行后輸出如下

ans: {123=hello, abc=456}

從上面的配置與實現(xiàn)來看，是很簡單的了，基本上沒有繞什么圈子，但是使用redis-cli連上去，卻查詢不到 hash 這個key的內(nèi)容

127.0.0.1:6379> get hash
(nil)
127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x04hash"

使用代碼去查沒問題，直接控制臺連接，發(fā)現(xiàn)這個key和我們預(yù)期的不一樣，多了一些前綴，why ?

3. 序列化問題

為了解決上面的問題，只能debug進(jìn)去，看下是什么引起的了

對應(yīng)源碼位置:

// org.springframework.data.redis.core.AbstractOperations#rawKey

byte[] rawKey(Object key) {
 Assert.notNull(key, "non null key required");
 return this.keySerializer() == null && key instanceof byte[] ? (byte[])((byte[])key) : this.keySerializer().serialize(key);
}

可以看到這個key不是我們預(yù)期的 key.getBytes(), 而是調(diào)用了this.keySerializer().serialize(key)，而debug的結(jié)果，默認(rèn)Serializer是JdkSerializationRedisSerializer

然后就是順藤摸瓜一步一步深入進(jìn)去，鏈路如下

// org.springframework.core.serializer.support.SerializingConverter#convert

// org.springframework.core.serializer.DefaultSerializer#serialize

public class DefaultSerializer implements Serializer<Object> {
 public DefaultSerializer() {
 }

 public void serialize(Object object, OutputStream outputStream) throws IOException {
 if (!(object instanceof Serializable)) {
 throw new IllegalArgumentException(this.getClass().getSimpleName() + " requires a Serializable payload but received an object of type [" + object.getClass().getName() + "]");
 } else {
 ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
 objectOutputStream.writeObject(object);
 objectOutputStream.flush();
 }
 }
}

所以具體的實現(xiàn)很清晰了，就是 ObjectOutputStream,這個東西就是Java中最原始的序列化反序列流工具，會包含類型信息，所以會帶上那串前綴了

所以要解決這個問題，也比較明確了，替換掉原生的JdkSerializationRedisSerializer,改為String的方式，正好提供了一個StringRedisSerializer,所以在RedisTemplate的配置處，稍稍修改

@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
 RedisTemplate<String, String> redis = new RedisTemplate<>();
 redis.setConnectionFactory(redisConnectionFactory);

 // 設(shè)置redis的String/Value的默認(rèn)序列化方式
 StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 redis.setKeySerializer(stringRedisSerializer);
 redis.setValueSerializer(stringRedisSerializer);
 redis.setHashKeySerializer(stringRedisSerializer);
 redis.setHashValueSerializer(stringRedisSerializer);

 redis.afterPropertiesSet();
 return redis;
}

再次執(zhí)行，結(jié)果尷尬的事情出現(xiàn)了，拋異常了，類型轉(zhuǎn)換失敗

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

 at org.springframework.data.redis.serializer.StringRedisSerializer.serialize(StringRedisSerializer.java:33)
 at org.springframework.data.redis.core.AbstractOperations.rawHashValue(AbstractOperations.java:171)
 at org.springframework.data.redis.core.DefaultHashOperations.putAll(DefaultHashOperations.java:129)
 ...

看前面的測試用例，map中的value有integer，而StringRedisSerializer接收的參數(shù)必須是String，所以不用這個，自己照樣子重新寫一個兼容掉

public class DefaultStrSerializer implements RedisSerializer<Object> {
 private final Charset charset;

 public DefaultStrSerializer() {
 this(Charset.forName("UTF8"));
 }

 public DefaultStrSerializer(Charset charset) {
 Assert.notNull(charset, "Charset must not be null!");
 this.charset = charset;
 }


 @Override
 public byte[] serialize(Object o) throws SerializationException {
 return o == null ? null : String.valueOf(o).getBytes(charset);
 }

 @Override
 public Object deserialize(byte[] bytes) throws SerializationException {
 return bytes == null ? null : new String(bytes, charset);

 }
}

然后可以開始愉快的玩耍了,執(zhí)行完之后測試

keys *
1) "\xac\xed\x00\x05t\x00\x04hash"
2) "hash"
127.0.0.1:6379> hgetAll hash
1) "123"
2) "hello"
3) "abc"
4) "456"

III. RedisTemplate使用姿勢

1. opsForXXX

簡單過來一下RedisTemplate的使用姿勢，針對不同的數(shù)據(jù)結(jié)構(gòu)(String, List, ZSet, Hash）讀封裝了比較使用的調(diào)用方式 opsForXXX

// hash 數(shù)據(jù)結(jié)構(gòu)操作
org.springframework.data.redis.core.RedisTemplate#opsForHash

// list
org.springframework.data.redis.core.RedisTemplate#opsForList

// string
org.springframework.data.redis.core.RedisTemplate#opsForValue

// set
org.springframework.data.redis.core.RedisTemplate#opsForSet

// zset
org.springframework.data.redis.core.RedisTemplate#opsForZSet

2. execute

除了上面的這種使用方式之外，另外一種常見的就是直接使用execute了，一個簡單的case如下

@Test
public void testRedis() {
 String key = "hello";
 String value = "world";
 redisTemplate.execute((RedisCallback<Void>) con -> {
 con.set(key.getBytes(), value.getBytes());
 return null;
 });

 String asn = redisTemplate.execute((RedisCallback<String>) con -> new String(con.get(key.getBytes())));
 System.out.println(asn);


 String hkey = "hKey";
 redisTemplate.execute((RedisCallback<Void>) con -> {
 con.hSet(hkey.getBytes(), "23".getBytes(), "what".getBytes());
 return null;
 });

 Map<byte[], byte[]> map = redisTemplate.execute((RedisCallback<Map<byte[], byte[]>>) con -> con.hGetAll(hkey.getBytes()));
 for (Map.Entry<byte[], byte[]> entry : map.entrySet()) {
 System.out.println("key: " + new String(entry.getKey()) + " | value: " + new String(entry.getValue()));
 }
}

輸出結(jié)果如下

world
key: 23 | value: what

3. 區(qū)別

一個自然而然能想到的問題就是上面的兩種方式有什么區(qū)別？

opsForXXX 的底層，就是通過調(diào)用execute方式來做的，其主要就是封裝了一些使用姿勢，定義了序列化，使用起來更加的簡單和便捷；這種方式下，帶來的小號就是每次都需要新建一個DefaultXXXOperations對象，多繞了一步，基于此是否會帶來額外的性能和內(nèi)存開銷呢？沒測過，但個人感覺量小的情況下，應(yīng)該沒什么明顯的影響；而qps很高的情況下，這方便的優(yōu)化能帶來的幫助，估計也不太大