spring-data-redis与Jedis整合使用

最新推荐文章于 2023-07-30 21:47:19 发布

xiaomin_____

最新推荐文章于 2023-07-30 21:47:19 发布

阅读量252

点赞数

分类专栏： spring 文章标签：数据库测试 java

本文链接：https://blog.csdn.net/xiaomin1991222/article/details/84903216

版权

spring 专栏收录该内容

124 篇文章 1 订阅

订阅专栏

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

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

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

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

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

   RedisTemplate类的属性 
 

 
   privateboolean enableTransactionSupport =false;
privateboolean exposeConnection =false;
privateboolean initialized =false;
privateboolean enableDefaultSerializer =true;
// 默认的序列化实现
privateRedisSerializer<?> defaultSerializer =newJdkSerializationRedisSerializer();
// 各种操作的序列化方式定义
privateRedisSerializer keySerializer =null;
privateRedisSerializer valueSerializer =null;
privateRedisSerializer hashKeySerializer =null;
privateRedisSerializer hashValueSerializer =null;
privateRedisSerializer<String> stringSerializer =newStringRedisSerializer();
privateScriptExecutor<K> scriptExecutor;
// Spring 提供的各种Redis结构的key-value操作类
// cache singleton objects (where possible)
privateValueOperations<K, V> valueOps;
privateListOperations<K, V> listOps;
privateSetOperations<K, V> setOps;
privateZSetOperations<K, V> zSetOps;
privateHyperLogLogOperations<K, V> hllOps;
 
  
 
   在一个应用中RedisTemplate类对象可以是单例的，因为其属性“ valueOps、listOps、setOps、zSetOps、hllOps 
   ”的各种操作也是线程安全的，源码如下： 
  

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

 
   publicValueOperations<K, V> opsForValue()
{
if(valueOps ==null)
{
 valueOps =newDefaultValueOperations<K, V>(this);
}
return valueOps;
}
publicListOperations<K, V> opsForList()
{
if(listOps ==null)
{
 listOps =newDefaultListOperations<K, V>(this);
}
return listOps;
}
// 省略部分......
 
  

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

 
   publicvoid set(K key, V value)
{
finalbyte[] rawValue = rawValue(value);
 execute(newValueDeserializingRedisCallback(key)
{
protectedbyte[] inRedis(byte[] rawKey,RedisConnection connection)
{
 connection.set(rawKey, rawValue);
returnnull;
}
},true);
}
// 省略其他操作......
 
  

    再看看 
   execute 
   的实现如下： 
  

 
   //org.springframework.data.redis.core.AbstractOperations<K, V>
<T> T execute(RedisCallback<T> callback,boolean b){
return template.execute(callback, b);
}
// template.execute实现如下：
// org.springframework.data.redis.core.RedisTemplate<K, V>
public<T> T execute(RedisCallback<T> action,boolean exposeConnection){
return execute(action, exposeConnection,false);
}
// execute实现如下：
// org.springframework.data.redis.core.RedisTemplate<K, V> --- 最终实现
public<T> T execute(RedisCallback<T> action,boolean exposeConnection,boolean pipeline){
Assert.isTrue(initialized,"template not initialized; call afterPropertiesSet() before using it");
Assert.notNull(action,"Callback object must not be null");
RedisConnectionFactory factory = getConnectionFactory();
RedisConnection conn =null;
try{
if(enableTransactionSupport){
// only bind resources in case of potential transaction synchronization
 conn =RedisConnectionUtils.bindConnection(factory, enableTransactionSupport);
}else{
 conn =RedisConnectionUtils.getConnection(factory);
}
boolean existingConnection =TransactionSynchronizationManager.hasResource(factory);
RedisConnection connToUse = preProcessConnection(conn, existingConnection);
boolean pipelineStatus = connToUse.isPipelined();
if(pipeline &&!pipelineStatus){
 connToUse.openPipeline();
}
RedisConnection connToExpose =(exposeConnection ? connToUse : createRedisConnectionProxy(connToUse));
 T result = action.doInRedis(connToExpose);
// close pipeline
if(pipeline &&!pipelineStatus){
 connToUse.closePipeline();
}
// TODO: any other connection processing?
return postProcessResult(result, connToUse, existingConnection);
}finally{
if(!enableTransactionSupport){
RedisConnectionUtils.releaseConnection(conn, factory);
}
}
}
 
  

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

 
  回到顶部

2.JedisConnectionFactory中使用sentinel集群

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

 
   <!-- Redis sentinel集群配置 -->
<beanid="sentinelConfig"class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
<constructor-argindex="0"type="java.lang.String"value="master001"/>
<constructor-argindex="1"type="java.util.Set">
<set>
<value>192.168.110.100:26379</value>
<value>192.168.110.100:36379</value>
<value>192.168.110.100:46379</value>
</set>
</constructor-arg>
</bean>
<!-- Spring提供的Redis连接工厂 -->
<beanid="jedisConnectionFactory"class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"destroy-method="destroy">
<!-- Redis sentinel集群配置 -->
<constructor-argindex="0"type="org.springframework.data.redis.connection.RedisSentinelConfiguration"ref="sentinelConfig"/>
<!-- 连接池配置. -->
<constructor-argindex="1"type="redis.clients.jedis.JedisPoolConfig"ref="jedisPoolConfig"/>
<!-- Redis服务主机. -->
<propertyname="hostName"value="192.168.110.101"/>
<!-- Redis服务端口号. -->
<propertyname="port"value="6379"/>
<!-- Redis服务连接密码. -->
<!-- <property name="password" value="${redis.password}" /> -->
<!-- 连超时设置. -->
<propertyname="timeout"value="15000"/>
<!-- 是否使用连接池. -->
<propertyname="usePool"value="true"/>
</bean>
 
  
 
   2.使用测试代码 
  

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

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

 
   2015-10-315:10:59 redis.clients.jedis.JedisSentinelPool initSentinels
信息:Trying to find master from available Sentinels...
2015-10-315:10:59 redis.clients.jedis.JedisSentinelPool initSentinels
信息:Redis master running at 192.168.110.101:6379, starting Sentinel listeners...
2015-10-315:10:59 redis.clients.jedis.JedisSentinelPool initPool
信息:CreatedJedisPool to master at 192.168.110.101:6379
V001
2015-10-315:11:38 redis.clients.jedis.JedisSentinelPool initPool
信息:CreatedJedisPool to master at 192.168.110.103:6379
V002
 
  
 
   回到顶部 
    
  
3.JedisConnectionFactory中使用JedisShardInfo

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

privateJedisShardInfo shardInfo;
// 省略......
publicvoid afterPropertiesSet(){
if(shardInfo ==null){
shardInfo =newJedisShardInfo(hostName, port);
if(StringUtils.hasLength(password)){
shardInfo.setPassword(password);
}
if(timeout >0){
setTimeoutOn(shardInfo, timeout);
}
}
if(usePool){
this.pool = createPool();
}
}
// 省略......
protectedJedis fetchJedisConnector(){
try{
if(usePool && pool !=null){
return pool.getResource();
}
Jedis jedis =newJedis(getShardInfo());
// force initialization (see Jedis issue #82)
jedis.connect();
return jedis;
}catch(Exception ex){
thrownewRedisConnectionFailureException("Cannot get Jedis connection", ex);
}
}

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

xiaomin_____

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring-data-redis与Jedis整合使用

1.spring-data-redis与Jedis简单整合spring-data-redis与Jedis简单整合，Redis没有任何集群只是单节点工作，使用连接池1.创建spring-context-jedis.xml配置文件&lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;beansxmlns="http://www.spri...
复制链接

扫一扫