前言
Spring針對Redis的使用，封裝了一個比較強大的Template以方便使用；之前在Spring的生態圈中也使用過redis，但直接使用Jedis進行相應的交互操作，現在正好來看一下RedisTemplate是怎麼實現的，以及使用起來是否更加便利
依然是採用Jedis進行連接池管理，因此除了引入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>
如果需要指定序列化相關參數，也可以引入jackson，本篇為簡單入門級，就不加這個了
準備redis相關的配置參數，常見的有host, port, password, timeout…，下面是一份簡單的配置，並給出了相應的含義
redis.hostName=127.0.0.1redis.port=6379redis.password=https://blog.hhui.top# 連接超時時間redis.timeout=10000#最大空閒數redis.maxIdle=300#控制一個pool可分配多少個jedis實例,用來替換上面的redis.maxActive,如果是jedis 2.4以後用該屬性redis.maxTotal=1000#最大建立連接等待時間。如果超過此時間將接到異常。設為-1表示無限制。 redis.maxWaitMillis=1000#連接的最小空閒時間默認1800000毫秒(30分鐘)redis.minEvictableIdleTimeMillis=300000#每次釋放連接的最大數目,默認3redis.numTestsPerEvictionRun=1024#逐出掃描的時間間隔(毫秒) 如果為負數,則不運行逐出線程, 默認-1redis.timeBetweenEvictionRunsMillis=30000#是否在從池中取出連接前進行檢驗,如果檢驗失敗,則從池中去除連接並嘗試取出另一個redis.testOnBorrow=true#在空閒時檢查有效性, 默認falseredis.testWhileIdle=true
說明
redis密碼請一定記得設置，特別是在允許遠程訪問的時候，如果沒有密碼，默認端口號，很容易就被是掃描注入腳本，然後開始給人挖礦（親身經歷…）
根據一般的思路，首先是得加載上面的配置，創建redis連接池，然後再實例化RedisTemplate對象，最後持有這個實力開始各種讀寫操作
使用JavaConfig的方式來配置，主要是兩個Bean，讀取配置文件設置各種參數的RedisConnectionFactory以及預期的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; }}@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); }}執行後輸出如下
ans: {123=hello, abc=456}從上面的配置與實現來看，是很簡單的了，基本上沒有繞什麼圈子，但是使用redis-cli連上去，卻查詢不到hash 這個key的內容
127.0.0.1:6379> get hash(nil)127.0.0.1:6379> keys *1) "/xac/xed/x00/x05t/x00/x04hash"
使用代碼去查沒問題，直接控制台連接，發現這個key和我們預期的不一樣，多了一些前綴，why ?
為了解決上面的問題，只能debug進去，看下是什麼引起的了
對應源碼位置:
// org.springframework.data.redis.core.AbstractOperations#rawKeybyte[] 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不是我們預期的key.getBytes(), 而是調用了this.keySerializer().serialize(key)，而debug的結果，默認Serializer是JdkSerializationRedisSerializer
然後就是順藤摸瓜一步一步深入進去，鏈路如下
// org.springframework.core.serializer.support.SerializingConverter#convert// org.springframework.core.serializer.DefaultSerializer#serializepublic 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(); } }}所以具體的實現很清晰了，就是ObjectOutputStream,這個東西就是Java中最原始的序列化反序列流工具，會包含類型信息，所以會帶上那串前綴了
所以要解決這個問題，也比較明確了，替換掉原生的JdkSerializationRedisSerializer,改為String的方式，正好提供了一個StringRedisSerializer,所以在RedisTemplate的配置處，稍稍修改
@Beanpublic RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, String> redis = new RedisTemplate<>(); redis.setConnectionFactory(redisConnectionFactory); // 設置redis的String/Value的默認序列化方式StringRedisSerializer stringRedisSerializer = new StringRedisSerializer(); redis.setKeySerializer(stringRedisSerializer); redis.setValueSerializer(stringRedisSerializer); redis.setHashKeySerializer(stringRedisSerializer); redis.setHashValueSerializer(stringRedisSerializer); redis.afterPropertiesSet(); return redis;}再次執行，結果尷尬的事情出現了，拋異常了，類型轉換失敗
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接收的參數必須是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); }}然後可以開始愉快的玩耍了,執行完之後測試
keys *1) "/xac/xed/x00/x05t/x00/x04hash"2) "hash"127.0.0.1:6379> hgetAll hash1) "123"2) "hello"3) "abc"4) "456"
簡單過來一下RedisTemplate的使用姿勢，針對不同的數據結構(String, List, ZSet, Hash）讀封裝了比較使用的調用方式opsForXXX
// hash 數據結構操作org.springframework.data.redis.core.RedisTemplate#opsForHash// listorg.springframework.data.redis.core.RedisTemplate#opsForList// stringorg.springframework.data.redis.core.RedisTemplate#opsForValue// setorg.springframework.data.redis.core.RedisTemplate#opsForSet// zsetorg.springframework.data.redis.core.RedisTemplate#opsForZSet
除了上面的這種使用方式之外，另外一種常見的就是直接使用execute了，一個簡單的case如下
@Testpublic 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())); }}輸出結果如下
world
key: 23 | value: what
一個自然而然能想到的問題就是上面的兩種方式有什麼區別？
opsForXXX 的底層，就是通過調用execute方式來做的，其主要就是封裝了一些使用姿勢，定義了序列化，使用起來更加的簡單和便捷；這種方式下，帶來的小號就是每次都需要新建一個DefaultXXXOperations對象，多繞了一步，基於此是否會帶來額外的性能和內存開銷呢？沒測過，但個人感覺量小的情況下，應該沒什麼明顯的影響；而qps很高的情況下，這方便的優化能帶來的幫助，估計也不太大
study-demo/spring-redis
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對武林網的支持。