redis基本操作之二 （增删改查）

代码下载地址：代码下载

一、实现原理

利用redis list和hash存法实现数据带排序增删改查

相关命令操作   点击打开链接

二、jar包版本

jedis2.9.0  下载地址：http://mvnrepository.com/artifact/redis.clients/jedis/2.9.0

fastjson1.2.24 下载地址：http://mvnrepository.com/artifact/com.alibaba/fastjson/1.2.24

二、代码实现

1. redis连接类

   import java.util.logging.Logger;
   
   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisPool;
   import redis.clients.jedis.JedisPoolConfig;
   
   /**
    * 
    * @author zhy
    *
    */
   public class RedisConnUtil {
   	private static JedisPool jedisPool = null;
   	private static String addr = "192.168.0.45";
   	private static int port = 6379;
   	private static Logger log = Logger.getAnonymousLogger();
   //	private static String pwd = "yhzb";
   
   	static {
   		try {
   			JedisPoolConfig config = new JedisPoolConfig();
   			// 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
   			config.setBlockWhenExhausted(true);
   			// 设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
   			config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
   			// 是否启用pool的jmx管理功能, 默认true
   			config.setJmxEnabled(true);
   			// MBean ObjectName = new
   			// ObjectName("org.apache.commons.pool2:type=GenericObjectPool,name="
   			// + "pool" + i); 默认为"pool", JMX不熟,具体不知道是干啥的...默认就好.
   			config.setJmxNamePrefix("pool");
   			// 是否启用后进先出, 默认true
   			config.setLifo(true);
   			// 最大空闲连接数, 默认8个
   			config.setMaxIdle(8);
   			// 最大连接数, 默认8个
   			config.setMaxTotal(100);
   			// 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,
   			// 默认-1
   			config.setMaxWaitMillis(-1);
   			// 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
   			config.setMinEvictableIdleTimeMillis(1800000);
   			// 最小空闲连接数, 默认0
   			config.setMinIdle(0);
   			// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
   			config.setNumTestsPerEvictionRun(35);
   			// 对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数
   			// 时直接逐出,不再根据MinEvictableIdleTimeMillis判断 (默认逐出策略)
   			config.setSoftMinEvictableIdleTimeMillis(1800000);
   			// 在获取连接的时候检查有效性, 默认false
   			config.setTestOnBorrow(false);
   			// 在空闲时检查有效性, 默认false
   			config.setTestWhileIdle(false);
   			// 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
   			config.setTimeBetweenEvictionRunsMillis(-1);
   			//设置密码连接
   //			jedisPool = new JedisPool(config, addr, port, 3000, pwd);
   			//无密码连接
   			jedisPool = new JedisPool(config, addr, port, 3000);
   
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	
   	/**
   	 * 获取连接
   	 * 
   	 * @author zhy
   	 * @return
   	 */
   	public synchronized static Jedis getJedis() {
           try {
               if (jedisPool != null) {
                   Jedis resource = jedisPool.getResource();
                   return resource;
               } else {
               	log.info("连接池初始化出错");
                   return null;
               }
           } catch (Exception e) {
               e.printStackTrace();
               return null;
           }
       }
   
   	/**
   	 * 关闭连接
   	 * 
   	 * @author zhy
   	 * @param jedis
   	 */
       public static void close(final Jedis jedis) {
           if (jedis != null) {
               jedis.close();
           }
       }
   }

2. redis 功能实现类

   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.Pipeline;
   
   /**
    * 
    * @author zhy
    *
    */
   public class RedisDealUtil {
   	
   	private final static String listName = ":list";
   	
   	private final static String mapName = ":map";
   	
   	private final static int size = 1000;
   	
   	/**
   	 * 倒序初始化数据到redis
   	 * 
   	 * @author zhy
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @return
   	 */
   	public static boolean initListDesc(String key, List<Map<String, Object>> listData, String uniqueColumn) {
   		boolean bool = true;
   		Jedis jedis = null;
   		int listSize = listData.size();
   		try {
   			jedis = RedisConnUtil.getJedis();
   			if(listSize > size) {
   				int num = listSize / size + ((listSize % size) > 0 ? 1 : 0);
   				for (int i = 0; i < num; i++) {
   					addListRightDeal(jedis, listData, uniqueColumn, key, (i * size));
   				}
   			} else {
   				addListRightDeal(jedis, listData, uniqueColumn, key);
   			}
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 升序初始化数据到redis
   	 * 
   	 * @author zhy
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @return
   	 */
   	public static boolean initListAesc(String key, List<Map<String, Object>> listData, String uniqueColumn) {
   		boolean bool = true;
   		Jedis jedis = null;
   		int listSize = listData.size();
   		try {
   			jedis = RedisConnUtil.getJedis();
   			if(listSize > size) {
   				int num = listSize / size + ((listSize % size) > 0 ? 1 : 0);
   				for (int i = 0; i < num; i++) {
   					addListLeftDeal(jedis, listData, uniqueColumn, key, (i * size));
   				}
   			} else {		
   				addListLeftDeal(jedis, listData, uniqueColumn, key);
   			}
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 倒序追加数据到redis
   	 * 
   	 * @author zhy
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @return
   	 */
   	public static boolean appendListDesc(String key, List<Map<String, Object>> listData, String uniqueColumn) {
   		boolean bool = true;
   		Jedis jedis = null;
   		int listSize = listData.size();
   		try {
   			jedis = RedisConnUtil.getJedis();
   			Pipeline pline = jedis.pipelined();
   			for (int i = listSize - 1; i > - 1 ; i--) {
   				Map<String, Object> map = listData.get(i);
   				String uniqueColumnVlue = map.get(uniqueColumn).toString();
   				String value = JSON.toJSONString(map);
   				pline.hset(key+mapName, uniqueColumnVlue, value);
   				pline.rpush(key+listName, uniqueColumnVlue);
   			}
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 升序追加数据到redis
   	 * 
   	 * @author zhy
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @return
   	 */
   	public static boolean appendListAesc(String key, List<Map<String, Object>> listData, String uniqueColumn) {
   		boolean bool = true;
   		Jedis jedis = null;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			addListLeftDeal(jedis, listData, uniqueColumn, key);
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 左侧追加数据到redis
   	 * 
   	 * @author zhy
   	 * @param jedis jedis连接
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @return
   	 */
   	private static void addListLeftDeal(Jedis jedis, List<Map<String, Object>> listData, String uniqueColumn, String key) {
   		try {
   			int listSize = listData.size();
   			Pipeline pline = jedis.pipelined();
   			for (int i = 0; i < listSize ; i++) {
   				Map<String, Object> map = listData.get(i);
   				appendMapLeft(pline, map, uniqueColumn, key);
   			}
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	
   	/**
   	 * 右侧追加数据到redis
   	 * 
   	 * @author zhy
   	 * @param jedis jedis连接
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @param start 循环开始位置
   	 * @return
   	 */
   	private static void addListLeftDeal(Jedis jedis, List<Map<String, Object>> listData, String uniqueColumn, String key, int start) {
   		try {
   			int listSize = listData.size();
   			int numData = listSize - start;
   			numData = numData > size ? size : numData;
   			Pipeline pline = jedis.pipelined();
   			for (int j = 0; j < numData; j++) {
   				Map<String, Object> map = listData.get(start + j);
   				appendMapLeft(pline, map, uniqueColumn, key);
   			}
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	
   	/**
   	 * 右侧追加数据到redis
   	 * 
   	 * @author zhy
   	 * @param jedis jedis连接
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @return
   	 */
   	private static void addListRightDeal(Jedis jedis, List<Map<String, Object>> listData, String uniqueColumn, String key) {
   		try {
   			int listSize = listData.size();
   			Pipeline pline = jedis.pipelined();
   			for (int i = 0; i < listSize ; i++) {
   				Map<String, Object> map = listData.get(i);
   				appendMapRight(pline, map, uniqueColumn, key);
   			}
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	
   	/**
   	 * 右侧追加数据到redis
   	 * 
   	 * @author zhy
   	 * @param jedis jedis连接
   	 * @param key redis存储的键
   	 * @param listData 存储的集合数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @param start 循环开始位置
   	 * @return
   	 */
   	private static void addListRightDeal(Jedis jedis, List<Map<String, Object>> listData, String uniqueColumn, String key, int start) {
   		try {
   			int listSize = listData.size();
   			int numData = listSize - start;
   			numData = numData > size ? size : numData;
   			Pipeline pline = jedis.pipelined();
   			for (int j = 0; j < numData; j++) {
   				Map<String, Object> map = listData.get(start + j);
   				appendMapRight(pline, map, uniqueColumn, key);
   			}
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	
   	/**
   	 * 拼接Map数据到redis List 左侧
   	 * 
   	 * @author zhy
   	 * @param jedis jedis连接
   	 * @param map 添加的map数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @param key redis存储的键
   	 */
   	private static void appendMapLeft(Pipeline pline, Map<String, Object> map, String uniqueColumn, String key) {
   		try {
   			String uniqueColumnVlue = map.get(uniqueColumn).toString();
   			String value = JSON.toJSONString(map);
   			pline.hset(key+mapName, uniqueColumnVlue, value);
   			pline.lpush(key+listName, uniqueColumnVlue);
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	
   	/**
   	 * 拼接Map数据到redis List 左侧
   	 * 
   	 * @author zhy
   	 * @param jedis jedis连接
   	 * @param map 添加的map数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @param key redis存储的键
   	 */
   	private static void appendMapRight(Pipeline pline, Map<String, Object> map, String uniqueColumn, String key) {
   		try {
   			String uniqueColumnVlue = map.get(uniqueColumn).toString();
   			String value = JSON.toJSONString(map);
   			pline.hset(key+mapName, uniqueColumnVlue, value);
   			pline.rpush(key+listName, uniqueColumnVlue);
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	
   	/**
   	 * 往List 追加Map 到左侧
   	 * 
   	 * @author zhy
   	 * @param map 添加的map数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @param key redis存储的键
   	 * @return
   	 */
   	public static boolean appendMapLeft(String key, Map<String, Object> map, String uniqueColumn) {
   		boolean bool = true;
   		Jedis jedis = RedisConnUtil.getJedis();
   		try {
   			Pipeline pline = jedis.pipelined();
   			String uniqueColumnVlue = map.get(uniqueColumn).toString();
   			String value = JSON.toJSONString(map);
   			pline.hset(key+mapName, uniqueColumnVlue, value);
   			pline.lpush(key+listName, uniqueColumnVlue);
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   			bool = false;
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 往List 追加Map 到右侧
   	 * 
   	 * @author zhy
   	 * @param map 添加的map数据
   	 * @param uniqueColumn list唯一不重复值的字段名称
   	 * @param key redis存储的键
   	 * @return
   	 */
   	public static boolean appendMapRight(String key, Map<String, Object> map, String uniqueColumn) {
   		boolean bool = true;
   		Jedis jedis = RedisConnUtil.getJedis();
   		try {
   			Pipeline pline = jedis.pipelined();
   			String uniqueColumnVlue = map.get(uniqueColumn).toString();
   			String value = JSON.toJSONString(map);
   			pline.hset(key+mapName, uniqueColumnVlue, value);
   			pline.rpush(key+listName, uniqueColumnVlue);
   			pline.sync();
   		} catch (Exception e) {
   			e.printStackTrace();
   			bool = false;
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 获取list集合
   	 * 
   	 * @author zhy
   	 * @param key 键名
   	 * @param start 开始位置
   	 * @param end 结束位置
   	 * @return
   	 */
   	public static JSONArray getListByRange(String key, Long start, Long end) {
   		JSONArray jsonArray = null;
   		Jedis jedis = null;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			List<String> list = jedis.lrange(key+listName, start, end);
   			String[] keyArray = list.toArray(new String[list.size()]);
   			jsonArray = JSON.parseArray(JSON.toJSONString(jedis.hmget(key + mapName, keyArray)));
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return jsonArray;
   	}
   	
   	/**
   	 * 获取list集合
   	 * 
   	 * @author zhy
   	 * @param key 键名
   	 * @param pageNum 起始页
   	 * @param pageSize 每页的大小
   	 * @return
   	 */
   	public static JSONArray getListByPage(String key, int pageNum, int pageSize) {
   		JSONArray jsonArray = null;
   		Jedis jedis = null;
   		long start = (pageNum - 1) * pageSize;
   		long end = pageNum * pageSize - 1;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			List<String> list = jedis.lrange(key+listName, start, end);
   			jsonArray = JSON.parseArray(JSON.toJSONString(jedis.hmget(key + mapName, list.toArray(new String[pageSize]))));
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return jsonArray;
   	}
   	
   	/**
   	 * 获取Hash中的值
   	 * 
   	 * @author zhy
   	 * @param key 键名
   	 * @param uniqueColumnValue 存储进来的唯一字段值
   	 * @return
   	 */
   	public static JSON getListHash(String key, String uniqueColumnValue) {
   		JSON json = null;
   		Jedis jedis = null;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			json = JSON.parseObject(jedis.hget(key + mapName, uniqueColumnValue));
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return json;
   	}
   	
   	/**
   	 * 修改数据
   	 * 
   	 * @author zhy
   	 * @param key 键名
   	 * @param uniqueColumnValue 存储进来的唯一字段值
   	 * @param mapData 要更新的数据
   	 * @return
   	 */
   	public static boolean updateList(String key, String uniqueColumnValue, Map<String, Object> mapData) {
   		boolean bool = true;
   		Jedis jedis = null;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			bool = jedis.hset(key + mapName, uniqueColumnValue, JSON.toJSONString(mapData)) > 0 ? false : true;
   		} catch (Exception e) {
   			e.printStackTrace();
   			bool = false;
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 删除字段
   	 * 
   	 * @author zhy
   	 * @param key 键名
   	 * @param uniqueColumnValue 存储进来的唯一字段值
   	 * @return
   	 */
   	public static boolean deleteList(String key, String uniqueColumnValue) {
   		boolean bool = true;
   		Jedis jedis = null;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			jedis.hdel(key + mapName, uniqueColumnValue);
   			jedis.lrem(key + listName, 0, uniqueColumnValue);
   		} catch (Exception e) {
   			e.printStackTrace();
   			bool = false;
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 删除Key
   	 * 
   	 * @author zhy
   	 * @param key 键名
   	 * @return
   	 */
   	public static boolean delKey(String key) {
   		boolean bool = true;
   		Jedis jedis = null;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			jedis.del(key + mapName);
   			jedis.del(key + listName);
   		} catch (Exception e) {
   			e.printStackTrace();
   			bool = false;
   		}
   		RedisConnUtil.close(jedis);
   		return bool;
   	}
   	
   	/**
   	 * 获取list长度
   	 * 
   	 * @author zhy
   	 * @param key 键名
   	 * @return
   	 */
   	public static long getListLen(String key) {
   		long len = 0;
   		Jedis jedis = null;
   		try {
   			jedis = RedisConnUtil.getJedis();
   			len = jedis.llen(key + listName);
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		RedisConnUtil.close(jedis);
   		return len;
   	}
   }
   

   
   
3. redis测试类

   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   
   import priv.zhouhuayi.packing.util.RedisDealUtil;
   
   public class RedisTest {
   	private static String key = "testKey";
   	
   	private static String uniqueColumn = "id";
   	
   	
   	public static void main(String[] args) {
   		initListAesc();
   		appendMapLeft();
   		getListByPage(1, 3);
   		appendListAesc();
   		getListByPage(1, 3);
   		
   		initListDesc();
   		appendMapRight();
   		long end = getListLen();
   		System.out.println(end);
   		getListByRange(end - 3, end);
   		appendListDesc();
   		getListByRange(end - 3, end + 1);
   		
   		update();
   		find();
   		
   		delList();
   		find();
   		end = getListLen();
   		System.out.println(end);
   		getListByRange(end - 3, end);
   	}
   	
   	private static void initListAesc() {
   		RedisDealUtil.delKey(key);
   		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
   		
   		for (int i = 1; i < 3001; i++) {
   			Map<String, Object> map = new HashMap<String, Object>();
   			map.put(uniqueColumn, i);
   			map.put("name", "用户"+i);
   			listMap.add(map);
   		}
   		RedisDealUtil.initListAesc(key, listMap, uniqueColumn);
   	}
   	
   	private static void appendListAesc() {
   		List<Map<String, Object>> listData = new ArrayList<Map<String, Object>>();
   		Map<String, Object> map = new HashMap<String, Object>();
   		map.put(uniqueColumn, "3002");
   		map.put("name", "追加list");
   		listData.add(map);
   		RedisDealUtil.appendListAesc(key, listData, uniqueColumn);
   	}
   	
   	private static void appendMapLeft() {
   		Map<String, Object> map = new HashMap<String, Object>();
   		map.put(uniqueColumn, 3001);
   		map.put("name", "用户3001");
   		RedisDealUtil.appendMapLeft(key, map, uniqueColumn);
   	}
   	
   	private static void initListDesc() {
   		RedisDealUtil.delKey(key);
   		List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
   		
   		for (int i = 1; i < 3001; i++) {
   			Map<String, Object> map = new HashMap<String, Object>();
   			map.put(uniqueColumn, i);
   			map.put("name", "用户"+i);
   			listMap.add(map);
   		}
   		
   		RedisDealUtil.initListDesc(key, listMap, uniqueColumn);
   	}
   	
   	private static void appendListDesc() {
   		List<Map<String, Object>> listData = new ArrayList<Map<String, Object>>();
   		Map<String, Object> map = new HashMap<String, Object>();
   		map.put(uniqueColumn, "3002");
   		map.put("name", "追加list");
   		listData.add(map);
   		RedisDealUtil.appendListDesc(key, listData, uniqueColumn);
   	}
   	
   	private static void appendMapRight() {
   		Map<String, Object> map = new HashMap<String, Object>();
   		map.put(uniqueColumn, 3001);
   		map.put("name", "用户3001");
   		RedisDealUtil.appendMapRight(key, map, uniqueColumn);
   	}
   	
   	private static void update() {
   		Map<String, Object> map = new HashMap<String, Object>();
   		map.put(uniqueColumn, 3001);
   		map.put("name", "用户你好");
   		RedisDealUtil.updateList(key, "3001", map);
   	}
   	
   	private static void delList() {
   		RedisDealUtil.deleteList(key, "3001");
   	}
   	
   	private static void find() {
   		System.out.println(RedisDealUtil.getListHash(key, "3001"));
   	}
   	
   	private static void getListByPage(int pageNum, int pageSize) {
   		System.out.println(RedisDealUtil.getListByPage(key, pageNum, pageSize));
   	}
   	
   	private static void getListByRange(long start, long end) {
   		System.out.println(RedisDealUtil.getListByRange(key, start, end));
   	}
   	
   	private static long getListLen() {
   		return RedisDealUtil.getListLen(key);
   	}
   	
   }