redis 集成到 spring 中

云深处

　　redis  集成到 spring 中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:tool="http://www.springframework.org/schema/tool"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/tool
http://www.springframework.org/schema/tool/spring-tool.xsd">
<!-- other redis connection configuration begin-->
<bean id="otherRedis"
class="com.trace.db.otherredis.RedisEntry"
scope="singleton" >
<property name="hostName" value="127.0.0.1" />
<property name="portNumber" value="6379" />
<property name="password"><null/></property>
</bean>
<bean id="redisconnectionconfig"
class="com.trace.db.otherredis.RedisConnectionConfigBean"
scope="singleton" >
<property name="hostConfig">
<list>
<ref bean="otherRedis" />
</list>
</property>
</bean>
<bean id="redisConnectionContext"
class="com.trace.db.otherredis.RedisConnectionContext"
scope="singleton" >
<property name="redisConfig" ref="redisconnectionconfig"/>
</bean>
<!-- other redis connection configuration fin-->
</beans>

package com.trace.db.otherredis;
public class RedisEntry {
private String hostName;
private int portNumber;
private String password;
public RedisEntry()
{
setHostName("localhost");
setPortNumber(6379);
setPassword(null);
}

public String getHostName() {
return hostName;
}
public void setHostName(String hostName) {
this.hostName = hostName;
}
public int getPortNumber() {
return portNumber;
}
public void setPortNumber(int portNumber) {
this.portNumber = portNumber;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}


package com.trace.db.otherredis;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
public class RedisConnectionConfigBean extends JedisPoolConfig {
private Logger log = Logger.getLogger(RedisConnectionConfigBean.class);
private static final int REDIS_MAX_ACTIVE = 1000;
private static final int REDIS_MAX_IDLE  = 60;
private static final int REDIS_MAX_WAIT  = 4000;
private static final boolean  REDIS_TEST_ON_BORROW = true;
private List<RedisEntry> hostConfig = null;

public RedisConnectionConfigBean()
{
super();
log.info("RedisConnectionConfigBean Constructor");
this.setMaxActive(RedisConnectionConfigBean.REDIS_MAX_ACTIVE);
this.setMaxIdle(RedisConnectionConfigBean.REDIS_MAX_IDLE);
this.setMaxWait(RedisConnectionConfigBean.REDIS_MAX_WAIT);
this.setTestOnBorrow(RedisConnectionConfigBean.REDIS_TEST_ON_BORROW);
}

public List<JedisShardInfo> getShardList()
{
if(null == hostConfig || hostConfig.isEmpty())
{
return null;
}
List<JedisShardInfo> reltList = new ArrayList<JedisShardInfo>();
for(RedisEntry entry : hostConfig)
{
JedisShardInfo localInfo = new JedisShardInfo(entry.getHostName(), entry.getPortNumber());
localInfo.setPassword(entry.getPassword());
log.info("JedisConnectionConfigBean getShardList entry for "+ entry.getHostName() + ":" + entry.getPortNumber());
reltList.add(localInfo);
}//end for
return reltList;
}
public void setHostConfig(List<RedisEntry> hostConfig) {
log.info("JedisConnectionConfigBean setHostConfig");
this.hostConfig = hostConfig;
}
public List<RedisEntry> getHostConfig() {
return hostConfig;
}
}


package com.trace.db.otherredis;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;  
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class RedisConnectionContext {
private Logger log = Logger.getLogger(RedisConnectionContext.class);
private RedisConnectionConfigBean redisConfig = null;
private ShardedJedisPool shardedJedisPool = null;
/**
*
*/
public RedisConnectionContext()
{
log.debug("JedisConnectionFactory constructor");
}

private ShardedJedisPool getShardedJedisPool()
{
if(null == redisConfig)
{
log.error("getShardedJedisPool with null config");
return null;
}
if(null == shardedJedisPool)
{
log.error("getShardedJedisPool while no pool exist, create a new one");
shardedJedisPool = new ShardedJedisPool(redisConfig, redisConfig.getShardList());
}
return shardedJedisPool;
}
private ShardedJedis getRedisConnection()
{
ShardedJedis localJedis = null;
try
{
localJedis = this.getShardedJedisPool().getResource();
if(null == localJedis)
{
log.error("getRedisConnection: can NOT get instance");
}
return localJedis;
} catch (Exception e)
{
log.error("getRedisConnection Exception");
e.printStackTrace();
return null;
}
}
@SuppressWarnings("unused")
private void closeRedisConnection(ShardedJedis paramJedis)
{
if (null != paramJedis)
{
try
{
this.getShardedJedisPool().returnResource(paramJedis);
} catch (Exception e)
{
log.error("closeRedisConnection Exception");
e.printStackTrace();
}
}
paramJedis = null;
}

// next operations
public  void  setRedisMap(String taskId, Map<String, String> eventMap){
log.debug("setRedisMap: taskId: " + taskId);
this.getRedisConnection().hmset(taskId,eventMap);
}

public    List<String>  getRedisMap(String taskId,String... field){
log.debug("getRedisMap: taskId: " + taskId + " field:" + field) ;
return   this.getRedisConnection().hmget(taskId,field);
}




public void setRedisConfig(RedisConnectionConfigBean paramJedisConfig) {
redisConfig = paramJedisConfig;
}
public RedisConnectionConfigBean getRedisConfig() {
return redisConfig;
}
}


log.info("init context: " + ProbServiceConfigs.SCTX_OTHER_REDIS_SUPPORT);
ApplicationContext otherRedisContext =  new ClassPathXmlApplicationContext(ProbServiceConfigs.SCTX_OTHER_REDIS_SUPPORT);
paramContextEvent.getServletContext().setAttribute(ProbServiceConfigs.SCTX_OTHER_REDIS_SUPPORT, otherRedisContext);

RedisConnectionContext redisCtx = (RedisConnectionContext) otherRedisContext.getBean("redisConnectionContext");