spring-data-redis与Jedis整合使用

1.spring-data-redis与Jedis简单整合

spring-data-redis与Jedis简单整合，Redis没有任何集群只是单节点工作，使用连接池

1.创建spring-context-jedis.xml配置文件

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beansxmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:mvc="http://www.springframework.org/schema/mvc"
6. xsi:schemaLocation="
7. http://www.springframework.org/schema/mvc
8. http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
9. http://www.springframework.org/schema/beans
10. http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
11. http://www.springframework.org/schema/context
12. http://www.springframework.org/schema/context/spring-context-4.0.xsd"
13. default-lazy-init="false">
15. <!-- 连接池配置. -->
16. <beanid="jedisPoolConfig"class="redis.clients.jedis.JedisPoolConfig">
17. <!-- 连接池中最大连接数。高版本：maxTotal，低版本：maxActive -->
18. <propertyname="maxTotal"value="8"/>
19. <!-- 连接池中最大空闲的连接数. -->
20. <propertyname="maxIdle"value="4"/>
21. <!-- 连接池中最少空闲的连接数. -->
22. <propertyname="minIdle"value="1"/>
23. <!-- 当连接池资源耗尽时，调用者最大阻塞的时间，超时将跑出异常。单位，毫秒数;默认为-1.表示永不超时。高版本：maxWaitMillis，低版本：maxWait -->
24. <propertyname="maxWaitMillis"value="5000"/>
25. <!-- 连接空闲的最小时间，达到此值后空闲连接将可能会被移除。负值(-1)表示不移除. -->
26. <propertyname="minEvictableIdleTimeMillis"value="300000"/>
27. <!-- 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3 -->
28. <propertyname="numTestsPerEvictionRun"value="3"/>
29. <!-- “空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1. -->
30. <propertyname="timeBetweenEvictionRunsMillis"value="60000"/>
31. <!-- testOnBorrow:向调用者输出“链接”资源时，是否检测是有有效，如果无效则从连接池中移除，并尝试获取继续获取。默认为false。建议保持默认值. -->
32. <!-- testOnReturn:向连接池“归还”链接时，是否检测“链接”对象的有效性。默认为false。建议保持默认值.-->
33. <!-- testWhileIdle:向调用者输出“链接”对象时，是否检测它的空闲超时；默认为false。如果“链接”空闲超时，将会被移除。建议保持默认值. -->
34. <!-- whenExhaustedAction:当“连接池”中active数量达到阀值时，即“链接”资源耗尽时，连接池需要采取的手段, 默认为1(0:抛出异常。1:阻塞，直到有可用链接资源。2:强制创建新的链接资源) -->
35. </bean>
37. <!-- Spring提供的Redis连接工厂 -->
38. <beanid="jedisConnectionFactory"class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"destroy-method="destroy">
39. <!-- 连接池配置. -->
40. <propertyname="poolConfig"ref="jedisPoolConfig"/>
41. <!-- Redis服务主机. -->
42. <propertyname="hostName"value="192.168.110.101"/>
43. <!-- Redis服务端口号. -->
44. <propertyname="port"value="6379"/>
45. <!-- Redis服务连接密码. -->
46. <!-- <property name="password" value="${redis.password}" /> -->
47. <!-- 连超时设置. -->
48. <propertyname="timeout"value="15000"/>
49. <!-- 是否使用连接池. -->
50. <propertyname="usePool"value="true"/>
51. </bean>
53. <!-- Spring提供的访问Redis类. -->
54. <beanid="jedisTemplate"class="org.springframework.data.redis.core.RedisTemplate">
55. <propertyname="connectionFactory"ref="jedisConnectionFactory"/>
56. <propertyname="keySerializer">
57. <beanclass="org.springframework.data.redis.serializer.StringRedisSerializer"/>
58. </property>
59. <propertyname="valueSerializer">
60. <!-- <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" /> -->
61. <beanclass="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
62. </property>
63. </bean>
64. </beans>

2.使用Spring提供的RedisTemplate类

1. publicstaticvoid main(String[] args)
2. {
3. ClassPathXmlApplicationContext applicationContext =newClassPathXmlApplicationContext("spring-context-jedis.xml");
5. // 获取Spring提供的RedisTemplate类此类封装了Jedis，简化操作
6. RedisTemplate<String,List<String>> redisTemplate = applicationContext.getBean("jedisTemplate",RedisTemplate.class);
7. // Spring 提供的各种Redis结构的key-value操作类
8. ValueOperations<String,List<String>> value = redisTemplate.opsForValue();
9. HashOperations<String,Object,Object> hash = redisTemplate.opsForHash();
10. ListOperations<String,List<String>> list = redisTemplate.opsForList();
11. HyperLogLogOperations<String,List<String>> hyperLogLog = redisTemplate.opsForHyperLogLog();
12. SetOperations<String,List<String>> set = redisTemplate.opsForSet();
13. ZSetOperations<String,List<String>> zSet = redisTemplate.opsForZSet();
15. List<String> listValue =newArrayList<String>();
16. listValue.add("001");
17. listValue.add("002");
18. value.set("list", listValue);
19. System.out.println(value.get("list"));
21. // 关闭Spring容器释放资源
22. applicationContext.close();
23. }

3.关于RedisTemplate类源码学习

RedisTemplate类的属性

1. privateboolean enableTransactionSupport =false;
2. privateboolean exposeConnection =false;
3. privateboolean initialized =false;
4. privateboolean enableDefaultSerializer =true;
5. // 默认的序列化实现
6. privateRedisSerializer<?> defaultSerializer =newJdkSerializationRedisSerializer();
8. // 各种操作的序列化方式定义
9. privateRedisSerializer keySerializer =null;
10. privateRedisSerializer valueSerializer =null;
11. privateRedisSerializer hashKeySerializer =null;
12. privateRedisSerializer hashValueSerializer =null;
13. privateRedisSerializer<String> stringSerializer =newStringRedisSerializer();
15. privateScriptExecutor<K> scriptExecutor;
17. // Spring 提供的各种Redis结构的key-value操作类
18. // cache singleton objects (where possible)
19. privateValueOperations<K, V> valueOps;
20. privateListOperations<K, V> listOps;
21. privateSetOperations<K, V> setOps;
22. privateZSetOperations<K, V> zSetOps;
23. privateHyperLogLogOperations<K, V> hllOps;

在一个应用中RedisTemplate类对象可以是单例的，因为其属性“ valueOps、listOps、setOps、zSetOps、hllOps”的各种操作也是线程安全的，源码如下：

获取其“ valueOps、listOps、setOps、zSetOps、hllOps”属性：

1. publicValueOperations<K, V> opsForValue()
2. {
3. if(valueOps ==null)
4. {
5. valueOps =newDefaultValueOperations<K, V>(this);
6. }
7. return valueOps;
8. }
10. publicListOperations<K, V> opsForList()
11. {
12. if(listOps ==null)
13. {
14. listOps =newDefaultListOperations<K, V>(this);
15. }
16. return listOps;
17. }
18. // 省略部分......

其属性“ valueOps、listOps、setOps、zSetOps、hllOps”的各种操作也是线程安全的，例如valueOps属性对象默认实现类DefaultValueOperations<K, V>源码：

1. publicvoid set(K key, V value)
2. {
3. finalbyte[] rawValue = rawValue(value);
4. execute(newValueDeserializingRedisCallback(key)
5. {
6. protectedbyte[] inRedis(byte[] rawKey,RedisConnection connection)
7. {
8. connection.set(rawKey, rawValue);
9. returnnull;
10. }
11. },true);
12. }
13. // 省略其他操作......

再看看execute的实现如下：

1. //org.springframework.data.redis.core.AbstractOperations<K, V>
2. <T> T execute(RedisCallback<T> callback,boolean b){
3. return template.execute(callback, b);
4. }
5. // template.execute实现如下：
7. // org.springframework.data.redis.core.RedisTemplate<K, V>
8. public<T> T execute(RedisCallback<T> action,boolean exposeConnection){
9. return execute(action, exposeConnection,false);
10. }
11. // execute实现如下：
13. // org.springframework.data.redis.core.RedisTemplate<K, V> --- 最终实现
14. public<T> T execute(RedisCallback<T> action,boolean exposeConnection,boolean pipeline){
15. Assert.isTrue(initialized,"template not initialized; call afterPropertiesSet() before using it");
16. Assert.notNull(action,"Callback object must not be null");
18. RedisConnectionFactory factory = getConnectionFactory();
19. RedisConnection conn =null;
20. try{
22. if(enableTransactionSupport){
23. // only bind resources in case of potential transaction synchronization
24. conn =RedisConnectionUtils.bindConnection(factory, enableTransactionSupport);
25. }else{
26. conn =RedisConnectionUtils.getConnection(factory);
27. }
29. boolean existingConnection =TransactionSynchronizationManager.hasResource(factory);
31. RedisConnection connToUse = preProcessConnection(conn, existingConnection);
33. boolean pipelineStatus = connToUse.isPipelined();
34. if(pipeline &&!pipelineStatus){
35. connToUse.openPipeline();
36. }
38. RedisConnection connToExpose =(exposeConnection ? connToUse : createRedisConnectionProxy(connToUse));
39. T result = action.doInRedis(connToExpose);
41. // close pipeline
42. if(pipeline &&!pipelineStatus){
43. connToUse.closePipeline();
44. }
46. // TODO: any other connection processing?
47. return postProcessResult(result, connToUse, existingConnection);
48. }finally{
50. if(!enableTransactionSupport){
51. RedisConnectionUtils.releaseConnection(conn, factory);
52. }
53. }
54. }

此时已经可以看出每次操作都会创建一个新的RedisConnection对象使用完成会调用RedisConnectionUtils.releaseConnection(conn, factory)方法释放连接，若想查看其创建RedisConnection连接和RedisConnectionUtils.releaseConnection(conn, factory)释放连接过程可继续查看其源码，此处就不赘述了。

回到顶部

2.JedisConnectionFactory中使用sentinel集群

1.在spring-context-jedis.xml中配置sentinel信息

1. <!-- Redis sentinel集群配置 -->
2. <beanid="sentinelConfig"class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
3. <constructor-argindex="0"type="java.lang.String"value="master001"/>
4. <constructor-argindex="1"type="java.util.Set">
5. <set>
6. <value>192.168.110.100:26379</value>
7. <value>192.168.110.100:36379</value>
8. <value>192.168.110.100:46379</value>
9. </set>
10. </constructor-arg>
11. </bean>
13. <!-- Spring提供的Redis连接工厂 -->
14. <beanid="jedisConnectionFactory"class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"destroy-method="destroy">
15. <!-- Redis sentinel集群配置 -->
16. <constructor-argindex="0"type="org.springframework.data.redis.connection.RedisSentinelConfiguration"ref="sentinelConfig"/>
17. <!-- 连接池配置. -->
18. <constructor-argindex="1"type="redis.clients.jedis.JedisPoolConfig"ref="jedisPoolConfig"/>
20. <!-- Redis服务主机. -->
21. <propertyname="hostName"value="192.168.110.101"/>
22. <!-- Redis服务端口号. -->
23. <propertyname="port"value="6379"/>
24. <!-- Redis服务连接密码. -->
25. <!-- <property name="password" value="${redis.password}" /> -->
26. <!-- 连超时设置. -->
27. <propertyname="timeout"value="15000"/>
28. <!-- 是否使用连接池. -->
29. <propertyname="usePool"value="true"/>
30. </bean>

2.使用测试代码

1. publicstaticvoid main(String[] args)
2. {
3. ClassPathXmlApplicationContext applicationContext =newClassPathXmlApplicationContext("spring-context-jedis.xml");
4. // 获取Spring提供的RedisTemplate类此类封装了Jedis，简化操作
5. RedisTemplate<String,String> redisTemplate = applicationContext.getBean("jedisTemplate",RedisTemplate.class);
6. ValueOperations<String,String> value = redisTemplate.opsForValue();
7. value.set("K001","V001");
8. System.out.println(value.get("K001"));
10. // 关闭Redis Master服务
11. Scanner scanner =newScanner(System.in);
12. String input = scanner.nextLine();
13. System.out.println(input);
15. value.set("K002","V002");
16. System.out.println(value.get("K002"));
18. // 关闭Spring容器释放资源
19. applicationContext.close();
20. }

代码输出，注意中间的打印：

1. 2015-10-315:10:59 redis.clients.jedis.JedisSentinelPool initSentinels
2. 信息:Trying to find master from available Sentinels...
3. 2015-10-315:10:59 redis.clients.jedis.JedisSentinelPool initSentinels
4. 信息:Redis master running at 192.168.110.101:6379, starting Sentinel listeners...
5. 2015-10-315:10:59 redis.clients.jedis.JedisSentinelPool initPool
6. 信息:CreatedJedisPool to master at 192.168.110.101:6379
7. V001
8. 2015-10-315:11:38 redis.clients.jedis.JedisSentinelPool initPool
9. 信息:CreatedJedisPool to master at 192.168.110.103:6379
12. V002

回到顶部

3.JedisConnectionFactory中使用JedisShardInfo

Spring-Data-Redis好像并不支持Redis分片集群，但是JedisConnectionFactory源码中有一个JedisShardInfo属性，源码如下：

1. privateJedisShardInfo shardInfo;
   
2. // 省略......
3. publicvoid afterPropertiesSet(){
4. if(shardInfo ==null){
5. shardInfo =newJedisShardInfo(hostName, port);
7. if(StringUtils.hasLength(password)){
8. shardInfo.setPassword(password);
9. }
11. if(timeout >0){
12. setTimeoutOn(shardInfo, timeout);
13. }
14. }
16. if(usePool){
17. this.pool = createPool();
18. }
19. }
20. // 省略......
21. protectedJedis fetchJedisConnector(){
22. try{
23. if(usePool && pool !=null){
24. return pool.getResource();
25. }
26. Jedis jedis =newJedis(getShardInfo());
27. // force initialization (see Jedis issue #82)
28. jedis.connect();
29. return jedis;
30. }catch(Exception ex){
31. thrownewRedisConnectionFailureException("Cannot get Jedis connection", ex);
32. }
33. }

http://www.cnblogs.com/LiZhiW/p/4853486.html