jedispool释放连接_redis项目实例

#访问地址
redis.host=127.0.0.1
#访问端口
redis.port=6379
#注意，如果没有password，此处不设置值，但这一项要保留
redis.password=123456
#最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。
redis.maxIdle=300
#连接池的最大数据库连接数。设为0表示无限制  
redis.maxActive=600
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
redis.maxWait=1000
#在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；  
redis.testOnBorrow=true
#客户端连接超时时间
redis.timeout=30000
#可用数据库数
redis.database = 0

<beans xmlns="http://www.springframework.org/schema/beans" 
		   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		   xmlns:p="http://www.springframework.org/schema/p" 
		   xmlns:tx="http://www.springframework.org/schema/tx"
		   xmlns:context="http://www.springframework.org/schema/context"
		   xsi:schemaLocation="
			http://www.springframework.org/schema/beans 
			http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
			http://www.springframework.org/schema/tx 
			http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
			http://www.springframework.org/schema/context
			http://www.springframework.org/schema/context/spring-context-3.0.xsd
			   ">
	
	<!-- 加载redis属性文件  --> 
	<context:property-placeholder location="classpath*:/redis.properties" />
	
	<!-- redis连接池  --> 
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
		<property name="maxIdle" value="${redis.maxIdle}" />  
		<property name="maxActive" value="${redis.maxActive}" />  
		<property name="maxWait" value="${redis.maxWait}" />  
		<property name="testOnBorrow" value="${redis.testOnBorrow}" />  
	</bean>  
	
	<!-- 单片机方式  -->
	<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
            <constructor-arg name="poolConfig" ref="poolConfig" />
            <constructor-arg name="host" value="${redis.host}" />
            <constructor-arg name="port" value="${redis.port}" type="int" />
            <constructor-arg name="timeout" value="${redis.timeout}" type="int" />
            <constructor-arg name="password" value="${redis.password}" />
            <constructor-arg name="database" value="${redis.database}" type="int" />
        </bean>
	
        <!-- 集群方式  --> 
	<!-- <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"  scope="singleton">
    	<constructor-arg index="0" ref="poolConfig" />
        <constructor-arg index="1">
            <list>
                <bean class="redis.clients.jedis.JedisShardInfo">
                    <constructor-arg name="host" value="${redis.host}" />
                </bean>
            </list>
        </constructor-arg>
        </bean> -->
</beans>			

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
		/WEB-INF/applicationContext.xml;
		/WEB-INF/redis-context.xml;
	</param-value>
</context-param>

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import cn.com.highset.goexpo.util.JsonDateValueProcessor;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
@Service
public class RedisService {
@Autowired
    private JedisPool jedisPool;//注入jedisPool
//保存单个值
public void set(String key,String value){
    Jedis jedis = jedisPool.getResource();
    jedis.set(key, value);
}
//获取单个值
public String get(String key){
    String value = "";
    Jedis jedis = jedisPool.getResource();
    value = jedis.get(key);
    return value;
}
//根据key删除值
public void del(String key){
    Jedis jedis = jedisPool.getResource();
    jedis.del(key);
}
//保存list集合
public void setList(String key,List<Map> list){
    if(list != null){
        Jedis jedis = jedisPool.getResource();
for(Map m : list){
    JsonConfig jsonConfig = new JsonConfig();  
//处理时间格式,注意时间类型java.sql.Timestamp/java.util.Date/java.sql.Date
jsonConfig.registerJsonValueProcessor(java.sql.Timestamp.class, new JsonDateValueProcessor("yyyy-MM-dd HH:mm:ss"));  
JSONObject jsonObject = JSONObject.fromObject(m,jsonConfig);  
    String jsonString = jsonObject.toString(); 
    jedis.rpush(key, jsonString);
        }
    }
}
//获取list集合
public List<Map> getList(String key){
    List<Map> listMap = new ArrayList<Map>();
    Jedis jedis = jedisPool.getResource();
    List<String> list = jedis.lrange(key, 0, -1);  
    for(String m : list){  
JSONObject jsonObject = JSONObject.fromObject(m);
    Map<Object, Object> map = (Map)jsonObject;
    listMap.add(map);
    }  
    return listMap;
}
//获取list分页数据
public List<Map> getPageList(String key,int start,int end){
    List<Map> listMap = new ArrayList<Map>();
    Jedis jedis = jedisPool.getResource();
    List<String> list = jedis.lrange(key, start, end);  
    for(String m : list){  
JSONObject jsonObject = JSONObject.fromObject(m);
    Map<Object, Object> map = (Map)jsonObject;
    listMap.add(map);
    }  
    return listMap;
}
}

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
public class JsonDateValueProcessor implements JsonValueProcessor { 
private String format ="yyyy-MM-dd hh:mm:ss";  
public JsonDateValueProcessor() {  
super();  
}  
public JsonDateValueProcessor(String format) {  
super();  
this.format = format;  
}  
@Override  
public Object processArrayValue(Object paramObject,JsonConfig paramJsonConfig) {  
return process(paramObject);  
}  
@Override  
public Object processObjectValue(String paramString, Object paramObject,JsonConfig paramJsonConfig) {  
return process(paramObject);  
}  
private Object process(Object value){  
if(value instanceof Date){    
SimpleDateFormat sdf = new SimpleDateFormat(format,Locale.CHINA);    
return sdf.format(value);  
}    
return value == null ? "" : value.toString();    
}  
}