redis缓存

zhaolu

/**　　
* RedisUnit
　　
* @author dsine
　　
*/
　　
public class RedisUnit {
　　/**
　　* 服务地址
　　*/
　　private String host;
　　

　　/**
　　* 端口，默认端口是6379
　　*/
　　private Integer port;
　　/**
　　* 密码
　　*/
　　private String password = "123456";
　　

　　/**
　　* 默认key前缀
　　*/
　　private String defaultKeyPrefix = "";
　　/**
　　* 最小空闲连接数
　　*/
　　private Integer minIdle = 5;
　　/**
　　* 最大空闲连接数
　　*/
　　private Integer maxIdle = 10;
　　/**
　　* 最大连接数
　　*/
　　private Integer maxTotal = 100;
　　/**
　　* 连接池
　　*/
　　private JedisPool jedisPool;
　　/**
　　* 连接池配置，具体参数：
　　* blockWhenExhausted = true;//连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
　　* evictionPolicyClassName = "org.apache.commons.pool2.impl.DefaultEvictionPolicy";//设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
　　* jmxEnabled = true;// 是否启用pool的jmx管理功能, 默认true
　　* jmxNamePrefix = "pool";
　　* lifo = true; //是否启用后进先出, 默认true
　　* minIdle = 5;//最小空闲连接数, 默认0
　　* maxIdle = 10;/最大空闲连接数, 默认8个
　　* maxTotal = 100;//最大连接数, 默认8个
　　* maxWaitMillis = 3000L;//获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间，默认-1
　　* testOnBorrow = true;//在获取连接的时候检查有效性, 默认false
　　* testOnReturn = true;//返回一个jedis实例给连接池时，是否检查连接可用性
　　* testWhileIdle = true;//在空闲时检查有效性, 默认false
　　* minEvictableIdleTimeMillis = 1800000L;//逐出连接的最小空闲毫秒，默认1800000毫秒(30分钟)
　　* softMinEvictableIdleTimeMillis = 1800000L;//对象空闲多久后逐出, 当空闲时间>该值 ，且空闲连接>最大空闲数时直接逐出,不再根据MinEvictableIdleTimeMillis判断 (默认逐出策略)，默认30m
　　* timeBetweenEvictionRunsMillis = 60000L;//逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
　　* numTestsPerEvictionRun = 5;//每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
　　*/
　　private JedisPoolConfig jedisPoolConfig;
　　/**
　　*初始化启动，创建连接池
　　*可以设置密码，防止外部操作
　　*/
　　@PostConstruct
　　public void init(){
　　jedisPoolConfig = new JedisPoolConfig();
　　jedisPoolConfig.setMinIdle(minIdle);
　　jedisPoolConfig.setMaxIdle(maxIdle);
　　jedisPoolConfig.setMaxTotal(maxTotal);
　　if( password != null && !"".equals( password.trim() ) ){
　　jedisPool = new JedisPool( jedisPoolConfig, this.host, this.port, Protocol.DEFAULT_TIMEOUT, this.password );
　　}else{
　　jedisPool = new JedisPool( jedisPoolConfig, this.host, this.port, Protocol.DEFAULT_TIMEOUT );
　　}
　　}
　　@PreDestroy销毁
　　public void destroy(){
　　jedisPool.destroy();
　　}
　　private Jedis getJedis(){
　　Jedis jedis = jedisPool.getResource();
　　return jedis;
　　}
　　/**
　　* 验证key是否为空
　　*/
　　private void checkKeyNotBlank( String key ){
　　if( key == null || "".equals( key ) ){
　　throw new RuntimeException( "key is blank" );
　　}
　　}
　　/**
　　* set设置缓存
　　*/
　　public void set( String keyPrefix, String key, Object value ){
　　this.checkKeyNotBlank( key );
　　this.getJedis().set( ObjectUtil.toBytes( keyPrefix + key ), ObjectUtil.toBytes( value ) );
　　}
　　/**
　　* set设置缓存
　　*/
　　public void set( String key, Object value ){
　　this.set( defaultKeyPrefix, key, value );
　　}
　　/**
　　* setNoPrefixToString
　　*/
　　public void setNoPrefixToString(String key, String flag, String value ){
　　this.checkKeyNotBlank( key );
　　Logger.info("向缓存中添加标志位"+flag+"的缓存，其中KEY 是"+key+"_"+flag+"VALUE 是"+value);
　　this.getJedis().set(key+"_"+flag, value);
　　}
　　/**
　　* setex可以设置超时时间
　　*/
　　public void setex( String keyPrefix, Integer timeOut, String key, Object value ){
　　this.checkKeyNotBlank( key );
　　this.getJedis().setex( ObjectUtil.toBytes( keyPrefix + key ), timeOut, ObjectUtil.toBytes( value ) );
　　}
　　/**
　　* setex可以设置超时时间
　　*/
　　public void setex( String key, Integer timeOut, Object value ){
　　if(defaultKeyPrefix != null && !"".equals(defaultKeyPrefix)){
　　this.setex( defaultKeyPrefix, timeOut, key, value );
　　}else{
　　this.setexObject(key, timeOut,  value);
　　}
　　}
　　/**
　　* setexObject可以设置超时时间
　　*/
　　public void setexObject( String key, Integer timeOut, Object value ){
　　this.checkKeyNotBlank( key );
　　String jsonString = JsonUtil.toJson(value);
　　this.getJedis().setex(key, timeOut, jsonString);
　　}
　　/**
　　* get单个获取
　　*/
　　public  T get( String keyPrefix, String key, Class clazz ){
　　this.checkKeyNotBlank( key );
　　Jedis redis = this.getJedis();
　　byte[] bs = redis.get( ObjectUtil.toBytes( keyPrefix + key ) );
　　if( bs == null || bs.length == 0 ){
　　return null;
　　}else{
　　T value = ObjectUtil.toObject( bs, clazz );
　　return value;
　　}
　　}
　　/**
　　* get单个获取
　　*/
　　public  T get( String key, Class clazz ){
　　return this.get( defaultKeyPrefix, key, clazz);
　　}
　　/**
　　* get单个获取
　　*/
　　public String getNoPrefixToString( String key ){
　　checkKeyNotBlank(key);
　　return this.getJedis().get(key);
　　}
　　/**
　　* 获取所有的key
　　* position 0为前包含，1位后包含, 2为所有*
　　* containStr 包含字符串
　　*/
　　public Map getAllKey(Integer position, String containStr){
　　Map map = new HashMap();
　　String sourceStr = "*";
　　try{
　　if(position == 0){
　　sourceStr = containStr + sourceStr;
　　}else if(position == 1){
　　sourceStr = sourceStr + containStr;
　　}
　　Jedis redis = this.getJedis();
　　Set set = (Set)redis.keys(sourceStr);
　　if(!set.isEmpty()){
　　for(String i : set){
　　String value=this.getNoPrefixToString(i);
　　map.put(i, value);
　　Logger.info("后缀为"+containStr+"中的KEY 是"+i+", VALUE 是："+value);
　　}
　　}else{
　　if(position==1){
　　Logger.info("后标志位为："+containStr+"在缓存中没有数据");
　　}else{
　　Logger.info("前标志位为："+containStr+"在缓存中没有数据");
　　}
　　}
　　}catch(Exception e){
　　Logger.error("匹配key为" + containStr + "异常", e);
　　}
　　return map;
　　}
　　/**
　　* del删除
　　*/
　　public void del( String keyPrefix, String key ){
　　Jedis redis = this.getJedis();
　　redis.del(key);
　　}
　　/**
　　* del删除
　　*/
　　public void del( String key ){
　　Jedis redis = this.getJedis();
　　redis.del(key);
　　}
　　

　　public void setHost(String host) {
　　this.host = host;
　　}
　　

　　public void setPort(Integer port) {
　　this.port = port;
　　}
　　

　　public void setPassword(String password) {
　　this.password = password;
　　}
　　

　　public void setMinIdle(Integer minIdle) {
　　this.minIdle = minIdle;
　　}
　　

　　public void setMaxIdle(Integer maxIdle) {
　　this.maxIdle = maxIdle;
　　}
　　

　　public void setMaxTotal(Integer maxTotal) {
　　this.maxTotal = maxTotal;
　　}
　　

　　public void setDefaultKeyPrefix(String defaultKeyPrefix) {
　　this.defaultKeyPrefix = defaultKeyPrefix;
　　}