使用 Jedis操做Redis

1.建立SpringUtils（用来获取指定的bean）

@Component
public class SpringUtils implements ApplicationContextAware {
	
	private static ApplicationContext applicationContext = null;

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		if (SpringUtils.applicationContext == null) {
			SpringUtils.applicationContext = applicationContext;
		}
	}

	/**
	 *  获取applicationContext
	 */
	public static ApplicationContext getApplicationContext() {
		return applicationContext;
	}

	/**
	 *  经过name获取 Bean
	 *  
	 *  @param name			须要获取bean的name
	 */
	public static Object getBean(String name) {
		return getApplicationContext().getBean(name);
	}

	/**
	 *  经过class获取Bean
	 *  
	 *  @param clazz		须要获取bean的class
	 */
	public static <T> T getBean(Class<T> clazz) {
		return getApplicationContext().getBean(clazz);
	}

	/**
	 *  经过name,以及class返回指定的Bean
	 *  
	 * @param name			须要获取bean的name
	 * @param clazz			须要获取bean的class
	 */
	public static <T> T getBean(String name, Class<T> clazz) {
		return getApplicationContext().getBean(name, clazz);
	}
}

2.获取单例的Jedis

/**
 * 获取redis客户端jedis
 * 
 * @author lshaci
 *
 */
public class JedisUtil {
	
	private JedisUtil() {}
	
	private static class JedisUtilHolder {
		private static Jedis jedis = SpringUtils.getBean(JedisConnectionFactory.class).getShardInfo().createResource();
	}

	/**
	 * 获取redis客户端（单例）
	 * 
	 * @return
	 */
	public static Jedis getJedis() {
		return JedisUtilHolder.jedis;
	}
}

3.对redis进行操做（使用fastjson转换对象）

/**
 * redis相关操做工具
 * 
 * @author lshaci
 *
 */
public class RedisUtils {
	
	/**
	 * 操做redis客户端
	 */
	private static Jedis jedis = JedisUtil.getJedis();
	
	/**
	 * 把对象保存到redis中
	 * 
	 * @param key		保存对象的key
	 * @param value		保存的对象
	 */
	public static void set(String key, Object value) {
		jedis.set(JSON.toJSONString(key), JSON.toJSONString(value));
	}
	
	/**
	 * 根据key从redis中取出指定对象
	 * 
	 * @param key		对象的key
	 * @param clazz		对象的类型
	 * @return			key在redis中对应的对象的实例
	 */
	public static <T> T get(String key, Class<T> clazz) {
		String jsonString = jedis.get(JSON.toJSONString(key));
		return JSON.parseObject(jsonString, clazz);
	}
	
	/**
	 * 根据key删除redis中缓存的对象
	 * 
	 * @param key		须要删除对象的key
	 */
	public static void del(String key) {
		jedis.del(JSON.toJSONString(key));
	}
	
	/**
	 * 把对象保存到redis的hash表中
	 * 
	 * @param key		hash的key
	 * @param field		对象对应的字段
	 * @param value		保存的对象
	 */
	public static void hSet(String key, String field, Object value) {
		jedis.hset(JSON.toJSONString(key), JSON.toJSONString(field), JSON.toJSONString(value));
	}
	
	/**
	 * 根据key从redis的hash表中取出指定对象
	 * 
	 * @param key		hash的key
	 * @param field		对象对应的字段
	 * @param clazz		对象的类型
	 * @return			key在redis的hash表中对应field的对象实例
	 */
	public static <T> T hGet(String key, String field, Class<T> clazz) {
		String jsonString = jedis.hget(JSON.toJSONString(key), JSON.toJSONString(field));
		return JSON.parseObject(jsonString, clazz);
	}
	
	/**
	 * 获取模型在redis的hash表中全部的实例
	 * 
	 * @param key		hash的key
	 * @param clazz		对象的类型
	 * @return			key在redis的hash表中对应对象的全部实例集合
	 */
	public static <T> List<T> hGetAll(String key,  Class<T> clazz) {
		Map<String, String> all = jedis.hgetAll(JSON.toJSONString(key));
		Collection<String> values = all.values();
		List<T> ts  = new ArrayList<>();
		for (String jsonString : values) {
			ts.add(JSON.parseObject(jsonString, clazz));
		}
		return ts;
	}
	
	/**
	 * 经过字段在redis指定key的hash表中删除一个对象
	 * 
	 * @param key		hash的key
	 * @param field		对象对应的字段
	 * @return			删除成功返回ture，失败则返回false
	 */
	public static boolean hDel(String key, String field) {
		return jedis.hdel(JSON.toJSONString(key), JSON.toJSONString(field)) == 1;
	}