關於redis服務的代碼編碼

IRedisToolsService

package com.dmz.app.biz.redis.service;

import java.io.Serializable;

import java.util.List;
import java.util.Set;

/**
 * redis基礎服務bate版本
 * 
 */
public interface IRedisToolsService {
	/**
	 * 保存數據， 默認7天
	 * @param key redis的key值
	 * @param t 要保存的對象， 必須實現序列化接口
	 * @return 成功， 返回保存的數據
	 */
	<T extends Serializable> T set(String key, T t);
	
	/**
	 * 保存數據
	 * @param key redis的key值
	 * @param t 要保存的對象， 必須實現序列化接口
	 * @param liveSeconds 設置存活時間 單位秒
	 * @return 成功， 返回保存的數據
	 */
	<T extends Serializable> T set(String key, T t, long liveSeconds);
	
	/**
	 * 返回redis中的全部存在的key
	 * @return
	 */
	Set<String> keys();
	
	/**
	 * 返回隨即生成的key值
	 * @return
	 */
	String randomKey();
	
	/**
	 * 返回是否存在該key值
	 * @param key
	 * @return
	 */
	boolean exists(String key);

	/**
	 * 經過key值刪除redis中的數據
	 * @param key
	 * @return
	 */
	<T extends Serializable> T del(String key);
	
	/**
	 * 從redis根據key查找數據
	 * @param key
	 * @return
	 */
	<T extends Serializable> T get(String key);

	/**
	 * 延長key對應的value的存活時間
	 * @param key
	 * @param liveSeconds
	 * @return 延長成功：true， 不然false
	 */
	boolean expire(String key, long liveSeconds);

	long incr(String key);

	long decr(String key);
	
	<T extends Serializable> boolean setNX(final String key, final T t);
	
	<T extends Serializable> T  getSet(final String key, final T t);
	

	/**
	 * 將一個或多個值插入到列表頭部
	 * @param key
	 * @param t
	 * @return
	 */
	<T extends Serializable> long lpush(final String key, final T t);
	/**
	 * 獲取列表指定範圍內的元素
	 * @param key
	 * @param t
	 * @return
	 */
	List lrange(final String key, final long start, final long end);
	/**
	 * 對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間以內的元素都將被刪除。
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	boolean ltrim(final String key, long start, long end);
	
	long lpop(final String key);
	
	/**
	 * 
     * @Title: batchPipelineSet
     * @Description: 批量插入數據
     * @param @param keyList  key值列表
     * @param @param dataList value列表
     * @param @param expire   過時時間
     * @return void    返回類型
     * @throws
	 */
	void batchPipelineSet(List<String> keyList,List<Object> dataList, long expire);
	
}

RedisToolsServiceImpl

package com.dmz.app.biz.redis.service.impl;

import java.io.Serializable;

import java.util.List;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.aic.dmz.app.biz.redis.dao.IRedisToolsDAO;
import com.aic.dmz.app.biz.redis.service.IRedisToolsService;

@Service("redisToolsService")
public class RedisToolsServiceImpl implements IRedisToolsService{
	
	@Resource
	private IRedisToolsDAO redisToolsDAO;

	@Override
	public <T extends Serializable> T set(String key, T t) {

		return (T)redisToolsDAO.set(key, t);
	}

	@Override
	public <T extends Serializable> T set(String key, T t, long liveSeconds) {
		
		return (T)redisToolsDAO.set(key, t, liveSeconds);
	}

	@Override
	public Set<String> keys() {

		return redisToolsDAO.keys();
	}

	@Override
	public String randomKey() {

		return redisToolsDAO.randomKey();
	}

	@Override
	public boolean exists(String key) {

		return redisToolsDAO.exists(key);
	}

	@SuppressWarnings("unchecked")
	@Override
	public <T extends Serializable> T del(String key) {

		return (T)redisToolsDAO.del(key);
	}

	@SuppressWarnings("unchecked")
	@Override
	public <T extends Serializable> T get(String key) {

		return (T)redisToolsDAO.get(key);
	}

	@Override
	public boolean expire(String key, long liveSeconds) {

		return redisToolsDAO.expire(key, liveSeconds);
	}

	@Override
	public long incr(String key) {
		return redisToolsDAO.incr(key);
	}

	@Override
	public long decr(String key) {
		return redisToolsDAO.decr(key);
	}
	
	@Override
	public <T extends Serializable> boolean setNX(final String key, final T t){
	return redisToolsDAO.setNX(key, t);	
	}
	
	@Override
	public <T extends Serializable> T  getSet(final String key, final T t){
		return redisToolsDAO.getSet(key, t);	
	}

	@Override
	public <T extends Serializable> long lpush(final String key, final T t) {
		// TODO Auto-generated method stub
		return redisToolsDAO.lpush(key, t);
	}

	@Override
	public List lrange(final String key, final long start, final long end) {
		// TODO Auto-generated method stub
		return redisToolsDAO.lrange(key, start, end);
	}

	@Override
	public boolean ltrim(final String key, final long start, final long end) {
		// TODO Auto-generated method stub
		return redisToolsDAO.ltrim(key, start, end);
	}

	@Override
	public long lpop(String key) {
		// TODO Auto-generated method stub
		return redisToolsDAO.lpop(key);
	}
	
	public void batchPipelineSet(final List<String> keyList,final  List<Object> dataList, final long expire){
		redisToolsDAO.batchPipelineSet(keyList, dataList, expire);
	}
	
}

IRedisToolsDAO

package com.dmz.app.biz.redis.dao;

import java.io.Serializable;
import java.util.List;
import java.util.Set;

/**
 * redis集成spring， 暫時開放以下接口。若有須要在作擴展
 * @author EX-CHENKEFENG001
 * 
 * @version 1.0bate
 *
 */
public interface IRedisToolsDAO {

	/**
	 * 保存數據， 默認7天
	 * @param key redis的key值
	 * @param t 要保存的對象， 必須實現序列化接口
	 * @return 成功， 返回保存的數據
	 */
	<T extends Serializable> T set(String key, T t);
	
	/**
	 * 保存數據
	 * @param key redis的key值
	 * @param t 要保存的對象， 必須實現序列化接口
	 * @param liveSeconds 設置存活時間 單位秒
	 * @return 成功， 返回保存的數據
	 */
	<T extends Serializable> T set(String key, T t, long liveSeconds);

	/**
	 * 返回redis中的全部存在的key
	 * @return
	 */
	Set<String> keys();
	
	/**
	 * 返回隨即生成的key值
	 * @return
	 */
	String randomKey();
	
	/**
	 * 返回是否存在該key值
	 * @param key
	 * @return
	 */
	boolean exists(String key);

	/**
	 * 經過key值刪除redis中的數據
	 * @param key
	 * @return
	 */
	<T extends Serializable> T del(String key);
	
	/**
	 * 從redis根據key查找數據
	 * @param key
	 * @return
	 */
	<T extends Serializable> T get(String key);

	/**
	 * 延長key對應的value的存活時間
	 * @param key
	 * @param liveSeconds
	 * @return 延長成功：true， 不然false
	 */
	boolean expire(String key, long liveSeconds);

	/**
	 * 增長獲取值
	 * @param key
	 * @return
	 */
	long incr(String key);

	/**
	 * 減小獲取值
	 * @param key
	 * @return
	 */
	long decr(String key);

	
	<T extends Serializable> boolean setNX(final String key, final T t);
	
	<T extends Serializable> T  getSet(final String key, final T t);
	
	/**
	 * 將一個或多個值插入到列表頭部
	 * @param key
	 * @param t
	 * @return
	 */
	<T extends Serializable> long lpush(final String key, final T t);
	/**
	 * 獲取列表指定範圍內的元素
	 * @param key
	 * @param t
	 * @return
	 */
	List lrange(final String key, final long start, final long end);
	/**
	 * 對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間以內的元素都將被刪除。
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	boolean ltrim(final String key, long start, long end);
	

	long lpop(final String key);
	
	
	/**
	 * pipeline
     * @Title: batchPipelineSet
     * @Description: 管道方式插入數據
     * @param  keyList key值列表
     * @param  dataList value值列表
     * @param  expire  過時時間
     * @return void
     * @throws
	 */
	void batchPipelineSet(final List<String> keyList,final List<Object> dataList,final  long expire);
	
}

RedisToolsDAOImpl

package com.dmz.app.biz.redis.dao.impl;

import java.io.Serializable;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Repository;



import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
/**
 * Redis基礎服務
 * @author EX-CHENKEFENG001
 *
 */
@Repository("redisToolsDAO")
public class RedisToolsDAOImpl implements IRedisToolsDAO, ApplicationContextAware{
	
	protected final FormatLogger logger = new FormatLogger(this.getClass());

	private RedisTemplate<String, String> redisTemplate;

	
	@Override
	public <T extends Serializable> T set(final String key, final T t) {
		
		return (T)set(key, t, Constants.DEFAULT_CACHE_SECONDS);
	}

	@Override
	public <T extends Serializable> T set(final String key, final T t, final long liveSeconds) {
		try{
			return redisTemplate.execute(new RedisCallback<T>() {

				@SuppressWarnings("unchecked")
				@Override
				public T doInRedis(RedisConnection conn)
						throws DataAccessException {
					byte[] keys = redisTemplate.getStringSerializer().serialize(key);
					RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
					byte[] values = valueSerializer.serialize(t);
					
					conn.set(keys, values);
					conn.expire(keys, liveSeconds);
					
					return t;
				}
				
			});
			
		}catch(Exception e){
			logger.error(e, "set data has error. key=[{0}]. value=[{1}]", key, t);
			return null;
		}
	}

	@Override
	public Set<String> keys() {
		
		return redisTemplate.execute(new RedisCallback<Set<String>>() {

			@Override
			public Set<String> doInRedis(RedisConnection conn)
					throws DataAccessException {
				byte[] keys = redisTemplate.getStringSerializer().serialize("*");
				Set<byte[]> keyRes = conn.keys(keys);
				Set<String> result = new HashSet<String>();
				for (byte[] bs : keyRes) {
					result.add(redisTemplate.getStringSerializer().deserialize(bs));
				}
				return result;
			}
		});
		
	}

	@Override
	public String randomKey() {
		
		return redisTemplate.randomKey();
	}

	@Override
	public boolean exists(final String key) {
		
		return redisTemplate.execute(new RedisCallback<Boolean>() {

			@Override
			public Boolean doInRedis(RedisConnection conn)
					throws DataAccessException {
				
				return conn.exists(redisTemplate.getStringSerializer().serialize(key));
			}
		});
	}

	@Override
	public <T extends Serializable> T del(final String key) {
		
		return redisTemplate.execute(new RedisCallback<T>() {

			@SuppressWarnings("unchecked")
			@Override
			public T doInRedis(RedisConnection conn)
					throws DataAccessException {
				T t = (T)get(key);
				conn.del(redisTemplate.getStringSerializer().serialize(key));
				return t;
			}
		});
	}

	@Override
	public <T extends Serializable> T get(final String key) {
		
		return redisTemplate.execute(new RedisCallback<T>() {

			@SuppressWarnings("unchecked")
			@Override
			public T doInRedis(RedisConnection conn)
					throws DataAccessException {
				byte[] valBytes = conn.get(redisTemplate.getStringSerializer().serialize(key));
				
				RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
				
				return (T)valueSerializer.deserialize(valBytes);
			}
		});
	}

	@Override
	public boolean expire(final String key, final long liveSeconds) {
		if(!exists(key)){
			return false;
		}
		
		redisTemplate.execute(new RedisCallback<Void>() {

			@Override
			public Void doInRedis(RedisConnection conn)
					throws DataAccessException {
				conn.expire(redisTemplate.getStringSerializer().serialize(key), liveSeconds);
				return null;
			}
		});
		
		return true;
	}

	@Override
	public long incr(final String key) {
		return redisTemplate.execute(new RedisCallback<Long>() {
			@Override
			public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
				return redisConnection.incr(redisTemplate.getStringSerializer().serialize(key));
			}
		});
	}

	@Override
	public long decr(final String key) {
		return redisTemplate.execute(new RedisCallback<Long>() {
			@Override
			public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
				return redisConnection.decr(redisTemplate.getStringSerializer().serialize(key));
			}
		});
	}

	@SuppressWarnings("unchecked")
	@Override
	public void setApplicationContext(ApplicationContext context)
			throws BeansException {
		this.redisTemplate = (RedisTemplate<String, String>) context.getBean("redisTemplate");
		CyberarkV9Service cyberarkV9Service =(CyberarkV9Service) context.getBean("cyberarkV9Service");
		JedisConnectionFactory jedisConnectionFactory =(JedisConnectionFactory)redisTemplate.getConnectionFactory();
		String password= cyberarkV9Service.getPassword("ilifecore.dmz.redis.password");
		if(password==null){
			logger.warn("get redis password from V9 failed!");
			return;
		}
		jedisConnectionFactory.setPassword(password);
		jedisConnectionFactory.getShardInfo().setPassword(password);
		jedisConnectionFactory.afterPropertiesSet();
	}
	
	@Override
	public <T extends Serializable> boolean setNX(final String key, final T t) {
		try{
			return redisTemplate.execute(new RedisCallback<Boolean>() {
				@SuppressWarnings("unchecked")
				@Override
				public Boolean doInRedis(RedisConnection conn)
						throws DataAccessException {
					byte[] keys = redisTemplate.getStringSerializer().serialize(key);
					RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
					byte[] values = valueSerializer.serialize(t);
					return conn.setNX(keys,values);
				}
				
			});
			
		}catch(Exception e){
			logger.error(e, "setNX data has error. key=[{0}]. value=[{1}]", key, t);
			return false;
		}
	}
	
	
	@Override
	public <T extends Serializable> T  getSet(final String key, final T t) {
		try{
			return redisTemplate.execute(new RedisCallback<T>() {
				@SuppressWarnings("unchecked")
				@Override
				public T doInRedis(RedisConnection conn)
						throws DataAccessException {
					byte[] keys = redisTemplate.getStringSerializer().serialize(key);
					RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
					byte[] values = valueSerializer.serialize(t);
					return (T)valueSerializer.deserialize(conn.getSet(keys, values));
				}
				
			});
			
		}catch(Exception e){
			logger.error(e, "getSet data has error. key=[{0}]. value=[{1}]", key, t);
			return null;
		}
	}

	@Override
	public <T extends Serializable> long lpush(final String key, final T t) {
		try {
			return redisTemplate.execute(new RedisCallback<Long>() {
				public Long doInRedis(RedisConnection conn) 
						throws DataAccessException {
					byte[] keys = redisTemplate.getStringSerializer().serialize(key);
					RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
					byte[] values = valueSerializer.serialize(t);
					return conn.lPush(keys, values);
				}
			});
		} catch (Exception e) {
			logger.error(e, "lpush data has error. key=[{0}].value=[{1}]", key, t);
			return 0l;
		}
		
	}

	@Override
	public List lrange(final String key, final long start, final long end) {
		try {
			return redisTemplate.execute(new RedisCallback<List>() {
				public List doInRedis(RedisConnection conn) 
						throws DataAccessException {
					byte[] keys = redisTemplate.getStringSerializer().serialize(key);
					RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
					List list = conn.lRange(keys, start, end);
					List<Object> objects = new ArrayList<Object>();
					for(Object object : list){
						objects.add(valueSerializer.deserialize((byte[]) object));
					}
					return  objects;
				}
			});
		} catch (Exception e) {
			logger.error(e, "lrange data has error. key=[{0}]. start=[{1}]. end=[{2}]", key, start, end);
			return null;
		}
	}

	@Override
	public boolean ltrim(final String key, final long start, final long end) {
		try {
			return redisTemplate.execute(new RedisCallback<Boolean>() {
				public Boolean doInRedis(RedisConnection conn) 
					throws DataAccessException {
					byte[] keys = redisTemplate.getStringSerializer().serialize(key);
					conn.lTrim(keys, start, end);
					return true;
				}
			});
		} catch (Exception e) {
			logger.error(e, "ltrim data has error. key=[{0}]. start=[{1}]. end=[{2}]", key, start, end);
			return false;
		}
	}


	@Override
	public long lpop(final String key) {
		try {
			return redisTemplate.execute(new RedisCallback<Long>() {
				public Long doInRedis(RedisConnection conn) 
						throws DataAccessException {
					byte[] keys = redisTemplate.getStringSerializer().serialize(key);
					RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
					 conn.lPop(keys);
					 return 1l;
				}
			});
		} catch (Exception e) {
			logger.error(e, "lpop data has error. key=[{0}]]", key);
			return 0l;
		}
	}
	
	@Override
	public void batchPipelineSet(final List<String> keyList,final List<Object> dataList, final long expire) {
        //使用pipeline方式
        redisTemplate.executePipelined(new RedisCallback<List<Object>>() {
            @Override
            public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
            	for(int i = 0; i < keyList.size();i++){
            		String key = keyList.get(i);
            		byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
            		@SuppressWarnings("unchecked")
					RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
					byte[] value = valueSerializer.serialize(dataList.get(i));
            		connection.setEx(rawKey, expire, value);
            	}
                return null;
            }
        });
 
    }

	
}