Redis数据结构常用命令

XML配置

<?xml version=‘1.0‘ encoding=‘UTF-8‘ ?>
<!-- was: <?xml version="1.0" encoding="UTF-8"?> -->
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	   http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="50" />
		<property name="maxTotal" value="100" />
		<property name="maxWaitMillis" value="20000" />
	</bean>

	<bean id="stringRedisSerializer"
		class="org.springframework.data.redis.serializer.StringRedisSerializer" />

	<bean id="connectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="hostName" value="localhost" />
		<property name="port" value="6379" />
		<property name="poolConfig" ref="poolConfig" />
	</bean>

	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="defaultSerializer" ref="stringRedisSerializer" />
		<property name="keySerializer" ref="stringRedisSerializer" />
		<property name="valueSerializer" ref="stringRedisSerializer" />
	</bean>

</beans>

　　测试：

public class Chapter18Main {

	public static void main(String[] args) {
		testString();
		testCal();
		testRedisHash();
		testList();
		testBList();
		testSet();
		testZset();
		testHyperLogLog();
	}

	public static void testString() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		// 设值
		redisTemplate.opsForValue().set("key1", "value1");
		redisTemplate.opsForValue().set("key2", "value2");
		// 通过key获取值
		String value1 = (String) redisTemplate.opsForValue().get("key1");
		System.out.println(value1);
		// 通过key删除值
		redisTemplate.delete("key1");
		// 求长度
		Long length = redisTemplate.opsForValue().size("key2");
		System.out.println(length);
		// 设值新值并返回旧值
		String oldValue2 = (String) redisTemplate.opsForValue().getAndSet("key2", "new_value2");
		System.out.println(oldValue2);
		// 通过key获取值.
		String value2 = (String) redisTemplate.opsForValue().get("key2");
		System.out.println(value2);
		// 求子串
		String rangeValue2 = redisTemplate.opsForValue().get("key2", 0, 3);
		System.out.println(rangeValue2);
		// 追加字符串到末尾，返回新串长度
		int newLen = redisTemplate.opsForValue().append("key2", "_app");
		System.out.println(newLen);
		String appendValue2 = (String) redisTemplate.opsForValue().get("key2");
		System.out.println(appendValue2);
	}

	/**
	 * 测试Redis运算.
	 */
	public static void testCal() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		redisTemplate.opsForValue().set("i", "9");
		printCurrValue(redisTemplate, "i");
		redisTemplate.opsForValue().increment("i", 1);
		printCurrValue(redisTemplate, "i");
		redisTemplate.getConnectionFactory().getConnection().decr(redisTemplate.getKeySerializer().serialize("i"));
		printCurrValue(redisTemplate, "i");
		redisTemplate.getConnectionFactory().getConnection().decrBy(redisTemplate.getKeySerializer().serialize("i"), 6);
		printCurrValue(redisTemplate, "i");
		redisTemplate.opsForValue().increment("i", 2.3);
		printCurrValue(redisTemplate, "i");
	}

	/**
	 * 打印当前key的值
	 *
	 * @param redisTemplate
	 *            spring RedisTemplate
	 * @param key键
	 */
	public static void printCurrValue(RedisTemplate redisTemplate, String key) {
		String i = (String) redisTemplate.opsForValue().get(key);
		System.err.println(i);
	}

	public static void testRedisHash() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		String key = "hash";
		Map<String, String> map = new HashMap<String, String>();
		map.put("f1", "val1");
		map.put("f2", "val2");
		// 相当于hmset命令
		redisTemplate.opsForHash().putAll(key, map);
		// 相当于hset命令
		redisTemplate.opsForHash().put(key, "f3", "6");
		printValueForhash(redisTemplate, key, "f3");
		// 相当于 hexists key filed命令
		boolean exists = redisTemplate.opsForHash().hasKey(key, "f3");
		System.out.println(exists);
		// 相当于hgetall命令
		Map keyValMap = redisTemplate.opsForHash().entries(key);
		// 相当于hincrby命令
		redisTemplate.opsForHash().increment(key, "f3", 2);
		printValueForhash(redisTemplate, key, "f3");
		// 相当于hincrbyfloat命令
		redisTemplate.opsForHash().increment(key, "f3", 0.88);
		printValueForhash(redisTemplate, key, "f3");
		// 相当于hvals命令
		List valueList = redisTemplate.opsForHash().values(key);
		// 相当于hkeys命令
		Set keyList = redisTemplate.opsForHash().keys(key);
		List<String> fieldList = new ArrayList<String>();
		fieldList.add("f1");
		fieldList.add("f2");
		// 相当于hmget命令
		List valueList2 = redisTemplate.opsForHash().multiGet(key, keyList);
		// 相当于hsetnx命令
		boolean success = redisTemplate.opsForHash().putIfAbsent(key, "f4", "val4");
		System.out.println(success);
		// 相当于hdel命令
		Long result = redisTemplate.opsForHash().delete(key, "f1", "f2");
		System.out.println(result);
	}

	private static void printValueForhash(RedisTemplate redisTemplate, String key, String field) {
		// 相当于hget命令
		Object value = redisTemplate.opsForHash().get(key, field);
		System.out.println(value);
	}

	public static void testList() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		try {
			// 删除链表，以便我们可以反复测试
			redisTemplate.delete("list");
			// 把node3插入链表list
			redisTemplate.opsForList().leftPush("list", "node3");
			List<String> nodeList = new ArrayList<String>();
			for (int i = 2; i >= 1; i--) {
				nodeList.add("node" + i);
			}
			// 相当于lpush把多个价值从左插入链表
			redisTemplate.opsForList().leftPushAll("list", nodeList);
			// 从右边插入一个节点
			redisTemplate.opsForList().rightPush("list", "node4");
			// 获取下标为0的节点
			String node1 = (String) redisTemplate.opsForList().index("list", 0);
			// 获取链表长度
			long size = redisTemplate.opsForList().size("list");
			// 从左边弹出一个节点
			String lpop = (String) redisTemplate.opsForList().leftPop("list");
			// 从右边弹出一个节点
			String rpop = (String) redisTemplate.opsForList().rightPop("list");
			// 注意，需要使用更为底层的命令才能操作linsert命令
			// 使用linsert命令在node2前插入一个节点
			redisTemplate.getConnectionFactory().getConnection().lInsert("list".getBytes("utf-8"),
					RedisListCommands.Position.BEFORE, "node2".getBytes("utf-8"), "before_node".getBytes("utf-8"));
			// 使用linsert命令在node2后插入一个节点
			redisTemplate.getConnectionFactory().getConnection().lInsert("list".getBytes("utf-8"),
					RedisListCommands.Position.AFTER, "node2".getBytes("utf-8"), "after_node".getBytes("utf-8"));
			// 判断list是否存在，如果存在则从左边插入head节点
			redisTemplate.opsForList().leftPushIfPresent("list", "head");
			// 判断list是否存在，如果存在则从右边插入end节点
			redisTemplate.opsForList().rightPushIfPresent("list", "end");
			// 从左到右，或者下标从0到10的节点元素
			List valueList = redisTemplate.opsForList().range("list", 0, 10);
			nodeList.clear();
			for (int i = 1; i <= 3; i++) {
				nodeList.add("node");
			}
			// 在链表左边插入三个值为node的节点
			redisTemplate.opsForList().leftPushAll("list", nodeList);
			// 从左到右删除至多三个node节点
			redisTemplate.opsForList().remove("list", 3, "node");
			// 给链表下标为0的节点设置新值
			redisTemplate.opsForList().set("list", 0, "new_head_value");
		} catch (UnsupportedEncodingException ex) {
			ex.printStackTrace();
		}
		// 打印链表数据
		printList(redisTemplate, "list");
	}

	public static void printList(RedisTemplate redisTemplate, String key) {
		// 链表长度
		Long size = redisTemplate.opsForList().size(key);
		// 获取整个链表的值
		List valueList = redisTemplate.opsForList().range(key, 0, size);
		// 打印
		System.out.println(valueList);
	}

	public static void testBList() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		// 清空数据，可以重复测试
		redisTemplate.delete("list1");
		redisTemplate.delete("list2");
		// 初始化链表list1
		List<String> nodeList = new ArrayList<String>();
		for (int i = 1; i <= 5; i++) {
			nodeList.add("node" + i);
		}
		redisTemplate.opsForList().leftPushAll("list1", nodeList);
		// Spring使用参数超时时间作为阻塞命令区分，等价于blpop命令，并且可以设置时间参数
		redisTemplate.opsForList().leftPop("list1", 1, TimeUnit.SECONDS);
		// Spring使用参数超时时间作为阻塞命令区分，等价于brpop命令，并且可以设置时间参数
		redisTemplate.opsForList().rightPop("list1", 1, TimeUnit.SECONDS);
		nodeList.clear();
		// 初始化链表list2
		for (int i = 1; i <= 3; i++) {
			nodeList.add("data" + i);
		}
		redisTemplate.opsForList().leftPushAll("list2", nodeList);
		// 相当于rpoplpush命令，弹出list1最右边的节点，插入到list2最左边
		redisTemplate.opsForList().rightPopAndLeftPush("list1", "list2");
		// 相当于brpoplpush命令，注意在Spring中使用超时参数区分
		redisTemplate.opsForList().rightPopAndLeftPush("list1", "list2", 1, TimeUnit.SECONDS);
		// 打印链表数据
		printList(redisTemplate, "list1");
		printList(redisTemplate, "list2");
	}

	public static void testSet() {
		// 请把RedisTemplate值序列化器设置为StringRedisSerializer测试该代码片段
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		Set set = null;
		// 将元素加入列表
		redisTemplate.boundSetOps("set1").add("v1", "v2", "v3", "v4", "v5", "v6");
		redisTemplate.boundSetOps("set2").add("v0", "v2", "v4", "v6", "v8");
		// 求集合长度
		redisTemplate.opsForSet().size("set1");
		// 求差集
		set = redisTemplate.opsForSet().difference("set1", "set2");
		// 求并集
		set = redisTemplate.opsForSet().intersect("set1", "set2");
		// 判断是否集合中的元素
		boolean exists = redisTemplate.opsForSet().isMember("set1", "v1");
		// 获取集合所有元素
		set = redisTemplate.opsForSet().members("set1");
		// 从集合中随机弹出一个元素
		String val = (String) redisTemplate.opsForSet().pop("set1");
		// 随机获取一个集合的元素
		val = (String) redisTemplate.opsForSet().randomMember("set1");
		// 随机获取2个集合的元素
		List list = redisTemplate.opsForSet().randomMembers("set1", 2L);
		// 删除一个集合的元素，参数可以是多个
		redisTemplate.opsForSet().remove("set1", "v1");
		// 求两个集合的并集
		redisTemplate.opsForSet().union("set1", "set2");
		// 求两个集合的差集，并保存到集合diff_set中
		redisTemplate.opsForSet().differenceAndStore("set1", "set2", "diff_set");
		// 求两个集合的交集，并保存到集合inter_set中
		redisTemplate.opsForSet().intersectAndStore("set1", "set2", "inter_set");
		// 求两个集合的并集，并保存到集合union_set中
		redisTemplate.opsForSet().unionAndStore("set1", "set2", "union_set");
	}

	public static void testZset() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		// Spring提供接口TypedTuple操作有序集合
		Set<TypedTuple> set1 = new HashSet<TypedTuple>();
		Set<TypedTuple> set2 = new HashSet<TypedTuple>();
		int j = 9;
		for (int i = 1; i <= 9; i++) {
			j--;
			// 计算分数和值
			Double score1 = Double.valueOf(i);
			String value1 = "x" + i;
			Double score2 = Double.valueOf(j);
			String value2 = j % 2 == 1 ? "y" + j : "x" + j;
			// 使用Spring提供的默认TypedTuple——DefaultTypedTuple
			TypedTuple typedTuple1 = new DefaultTypedTuple(value1, score1);
			set1.add(typedTuple1);
			TypedTuple typedTuple2 = new DefaultTypedTuple(value2, score2);
			set2.add(typedTuple2);
		}
		// 将元素插入有序集合zset1
		redisTemplate.opsForZSet().add("zset1", set1);
		redisTemplate.opsForZSet().add("zset2", set2);
		// 统计总数
		Long size = null;
		size = redisTemplate.opsForZSet().zCard("zset1");
		// 计分数为score，那么下面的方法就是求3<=score<=6的元素
		size = redisTemplate.opsForZSet().count("zset1", 3, 6);
		Set set = null;
		// 从下标一开始截取5个元素，但是不返回分数,每一个元素是String
		set = redisTemplate.opsForZSet().range("zset1", 1, 5);
		printSet(set);
		// 截取集合所有元素，并且对集合按分数排序，并返回分数,每一个元素是TypedTuple
		set = redisTemplate.opsForZSet().rangeWithScores("zset1", 0, -1);
		printTypedTuple(set);
		// 将zset1和zset2两个集合的交集放入集合inter_zset
		size = redisTemplate.opsForZSet().intersectAndStore("zset1", "zset2", "inter_zset");
		// 区间
		Range range = Range.range();
		range.lt("x8");// 小于
		range.gt("x1");// 大于
		set = redisTemplate.opsForZSet().rangeByLex("zset1", range);
		printSet(set);
		range.lte("x8");// 小于等于
		range.gte("x1");// 大于等于
		set = redisTemplate.opsForZSet().rangeByLex("zset1", range);
		printSet(set);
		// 限制返回个数
		Limit limit = Limit.limit();
		// 限制返回个数
		limit.count(4);
		// 限制从第五个开始截取
		limit.offset(5);
		// 求区间内的元素，并限制返回4条
		set = redisTemplate.opsForZSet().rangeByLex("zset1", range, limit);
		printSet(set);
		// 求排行，排名第1返回0，第2返回1
		Long rank = redisTemplate.opsForZSet().rank("zset1", "x4");
		System.err.println("rank = " + rank);
		// 删除元素，返回删除个数
		size = redisTemplate.opsForZSet().remove("zset1", "x5", "x6");
		System.err.println("delete = " + size);
		// 按照排行删除从0开始算起，这里将删除第排名第2和第3的元素
		size = redisTemplate.opsForZSet().removeRange("zset2", 1, 2);
		// 获取所有集合的元素和分数，以-1代表全部元素
		set = redisTemplate.opsForZSet().rangeWithScores("zset2", 0, -1);
		printTypedTuple(set);
		// 删除指定的元素
		size = redisTemplate.opsForZSet().remove("zset2", "y5", "y3");
		System.err.println(size);
		// 给集合中的一个元素的分数加上11
		Double dbl = redisTemplate.opsForZSet().incrementScore("zset1", "x1", 11);
		redisTemplate.opsForZSet().removeRangeByScore("zset1", 1, 2);
		set = redisTemplate.opsForZSet().reverseRangeWithScores("zset2", 1, 10);
		printTypedTuple(set);
	}

	/**
	 * 打印TypedTuple集合
	 *
	 * @param set
	 *            -- Set<TypedTuple>
	 */
	public static void printTypedTuple(Set<TypedTuple> set) {
		if (set != null && set.isEmpty()) {
			return;
		}
		Iterator iterator = set.iterator();
		while (iterator.hasNext()) {
			TypedTuple val = (TypedTuple) iterator.next();
			System.err.print("{value = " + val.getValue() + ", score = " + val.getScore() + "}\n");
		}
	}

	/**
	 * 打印普通集合
	 *
	 * @param set普通集合
	 */
	public static void printSet(Set set) {
		if (set != null && set.isEmpty()) {
			return;
		}
		Iterator iterator = set.iterator();
		while (iterator.hasNext()) {
			Object val = iterator.next();
			System.out.print(val + "\t");
		}
		System.out.println();
	}

	public static void testHyperLogLog() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);
		redisTemplate.opsForHyperLogLog().add("HyperLogLog", "a", "b", "c", "d", "a");
		redisTemplate.opsForHyperLogLog().add("HyperLogLog2", "a");
		redisTemplate.opsForHyperLogLog().add("HyperLogLog2", "z");
		Long size = redisTemplate.opsForHyperLogLog().size("HyperLogLog");
		System.err.println(size);
		size = redisTemplate.opsForHyperLogLog().size("HyperLogLog2");
		System.err.println(size);
		redisTemplate.opsForHyperLogLog().union("des_key", "HyperLogLog", "HyperLogLog2");
		size = redisTemplate.opsForHyperLogLog().size("des_key");
		System.err.println(size);
	}
}

　　

原文地址：https://www.cnblogs.com/daxiong225/p/9977456.html

时间： 2024-10-29 04:29:19

Redis数据结构常用命令的相关文章

Linux下安装redis以及常用命令

1.获取redis资源 wget http://download.redis.io/releases/redis-4.0.8.tar.gz 2.解压 tar xzvf redis-4.0.8.tar.gz 3.安装 cd redis-4.0.8 make cd src make install PREFIX=/usr/local/redis 4.移动配置文件到安装目录下 cd ../ mkdir /usr/local/redis/etc mv redis.conf /usr/local/redi

Jedis对Redis的常用命令操作

本篇主要总结一些Jedis对Redis的常用命令操作: 1.对key操作命令 2.对String操作命令 3.对List操作命令 4.对Set操作命令 5.对Hash操作命令 6.排序操作指令 一.项目中添加redis和junit的依赖. <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</ver

redis 操作常用命令

首先看一下redis操作常用的命令: exists key 测试制定的key是否存在 del key1 key2 .... keyn   删除制定的key type key 查看key的类型 keys pattern  返回匹配制定模式的所有的key raname oldkey newkey  修改key的名称 dbsize  查看当前数据库的key的数量 exprie key  seconds   为key指定过期时间 ttl  key  查看key的过期时间 select db-index

Redis(2):常用命令详解

redis命令不区分大小写 通用命令:1. 获得符合规则的键名列表: keys pattern   其中pattern符合glob风格  ? (一个字符) * (任意个字符) [] (匹配其中的任意一个字符)  \x (转义字符) 需要注意的是keys命令会遍历redis中的所有键,如果键比较多,会影响性能 keys *  会列出当前库中的所有键, 注意这个列出的不仅仅是string类型的,其他所有类型的key都包括(即使是hash类型的). 127.0.0.1:6379> HSET hashk

05_NoSQL数据库之Redis数据库：Redis的常用命令，键值相关命令和服务器相关命令

 Redis常用命令 Redis提供了丰富的命令对数据库和各种数据库类型进行操作,这些命令可以再Linux终端使用. 键值相关命令: Keys:返回满足给定pattern的所有key 用表达式*表示取出所有的key 127.0.0.1:6379> keys * 1) "age" 2) "name" 3) "age2" 127.0.0.1:6379> keys a* 1) "age" 2) "age2&

Redis 的常用命令

Redis 的数据类型 一些命令需要结合 redis 的数据类型来说. Redis 4.0 之前有5种数据类型,分别是:字符串(string).散列(hash).列表(list).集合(set).有序集合(zset). 在 4.0 版本,Redis 新加了一种 stream 的类型.暂且先不说,以后会新开文章具体讲解. 基本知识: 数据类型不支持嵌套,即所有的类型的元素只能是字符串,不能是散列和集合或者有序集合. 除了字符串之外,每种数据类型的命令都有一个开头. 散列(h) 列表(l) 集合(s

Redis之-常用命令

格式比较乱,主要是为了记录平时的一些操作,学习过程:1,查看数量127.0.0.1:6379> dbsize(integer) 62,手动重写aof文件127.0.0.1:6379> bgrewriteaofBackground append only file rewriting started3,保存aof日志,这个命令会阻塞其他操作,建议使用bgsave127.0.0.1:6379> saveOK4,查看上一次保存的时间127.0.0.1:6379> lastsave(int

redis的常用命令

键值得相关命令: keys * 返回满足给定patternd的所有key exists 确认一个key是否存在 del 删除一个key expire 设置一个key的过期时间 ttl 查看过期时间还有多久 move 将当前键移动到另一个数据库 select 选择数据库 默认一共16个数据库0到15,进客户端时,默认是0数据库 persist 移除给定key的过期时间 randomkey 随机返回key空间的一个key rename 重命名key type 返回key的数据类型 与服务器相关的命令

Redis中常用命令

连接操作相关的命令 quit:关闭连接(connection) auth:简单密码认证 持久化 save:将数据同步保存到磁盘 bgsave:将数据异步保存到磁盘 lastsave:返回上次成功将数据保存到磁盘的Unix时戳 shundown:将数据同步保存到磁盘,然后关闭服务 远程服务控制 info:提供服务器的信息和统计 monitor:实时转储收到的请求 slaveof:改变复制策略设置 config:在运行时配置Redis服务器 对value操作的命令 exists(key):确认一个k