Redis(2)---数据操作

我的第一篇redis Redis(1)

使用sping的RedisTemplate去操作Redis数据

1.操作字符串

private static ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring-context-jedis.xml");
	//RedisTemplate操作redis常用命令——字符串
	@Test
	public void testRedisString()
	{
		RedisTemplate redisTemplate= applicationContext.getBean(RedisTemplate.class);
	//  出现乱码修改序列化策略，我已在xml配置文件中修改
	//	RedisSerializer<String> stringSerializer = new StringRedisSerializer();
	//	redisTemplate.setKeySerializer(stringSerializer); 
	//	redisTemplate.setValueSerializer(stringSerializer); 
	//	redisTemplate.setHashKeySerializer(stringSerializer); 
	//	redisTemplate.setHashValueSerializer(stringSerializer);
		
      //设置值
		redisTemplate.opsForValue().set("key1",	"value1");
		redisTemplate.opsForValue().set("key2", "value2");
		
	  //通过key获取值
		String value1=(String) redisTemplate.opsForValue().get("key1");
		System.out.println("value1:"+value1);
		//求长度
		Long size=redisTemplate.opsForValue().size("key2");
		System.out.println("size:"+size);
		//修改值 返回旧值
		String oldvalue1=(String) redisTemplate.opsForValue().getAndSet("key1","newvalue1");
		System.out.println("oldvalue1:"+oldvalue1);
		
		//查看修改成功没
		String newvalue1=(String) redisTemplate.opsForValue().get("key1");
		System.out.println("newvalue1:"+newvalue1);
		
		//求字符串
		String rangevaue1=redisTemplate.opsForValue().get("key1", 0, 3);
		System.out.println("rangevaue1:"+rangevaue1);
	
	}

运行结果：

2.操作HASH
在Redis中，hash是一个String类型的field和value的映射表。与字符串不同的是，hash多了一个层级的概念field。它包含一个key->通过key找到此key下的所有field->再通过field->得到value值 具体看下面的例子很好理解。

//RedisTemplate操作redis常用命令——哈希
	@Test
	public void testRedisHash()
	{
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		String key1="hash1",key2="hash2";
		Map<String,String> map = new HashMap<>();
		map.put("f1","val1");
		map.put("f2","val2");
		
		redisTemplate.opsForHash().putAll(key1, map);
		printValueForHash(redisTemplate,key1,"f1");
		printValueForHash(redisTemplate,key1,"f2");
		redisTemplate.opsForHash().put(key1,"f3", "6");
		redisTemplate.opsForHash().put(key2,"f3", "6");
		printValueForHash(redisTemplate,key1,"f3");
		
		//hasKey()判断是否包含存在此filed字段
		boolean isexists = redisTemplate.opsForHash().hasKey(key2, "f3");
		System.out.println("isexists:"+isexists);
		
		//entries()方法通过传入key值查找次key值下的所有map集合
		Map<String,String> keyValueMap = redisTemplate.opsForHash().entries(key1);
		for(Map.Entry<String, String> mapenty:keyValueMap.entrySet())
		{
			System.out.println("key:"+mapenty.getKey()+"  value:"+mapenty.getValue());
		}
		
		//values()方法通过传入key值查找此key值下的所有value
		List<String> list=redisTemplate.opsForHash().values(key1);
		for(String str:list)
		{
			System.out.println(str+" ---");
		}
		
		//multiGet()方法通过传入key集合查找value值
		List<String> fieldList = new ArrayList<>();
		fieldList.add("f1");
		fieldList.add("f2");
		List<String> listValue = redisTemplate.opsForHash().multiGet(key1, fieldList);
		for(String str:listValue)
		{
			System.out.println(str+" *** ");
		}
		
		//delete()方法可以传入任意数量的fileddelete(key1,"f1","f2","f3"...)
		Long result=redisTemplate.opsForHash().delete(key1,"f1","f2");
		System.out.println(result);
		
	}
	
	public static void printValueForHash(RedisTemplate redisTemplate,Object key,String field)
	{
		Object object=redisTemplate.opsForHash().get(key,field);
		System.out.println(object);
	}

运行结果：

3.操作链表
redis中的链表结构是有序的，而且是双向，即可从左到右，也可从右到左操作，都知道链表查询性能不佳，如果这个链表很大，要慎用。

// RedisTemplate操作redis常用命令——链表
	@Test
	public void testRedisLinkList() {

		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		// 删除整个list 方便反复测试
		redisTemplate.delete("list");
		// 从左边插入node1
		redisTemplate.opsForList().leftPush("list", "node1");

		// 依次从左边插入node2，node3
		List<String> nodeList = new ArrayList<>();
		for (int i = 2; i < 4; i++) {
			nodeList.add("node" + i);
		}
		redisTemplate.opsForList().leftPushAll("list", nodeList);
		
		// 依次从右边插入node4
		redisTemplate.opsForList().rightPush("list", "node4");
		// range方法得到下标从 x->x的value值 这里是整个长度
		List<String> valueList3 = redisTemplate.opsForList().range("list", 0, redisTemplate.opsForList().size("list"));
		System.out.println(valueList3 + "  ***");

		// 得到下标为0的节点
		String node1 = (String) redisTemplate.opsForList().index("list", 0);
		System.out.println("0下标对应的值为:" + node1);

		// 长度
		long size = redisTemplate.opsForList().size("list");
		System.out.println("size:" + size);
		
		// 弹出左边第一个元素，意思是删除左边第一个元素
		String left = (String) redisTemplate.opsForList().leftPop("list");
		System.out.println("left:" + left);
		// 同理右边
		String rigth = (String) redisTemplate.opsForList().rightPop("list");
		System.out.println("right:" + rigth);
		
		// 注意：需要使用更为底层的命令才能实现在节点前后插入一个节点
		try {
			redisTemplate.getConnectionFactory().getConnection().lInsert("list".getBytes("utf-8"),
					RedisListCommands.Position.BEFORE, "node2".getBytes("utf-8"), // 从前面插入将BEFORE改为AFTER即可
					"通过Before插入node".getBytes("utf-8"));
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		// 判断lit是否存在，如果存在就从左边插入节点
		redisTemplate.opsForList().leftPushIfPresent("list", "head");
		redisTemplate.opsForList().rightPushIfPresent("list", "end");

		List<String> valueList = redisTemplate.opsForList().range("list", 0, redisTemplate.opsForList().size("list"));
		System.out.println(valueList + "  ---");
		// 给下标为0的设置新值
		redisTemplate.opsForList().set("list", 0, "newhead");

		List<String> valueList2 = redisTemplate.opsForList().range("list", 0, redisTemplate.opsForList().size("list"));

		System.out.println(valueList2 + "  ---");

	}

运行结果：

4.操作集合
redis的集合不是一个线性结构，而是一个哈希结构，所以对于插，删，查找复杂度都是O(1)所以需要注意以下3点
(1).对于集合而言，它的每一个元素都是不可重复的，当插入相同记录会失败。
(2),集合是无序的。
(3).集合的每一个元素都是String数据结构类型

	@Test
	public void testRedisSet()
	{
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		
		//将元素加入列表
		redisTemplate.boundSetOps("set1").add("v1","v2","v3","v4","v5","v6");
		redisTemplate.boundSetOps("set2").add("v0","v2","v4","v6","v8");
		
		//求集合长度
		long size = redisTemplate.opsForSet().size("set1");
		System.out.println("size:"+size);
		
		//求差集
		Set<String> set = redisTemplate.opsForSet().difference("set1", "set2");
		
			System.out.println(set+" 差集");
		
		
		//求交集
		Set<String> set2 = redisTemplate.opsForSet().intersect("set1", "set2");
		
			System.out.println(set2+" 交集");
		
		//求并集
		Set<String> set3 = redisTemplate.opsForSet().union("set1", "set2");
			System.out.println(set3+" 并集");
		
		//判断是否存在
		boolean exists = redisTemplate.opsForSet().isMember("set1","v1");
		System.out.println("exists:"+exists);
		
		//获取集合所有元素
		Set<String> set4 = redisTemplate.opsForSet().members("set1");
		System.out.println("所有元素："+set4);
		
		//随机弹出一个元素
		String val=(String) redisTemplate.opsForSet().pop("set1");
		System.out.println("随机弹出:"+val);
		Set<String> set5 = redisTemplate.opsForSet().members("set1");
		System.out.println("弹出后剩余："+set5);
		
		//随机获取一个元素
		String ranVal = (String) redisTemplate.opsForSet().randomMember("set1");
		System.out.println("随机获取:"+ranVal);
		
		//随机获取多个个元素
	    List<String> listVal = redisTemplate.opsForSet().randomMembers("set1",2);
		System.out.println("随机获取两个"+listVal);
		 
		 //删除一个集合的元素，参数可以多个
		 redisTemplate.opsForSet().remove("set1", "v1","v2");
		 Set<String> set6 = redisTemplate.opsForSet().members("set1");
		 System.out.println("删除后："+set6);
		 
		 //求两个集合的差集，并保存到集合test中   并集，交集同理
		 redisTemplate.opsForSet().differenceAndStore("set1", "set2", "test");
		 System.out.println();
	}

运行结果：