redis做缓存的简单实例

由于之前对redis有了一个系统的研究,在公司的多个项目中使用redis当做数据缓存;所以趁着这些天晚上的时间,自己写了一个demo;这里仅供自己后期学习笔记参考,若有不对的地方,请轻拍砖!

redis 官网推荐给java 使用的客户端很多:Jedis、Redisson、JRedis、JDBC-Redis 等,当然首推是jedis;可以参考redis客户端官网查看。

接下来来讲下我的这个demo,我这个案例不是通过spring进行整合的redis,这个将会在之后的demo中讲到的。

(1).创建一个maven 功臣,在工程的pom 中引入jedis客户端;还有要依赖spring管理,所以也要引入spring相关jar包。

		
				redis.clients
				jedis
				${jedis-version}
			
		

(2).一般一个(系统)项目所用的redis服务器 多节点的集群服务器,所以会自己对(jedis)redis客户端进行封装,由于本例我自己写的是单节点,但是我还是按多节点的思路对客户端进行了封装。

redisClient类

/**
 * redis 客户端封装
 * @author leo
 *
 */
public class RedisClient  {
	/**
	 * 日志记录
	 */
	private static final Log LOG = LogFactory.getLog(RedisClient.class);
	/**
	 * redis 连接池
	 */
	private JedisPool pool;
	
	public void setPool(JedisPool pool) {
		this.pool = pool;
	}
	/**
	 * 获取jedis 
	 * @return
	 */
	public Jedis getResource(){
		Jedis jedis =null;
		try {
			jedis =pool.getResource();
		} catch (Exception e) {
			LOG.info("can't  get  the redis resource");
		}
		return jedis;
	}
	/**
	 * 关闭连接
	 * @param jedis
	 */
	public void disconnect(Jedis jedis){
		jedis.disconnect();
	}
	/**
	 * 将jedis 返还连接池
	 * @param jedis
	 */
	public void returnResource(Jedis jedis){
		if(null != jedis){
			try {
				pool.returnResource(jedis);
			} catch (Exception e) {
				LOG.info("can't return jedis to jedisPool");
			}
		}
	}
	/**
	 * 无法返还jedispool,释放jedis客户端对象,
	 * @param jedis
	 */
	public void brokenResource(Jedis jedis){
		if (jedis!=null) {
			try {
				pool.returnBrokenResource(jedis);
			} catch (Exception e) {
				LOG.info("can't release jedis Object");
			}
		}
	}
}
然后 通过spring的bean.xml 来管理 连接池,和连接池参数配置,以及redisClient 的依赖注入。


		
			
			
			
			
			
		
		
		
			 
			 
			
			 
		
		
		
			
		
(3).创建好redisClient 之后,我要创造一个存储器,即一个对redis操作的工具容器。由于是公共容器,所以我创建接口是的容器接口就不该是封闭的,应该是开封的,保证存入数据库中对象类型的多态性。

存储器接口:

/**
 * 
 * @author leo
 *缓存存储接口
 * @param  key
 * @param  value
 */
public interface RedisCacheStorage {
	/**
	 * 在redis数据库中插入 key  和value
	 * @param key
	 * @param value
	 * @return
	 */
	boolean set(K key,V value);
	/**
	 * 在redis数据库中插入 key  和value 并且设置过期时间
	 * @param key
	 * @param value
	 * @param exp 过期时间 s
	 * @return
	 */
	boolean set(K key, V value, int exp);
	/**
	 * 根据key 去redis 中获取value
	 * @param key
	 * @return
	 */
	V get(K key);
	/**
	 * 删除redis库中的数据
	 * @param key
	 * @return
	 */
	boolean remove(K key);
	/**
	 * 设置哈希类型数据到redis 数据库
	 * @param cacheKey 可以看做一张表
	 * @param key	表字段
	 * @param value  
	 * @return
	 */
	boolean hset(String cacheKey,K key,V value);
	/**
	 * 获取哈希表数据类型的值
	 * @param cacheKey
	 * @param key
	 * @return
	 */
	V hget(String cacheKey,K key);
	/**
	 * 获取哈希类型的数据
	 * @param cacheKey
	 * @return
	 */
	Map hget(String cacheKey);
以及存储实现类:

/**
 * redis 缓存存储器实现
 * @author leo
 *
 * @param 
 */
public class RedisCacheStorageImpl implements RedisCacheStorage {
	/**
	 * 日志记录
	 */
	public static final Log LOG = LogFactory.getLog(RedisCacheStorageImpl.class);
	/**
	 * redis 客户端
	 */
	private RedisClient redisClient;
	/**
	 * 默认过时时间
	 */
	private static final int EXPRIE_TIME =3600*24; 
	
	public void setRedisClient(RedisClient redisClient) {
		this.redisClient = redisClient;
	}
	/**
	 * 在redis数据库中插入 key  和value
	 * @param key
	 * @param value
	 * @return
	 */
	@Override
	public boolean set(String key, V value) {
		//设置默认过时时间
		return set(key, value, EXPRIE_TIME);
	}
	/**
	 * 在redis数据库中插入 key  和value 并且设置过期时间
	 * @param key
	 * @param value
	 * @param exp 过期时间 s
	 * @return
	 */
	@SuppressWarnings("finally")
	@Override
	public boolean set(String key, V value, int exp) {
		Jedis jedis =null;
		//将key 和value  转换成 json 对象
		String jKey =CacheUtils.toJsonString(key);
		String jValue =CacheUtils.toJsonString(value);
		//操作是否成功
		boolean isSucess =true;
		if(StringUtils.isNotEmpty(jKey)){
			LOG.info("key is empty");
			return false;
		}
		try {
			//获取客户端对象
			jedis =redisClient.getResource();
			//执行插入
			jedis.setex(jKey, exp, jValue);
		} catch (JedisException e) {
			LOG.info("client can't connect server");
			isSucess =false;
			if(null !=jedis){
				//释放jedis对象
				redisClient.brokenResource(jedis);
			}
			return false;
		}finally{
			if(isSucess){
				//返还连接池
				redisClient.returnResource(jedis);
			}
			return true;
		}
	}
	/**
	 * 根据key 去redis 中获取value
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	@Override
	public V get(String key) {
		Jedis jedis =null;
		//将key 和value  转换成 json 对象
		String jKey =CacheUtils.toJsonString(key);
		V jValue =null;
		//key 不能为空
		if(StringUtils.isEmpty(jKey)){
			LOG.info("key is empty");
			return null;
		}
		try {
			//获取客户端对象
			jedis =redisClient.getResource();
			//执行查询
			String value =	jedis.get(jKey);
			//判断值是否非空
			if(StringUtils.isEmpty(value)){
				return null;
			}else{
				jValue= (V) CacheUtils.jsonParseObject(value);
			}
			//返还连接池
			redisClient.returnResource(jedis);
		} catch (JedisException e) {
			LOG.info("client can't connect server");
			if(null !=jedis){
				//释放jedis 对象
				redisClient.brokenResource(jedis);
			}
		}
		return jValue;
	}
	/**
	 * 删除redis库中的数据
	 * @param key
	 * @return
	 */
	@SuppressWarnings("finally")
	@Override
	public boolean remove(String key) {
		Jedis jedis =null;
		//将key 和value  转换成 json 对象
		String jKey =CacheUtils.toJsonString(key);
		//操作是否成功
		boolean isSucess =true;
		if(StringUtils.isEmpty(jKey)){
			LOG.info("key is empty");
			return false;
		}
		try {
			jedis =redisClient.getResource();
			//执行删除
			jedis.del(jKey);
		} catch (JedisException e) {
			LOG.info("client can't connect server");
			isSucess =false;
			if(null !=jedis){
				//释放jedis 对象
				redisClient.brokenResource(jedis);
			}
			return false;
		}finally{
			if (isSucess) {
				//返还连接池
				redisClient.returnResource(jedis);
			}
			return true;
		}
	}
	/**
	 * 设置哈希类型数据到redis 数据库
	 * @param cacheKey 可以看做一张表
	 * @param key	表字段
	 * @param value  
	 * @return
	 */
	@SuppressWarnings("finally")
	@Override
	public boolean hset(String cacheKey, String key, V value) {
		Jedis jedis =null;
		//将key 和value  转换成 json 对象
		String jKey =CacheUtils.toJsonString(key);
		String jCacheKey =CacheUtils.toJsonString(cacheKey);
		String jValue =CacheUtils.toJsonString(value);
		//操作是否成功
		boolean isSucess =true;
		if(StringUtils.isEmpty(jCacheKey)){
			LOG.info("cacheKey is empty");
			return false;
		}
		try {
			jedis =redisClient.getResource();
			//执行插入哈希
			jedis.hset(jCacheKey, jKey, jValue);
		} catch (JedisException e) {
			LOG.info("client can't connect server");
			isSucess =false;
			if(null !=jedis){
				//释放jedis 对象
				redisClient.brokenResource(jedis);
			}
			return false;
		}finally{
			if (isSucess) {
				//返还连接池
				redisClient.returnResource(jedis);
			}
			return true;
		}
	}
	/**
	 * 获取哈希表数据类型的值
	 * @param cacheKey
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	@Override
	public V hget(String cacheKey, String key) {
		Jedis jedis =null;
		//将key 和value  转换成 json 对象
		String jKey =CacheUtils.toJsonString(key);
		String jCacheKey =CacheUtils.toJsonString(cacheKey);
		V jValue =null;
		if(StringUtils.isEmpty(jCacheKey)){
			LOG.info("cacheKey is empty");
			return null;
		}
		try {
			//获取客户端对象
			jedis =redisClient.getResource();
			//执行查询
			String value =	jedis.hget(jCacheKey, jKey);
			//判断值是否非空
			if(StringUtils.isEmpty(value)){
				return null;
			}else{
				jValue= (V) CacheUtils.jsonParseObject(value);
			}
			//返还连接池
			redisClient.returnResource(jedis);
		} catch (JedisException e) {
			LOG.info("client can't connect server");
			if(null !=jedis){
				//释放jedis 对象
				redisClient.brokenResource(jedis);
			}
		}
		return jValue;
	}
	/**
	 * 获取哈希类型的数据
	 * @param cacheKey
	 * @return
	 */
	@Override
	public Map hget(String cacheKey) {
		String jCacheKey =CacheUtils.toJsonString(cacheKey);
		//非空校验
		if(StringUtils.isEmpty(jCacheKey)){
			LOG.info("cacheKey is empty!");
			return null;
		}
		Jedis jedis =null;
		Map result =null;
		try {
			jedis =redisClient.getResource();
			//获取列表集合
			Map map = jedis.hgetAll(jCacheKey); 
			
			if(null !=map){
				for(Map.Entry entry : map.entrySet()){
					if(result ==null){
						result =new HashMap();
					}
					result.put((String) CacheUtils.jsonParseObject(entry.getKey()), (V)CacheUtils.jsonParseObject(entry.getValue()));
				}
			}
		} catch (JedisException e) {
			LOG.info("client can't connect server");
			if(null !=jedis){
				//释放jedis 对象
				redisClient.brokenResource(jedis);
			}
		}
		return result;
	}

}
(4),接下来要把写个具体的业务UserService,来测试redis的存储器在具体业务中的使用,即实现(非关系型数据库的持久化操作)。本例中的例子是经常项目中对user的操作

创建UserEntity实体类:

/**
 * 用户实体类
 * @author leo
 *
 */
public class UserEntity {
	//用户id
	private String userId;
	//用户账号
	private String EmpCode;
	//用户名称
	private String EmpName;
	//用户角色
	private String role;
	//职位
	private String title;
	public String getUserId() {
		return userId;
	}
	public void setUserId(String userId) {
		this.userId = userId;
	}
	public String getEmpCode() {
		return EmpCode;
	}
	public void setEmpCode(String empCode) {
		EmpCode = empCode;
	}
	public String getEmpName() {
		return EmpName;
	}
	public void setEmpName(String empName) {
		EmpName = empName;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
然后创建用户操作的业务层Service;由于这里主要是测试NOSQL的数据持久化,所以就忽略了对数据库持久化层(DAO)的操作。

userServiceImpl类:

/**
 * 业务层接口实现
 * @author leo
 *
 */
public class UserServiceImpl implements IUserService {
	private static final String  cacheKey  ="userEntity";
	/**
	 * 缓存存储
	 */
	private RedisCacheStorageImpl storageCache;
	
	public void setStorageCache(RedisCacheStorageImpl storageCache) {
		this.storageCache = storageCache;
	}
	/**
	 * 新增
	 * @param entity
	 * @return
	 */
	@Override
	public boolean addUserEntity(UserEntity entity) {
		//非空
		if(entity ==null || StringUtils.isEmpty(entity.getUserId())){
			return false;
		}
		/**
		 * 做数据库持久化,这里就无需再申明了
		 */
		System.out.println("先插入数据库中,.........");
		//然后接下来做非关系型数据库持久化
		return storageCache.hset(cacheKey, entity.getUserId(), entity);
	}

	@Override
	public boolean deleteUserEntity(UserEntity entity) {
		
		return false;
	}
	/**
	 * 根据id 查询
	 * @return
	 */
	@Override
	public UserEntity queryUserEntityByUserId(UserEntity userEntity) {
		//非空
		if(userEntity ==null || StringUtils.isEmpty(userEntity.getUserId())){
			return null;
		}
		//先去缓存中查询 是否存在,不存在在查询
		 UserEntity reslut = storageCache.hget(cacheKey, userEntity.getUserId());
		if(reslut!=null){
			return reslut;
		}else{
			//查询数据库
			System.out.println("查询数据库");
		}
		return null;
	}

}
以及spring-bean.xml的配置对业务层的管理:


		
			
		
		
			
		
(6).最后写个junit 测下,查看是否有没有插入到redis库中

public class TestUserServiceImpl {
	/**
	 * 用户接口
	 */
	private IUserService userServiceImpl;
	
	public void setUserServiceImpl(IUserService userServiceImpl) {
		this.userServiceImpl = userServiceImpl;
	}
	@Before
	public void setUp() throws Exception {
		userServiceImpl = (IUserService) SpringTestHelper.get().getBeanByClass(UserServiceImpl.class);
	}

	@After
	public void tearDown() throws Exception {
	}
	@Test
	public void testAdd(){
		UserEntity entity = new UserEntity();
		entity.setUserId("000001");
		entity.setEmpCode("130566");
		entity.setEmpName("leonardo-zeng");
		entity.setRole("Java Development Engineer");
		entity.setTitle("PM");
		boolean isTrue =userServiceImpl.addUserEntity(entity);
		Assert.assertTrue(isTrue);
	}
	
	@Test
	public void testQueryById(){
		UserEntity entity = new UserEntity();
		entity.setUserId("000001");
		UserEntity userEntity =userServiceImpl.queryUserEntityByUserId(entity);
		System.out.println(userEntity);
	}
}
连接redis库,查询出来的确值在库中存在

redis 127.0.0.1:6379> hkeys "\"userEntity\""
1) "\"000001\""
redis 127.0.0.1:6379> hget "\"userEntity\"" "\"000001\""
"{\"@type\":\"com.deppon.cache.entity.UserEntity\",\"empCode\":\"130566\",\"empN
ame\":\"leonardo-zeng\",\"role\":\"Java Development Engineer\",\"title\":\"PM\",
\"userId\":\"000001\"}"
redis 127.0.0.1:6379>
整个demo就这样了




你可能感兴趣的:(redis)