redis 集成到 spring 中-CSDN博客

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");