Java操作Redis数据

最新推荐文章于 2024-07-05 10:14:45 发布
最新推荐文章于 2024-07-05 10:14:45 发布
阅读量2.8w 收藏 5
点赞数 2
分类专栏： NoSQL Redis 文章标签： redis spring-data-redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/limingjian/article/details/42586619
版权
NoSQL 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
Redis
2 篇文章 0 订阅
订阅专栏

       Redis 是完全开源免费的，遵守BSD协议，先进的key - value持久化产品。它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。下面是使用spring-data-redis分别针对key和value的操作。


1.Key（键）

public class KeysTest extends RedisCommon {
	private static StringRedisTemplate template;
	private static String key = "key1";

	public static void main(String[] args) {
		log.info("-----------Starting Redis keys testing-----------");
		ApplicationContext ctx = SpringApplication.run(KeysTest.class, args);
		template = ctx.getBean(StringRedisTemplate.class);
		KeysTest keysTest = ctx.getBean(KeysTest.class);
		keysTest.initValue();

		log.info("KeysTest @##@ randomKey: " + template.randomKey());

		keysTest.expireKey(key, 2);
		// keysTest.persistKey(key, 2);

		String newkey = "newKey";
		// template.rename(key, newkey);
		template.renameIfAbsent(key, newkey);

		Set<String> keys = template.keys("*");
		log.info("KeysTest @##@ keys:" + keys);
		for (String key : keys) {
			log.info("KeysTest @##@ " + key + " expire:"
					+ template.getExpire(key));
			// template.getExpire(key, TimeUnit.SECONDS);
		}

		int dbIndex = 1;// ref:http://redisdoc.com/key/move.html
		log.info("KeysTest @##@ move " + key + " to db" + dbIndex + ": "
				+ template.move(key, 1));

		// template.delete(key);
		template.delete(keys);
		log.info("KeysTest @##@ delete keys: " + keys);

		// template.exec();
		// template.multi();
		// template.discard();

		// template.slaveOf(host, port);
		// template.slaveOfNoOne();

		// template.watch(key);
		// template.watch(keys);
		// template.unwatch();
		log.info("-----------End Redis keys testing-----------");
	}

	public void initValue() {
		String value = "hello,redis";
		template.opsForValue().set(key, value);
		Set<String> keys = new HashSet<String>() {
			private static final long serialVersionUID = -4402948387930279259L;
			{
				this.add("key2");
				this.add("key3");
				this.add("key4");
			}
		};
		try {
			byte[] bytes = template.dump(key);
			log.info("KeysTest # key dump:" + new String(bytes));
			for (String k : keys) {
				template.restore(k, bytes, 0, TimeUnit.SECONDS);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public boolean expireKey(String key, long expiretime) {
		log.info("KeysTest @##@ has " + key + " : " + template.hasKey(key));
		log.info("KeysTest @##@ expire " + key + " for " + expiretime
				+ " seconds : "
				+ template.expire(key, expiretime, TimeUnit.SECONDS));
		// template.expireAt(key, new Date());
		try {
			Thread.sleep((expiretime + 1) * 1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		boolean result = template.hasKey(key);
		log.info("KeysTest @##@ has " + key + " : " + result);
		return result;
	}

	public boolean persistKey(String key, long expiretime) {
		log.info("KeysTest @##@ has " + key + " : " + template.hasKey(key));
		log.info("KeysTest @##@ expire " + key + " for " + expiretime
				+ " seconds : "
				+ template.expire(key, expiretime, TimeUnit.SECONDS));
		log.info("KeysTest @##@ persist " + key + " : " + template.persist(key));
		try {
			Thread.sleep((expiretime + 1) * 1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return template.hasKey(key);
	}

}

2.String（字符串）

public class StringsTest extends RedisCommon {
	private static StringRedisTemplate template;
	private static String key = "strKey";
	
	public static void main(String[] args) throws InterruptedException {
		log.info("-----------Starting Redis Strings testing-----------");
		ApplicationContext ctx = SpringApplication.run(StringsTest.class, args);
		template = ctx.getBean(StringRedisTemplate.class);
		StringsTest stringsTest = ctx.getBean(StringsTest.class);
		
		String value = "hello, redis";
		template.opsForValue().set(key, value);
		log.info("StringsTest @##@ " + key + "'s value: " + template.opsForValue().get(key));
		log.info("StringsTest @##@ " + key + "'s size: " + template.opsForValue().size(key));
		
		stringsTest.getRange(key, 0, 5);
		
		template.opsForValue().getAndSet(key, "hello, redis world");
		log.info("StringsTest @##@ " + key + "'s value after getAndSet: " + template.opsForValue().get(key));
		
		stringsTest.multiOperation();
		
		stringsTest.incrementDouble();
		
		stringsTest.incrementLong();
	}
	
	public void getRange(String key, int start, int end){
		log.info("StringsTest @##@ " + key + "'s value: " + template.opsForValue().get(key));
		log.info("StringsTest @##@ " + key + " range from "+start +" to " + end +" value is: " + template.opsForValue().get(key, start, end));
	}
	
	public void multiOperation(){
		Map<String, String> m = new HashMap<>();
		Set<String> keys = new HashSet<>();
		for(int i=0;i< 4;i++){
			m.put("key" + i, "value" + i);
			keys.add("key" + i);
		}
		template.opsForValue().multiSet(m);
		log.info("StringsTest @##@ multiSet : done.");
		log.info("StringsTest @##@ multiGet : " + template.opsForValue().multiGet(keys));
	}

	public void incrementDouble() {
		String hashKey = UUID.randomUUID().toString();
		Double value1 = template.opsForValue().increment(hashKey, 30.5d);
		log.info(hashKey + " has value :" + value1);
		double d = 30.2d;
		Double value2 = template.opsForValue().increment(hashKey, d);
		log.info(hashKey + " has value: " + value2 + ", after increment " + d);
	}

	public void incrementLong() {
		String hashKey = UUID.randomUUID().toString();
		long value1 = template.opsForValue().increment(hashKey, 30l);
		log.info(hashKey + " has value :" + value1);
		long l = 25l;
		long value2 = template.opsForValue().increment(hashKey, l);
		log.info(hashKey + " has value: " + value2 + ", after increment " + l);
	}
}

3.Hash（哈希表）

public class HashTest extends RedisCommon {
	private static RedisTemplate<String, Map<String, UserInfo>> userTemplate;
	private static RedisTemplate<String, Map<String, Double>> doubleTemplate;
	private static RedisTemplate<String, Map<String, Long>> longTemplate;
	private static String key = "UserInfo";

	public static void main(String[] args) throws InterruptedException {
		log.info("-----------Starting Redis hash testing-----------");
		ApplicationContext ctx = SpringApplication.run(HashTest.class, args);
		RedisConnectionFactory connectionFactory = ctx
				.getBean(RedisConnectionFactory.class);
		userTemplate = new RedisTemplate<>();
		userTemplate.setConnectionFactory(connectionFactory);
		userTemplate.setKeySerializer(userTemplate.getStringSerializer());
		userTemplate.setHashKeySerializer(userTemplate.getStringSerializer());
		userTemplate
				.setHashValueSerializer(new JacksonJsonRedisSerializer<UserInfo>(
						UserInfo.class));
		userTemplate.afterPropertiesSet();

		doubleTemplate = new RedisTemplate<>();
		doubleTemplate.setConnectionFactory(connectionFactory);
		doubleTemplate.setKeySerializer(doubleTemplate.getStringSerializer());
		doubleTemplate.setHashKeySerializer(doubleTemplate.getStringSerializer());
		doubleTemplate.setHashValueSerializer(doubleTemplate.getDefaultSerializer());
		doubleTemplate.afterPropertiesSet();

		longTemplate = new RedisTemplate<>();
		longTemplate.setConnectionFactory(connectionFactory);
		longTemplate.setKeySerializer(longTemplate.getStringSerializer());
		longTemplate.setHashKeySerializer(longTemplate.getStringSerializer());
		longTemplate.setHashValueSerializer(new LongSerializer());
		longTemplate.afterPropertiesSet();

		HashTest hashTest = ctx.getBean(HashTest.class);
		// hashTest.insert();
		// hashTest.batchInsert();
		// hashTest.insertIfAbsent();
		// hashTest.findAll();
		// hashTest.findOne();
		// hashTest.findAllKeys();
//		hashTest.incrementDouble();
		hashTest.incrementLong();
	}

	public void insert() {
		UserInfo info = new UserInfo();
		info.setName("Tomy");
		info.setAge(20);
		info.setBirthday(new Date());
		info.setId(UUID.randomUUID().toString());
		userTemplate.opsForHash().put(key, info.getId(), info);
		log.info("insert User[" + info + "] success!");
		log.info("User Hash size is : " + userTemplate.opsForHash().size(key));
	}

	public void batchInsert() {
		Map<String, UserInfo> users = new HashMap<>();
		for (int i = 1; i <= 3; i++) {
			UserInfo info = new UserInfo();
			info.setName("Tomy" + i);
			info.setAge(20 + i);
			info.setBirthday(new Date());
			info.setId(UUID.randomUUID().toString());
			users.put(info.getId(), info);
		}
		userTemplate.opsForHash().putAll(key, users);
		log.info("batchInsert Users[" + users + "] success!");
		log.info("User Hash size is : " + userTemplate.opsForHash().size(key));
	}

	public void insertIfAbsent() {
		UserInfo info = new UserInfo();
		info.setName("Tomy4");
		info.setAge(20);
		info.setBirthday(new Date());
		info.setId(UUID.randomUUID().toString());
		userTemplate.opsForHash().putIfAbsent(key, info.getId(), info);
		log.info("insertIfAbsent User[" + info + "] success!");
		log.info("User Hash size is : " + userTemplate.opsForHash().size(key));
	}

	public void findAll() {
		Map<Object, Object> users = userTemplate.opsForHash().entries(key);
		log.info("All User[" + users + "]");
		log.info("findAll User size is : " + users.size());
	}

	public UserInfo findOne() {
		String hashKey = "2ca66275-88ab-49e5-8651-b987e55d9347";
		Object userInfo = userTemplate.opsForHash().get(key, hashKey);
		// boolean have = userTemplate.opsForHash().hasKey(hashKey, hashKey);
		log.info("find one : " + userInfo);
		return userInfo != null ? (UserInfo) userInfo : null;
	}

	public Set<Object> findAllKeys() {
		Set<Object> users = userTemplate.opsForHash().keys(key);
		log.info("find : " + users.size() + " users :" + users);
		return users;
	}

	public void scan() {
		userTemplate.opsForHash().scan(key, ScanOptions.NONE);
	}

	public void incrementDouble() {
		String hashKey = UUID.randomUUID().toString();
		Double value1 = doubleTemplate.opsForHash().increment(key, hashKey,
				Double.valueOf("30"));
		log.info(key + ":" + hashKey + " has value :" + value1);
		Double delta = Double.valueOf("30.3");
		Double value2 = doubleTemplate.opsForHash().increment(key, hashKey, delta);
		log.info(key + ":" + hashKey + " has value: " + value2 + ", after increment " + delta);
	}

	public void incrementLong() {
		String hashKey = UUID.randomUUID().toString();
		long value1 = doubleTemplate.opsForHash().increment(key, hashKey, 30l);
		log.info(key + ":" + hashKey + " has value :" + value1);
		long delta = 20l;
		long value2 = doubleTemplate.opsForHash().increment(key, hashKey, delta);
		log.info(key + ":" + hashKey + " has value: " + value2 + ", after increment " + delta);
	}

}

4.List（列表）

public class ListsTest extends RedisCommon {
	private static RedisTemplate<String, UserInfo> userTemplate;

	public static void main(String[] args) throws InterruptedException {
		log.info("-----------Starting Redis Lists testing-----------");
		ApplicationContext ctx = SpringApplication.run(ListsTest.class, args);
		RedisConnectionFactory connectionFactory = ctx
				.getBean(RedisConnectionFactory.class);
		userTemplate = new RedisTemplate<>();
		userTemplate.setConnectionFactory(connectionFactory);
		userTemplate.setKeySerializer(userTemplate.getStringSerializer());
		userTemplate.setValueSerializer(new JacksonJsonRedisSerializer<UserInfo>(
				UserInfo.class));
		userTemplate.afterPropertiesSet();
		
		String key = "UserInfo";
		
		ListsTest listsTest = ctx.getBean(ListsTest.class);
		listsTest.leftpush(key);
		listsTest.leftpushBatch(key);
		listsTest.leftpop(key);
		listsTest.rightPopAndLeftPush(key);
	}

	public void leftpush(String key) {
		int size = 10;
		for(int i = 0; i < size; i++){
			UserInfo info = new UserInfo();
			info.setName("Tomy" + i);
			info.setAge(20 + i);
			info.setBirthday(new Date());
			info.setId(UUID.randomUUID().toString());
			userTemplate.opsForList().leftPush(key, info);
			//userTemplate.opsForList().leftPush(key, pivot, value)
			//userTemplate.opsForList().leftPushIfPresent(key, value)
			//userTemplate.opsForList().rightPush(key, pivot, value)
			//userTemplate.opsForList().rightPushIfPresent(key, value)
		}
		log.info("insert [" + size + "] User success! " + key + "'s size is:" + userTemplate.opsForList().size(key));
	}
	
	public void leftpushBatch(String key){
		int size = 20;
		List<UserInfo> users = new ArrayList<>();
		for(int i = 10; i < size; i++){
			UserInfo info = new UserInfo();
			info.setName("Tomy" + i);
			info.setAge(20 + i);
			info.setBirthday(new Date());
			info.setId(UUID.randomUUID().toString());
			users.add(info);
		}
		userTemplate.opsForList().leftPushAll(key, users.toArray(new UserInfo[users.size()]));
		//userTemplate.opsForList().rightPushAll(key, (UserInfo[])users.toArray());
		log.info("batchinsert [" + users.size() + "] User success! " + key + "'s size is:" + userTemplate.opsForList().size(key));
	}

	public void leftpop(String key){
		UserInfo userInfo = userTemplate.opsForList().leftPop(key, 2, TimeUnit.SECONDS);
		//userTemplate.opsForList().leftPop(key);
		AtomicInteger ai = new AtomicInteger(0);
		while(userInfo != null){
			ai.incrementAndGet();
			userInfo = userTemplate.opsForList().leftPop(key, 2, TimeUnit.SECONDS);
		}
		log.info("pop [" + ai.get() + "] Users from " + key);
	}
	
	public void rightPopAndLeftPush(String srcKey){
		String destinationKey = "destinationKey";
		log.info("srcKey [" + srcKey + "]'s size : " + userTemplate.opsForList().size(srcKey));
		log.info("destKey [" + destinationKey + "]'s size : " + userTemplate.opsForList().size(destinationKey));
		UserInfo userInfo = userTemplate.opsForList().rightPopAndLeftPush(srcKey, destinationKey);
		while(userInfo != null){
			userInfo = userTemplate.opsForList().rightPopAndLeftPush(srcKey, destinationKey, 2, TimeUnit.SECONDS);
		}
		log.info("After rightPopAndLeftPush destKey [" + destinationKey + "]'s size : " + userTemplate.opsForList().size(destinationKey));
	}
	
}

5.Set（集合）

public class SetTest extends RedisCommon {

	public static void main(String[] args) throws InterruptedException {
		log.info("-----------Starting Redis Set testing-----------");
		ApplicationContext ctx = SpringApplication.run(SetTest.class, args);
		StringRedisTemplate st = ctx.getBean(StringRedisTemplate.class);
		String key = "SetKey";
		String destKey = "DestKey";
		String[] values = new String[]{"value1","value2","value3","value4","value5","value6","value7"};
		log.info("SetKey add [" + st.opsForSet().add(key, values ) + "] values ");
		log.info("SetKey's member " + st.opsForSet().members(key));
		String value5 = "value5";
		log.info(value5 + " is member of SetKey's : " + st.opsForSet().isMember(key, value5));
		log.info("SetKey's randomMember [" + st.opsForSet().randomMember(key) + "]");
		log.info("SetKey's size: " + st.opsForSet().size(key));
		
		String[] subValues = new String[]{"value1","value2","value3"};
		log.info("SetKey remove " + st.opsForSet().remove(key, subValues) + " members");
		log.info("SetKey's size: " + st.opsForSet().size(key));
		
		log.info("SetKey move to DestKey: " + st.opsForSet().move(key, value5, destKey));
		log.info("SetKey's size: " + st.opsForSet().size(key));
		log.info("DestKey size: " + st.opsForSet().size(destKey));
		
		String popValue = st.opsForSet().pop(key);
		log.info("SetKey move to DestKey: " + st.opsForSet().move(key, popValue, destKey));
		log.info("SetKey's size: " + st.opsForSet().size(key));
		log.info("DestKey size: " + st.opsForSet().size(destKey));
		
		//st.opsForSet().difference(key, destKey);
		//st.opsForSet().differenceAndStore(key, otherKeys, destKey);
		
		//st.opsForSet().intersect(key, destKey);
		//st.opsForSet().intersectAndStore(key, otherKey, destKey);
	}

}

6.SortedSet（有序集合）

public class ZSetTest extends RedisCommon {

	public static void main(String[] args) throws InterruptedException {
		log.info("-----------Starting Redis ZSet testing-----------");
		ApplicationContext ctx = SpringApplication.run(ZSetTest.class, args);
		StringRedisTemplate st = ctx.getBean(StringRedisTemplate.class);
		String key = "ZSetKey";
		Set<TypedTuple<String>> values = new HashSet<>();
		for (int i = 0; i < 10; i++) {
			TypedTuple<String> tuple = new DefaultTypedTuple<String>("value-"
					+ i, 12d + i);
			values.add(tuple);
		}
//		log.info("SetKey add [" + st.opsForZSet().add(key, values) + "] values");
		//st.opsForZSet().add(key, value, score)
		//st.opsForZSet().incrementScore(key, value, delta)
		log.info("SetKey has [" + st.opsForZSet().size(key) + "] values");
		
		double start = 15d;
		double end = 18d;
		log.info("SetKey between " + start + " and " + end + " have " + st.opsForZSet().count(key, start, end));
		
		long s = 1;
		long e = 5;
		log.info("SetKey range from " + s + " to " + e + " have " + st.opsForZSet().range(key, s, e));
		//st.opsForZSet().rangeByScore(key, min, max, offset, count)
		//st.opsForZSet().rangeByScoreWithScores(key, min, max)
		//st.opsForZSet().rangeByScoreWithScores(key, min, max, offset, count)
		//st.opsForZSet()
		
		String member = "value-5";
		log.info(member + "'s rank is " + st.opsForZSet().rank(key, member) + " in SetKey.");
		 
		log.info("Remove " + member + " from SetKey : " + st.opsForZSet().remove(key, member));
		
//		st.opsForZSet().removeRange(key, start, end)
//		st.opsForZSet().removeRangeByScore(key, min, max)
//		st.opsForZSet().reverseRange(key, start, end)
//		st.opsForZSet().reverseRangeByScore(key, min, max)
//		st.opsForZSet().reverseRangeByScoreWithScores(key, min, max)
//		st.opsForZSet().reverseRank(key, o)
//		st.opsForZSet().unionAndStore(key, otherKeys, destKey)
//		st.opsForZSet().unionAndStore(key, otherKey, destKey)
	}

}

7.Pub/Sub（发布/订阅）

public class TopicTest extends RedisCommon {
	private static String topicName = "Topic:chat";

	@Bean
	RedisMessageListenerContainer container(
			RedisConnectionFactory connectionFactory,
			MessageListenerAdapter listenerAdapter) {
		RedisMessageListenerContainer container = new RedisMessageListenerContainer();
		container.setConnectionFactory(connectionFactory);
		container.addMessageListener(listenerAdapter, new PatternTopic(topicName));
		//container.addMessageListener(listenerAdapter, new ChannelTopic(topicName));
		return container;
	}

	@Bean
	MessageListenerAdapter listenerAdapter(Receiver receiver) {
		return new MessageListenerAdapter(receiver, "receiveMessage");
	}

	@Bean
	Receiver receiver(@Value("Receiver-1") String name) {
		return new Receiver(name);
	}

	public static void main(String[] args) throws InterruptedException {
		log.info("-----------Starting Redis Topic testing-----------");
		ApplicationContext ctx = SpringApplication.run(TopicTest.class, args);
		StringRedisTemplate template = ctx.getBean(StringRedisTemplate.class);
		template.convertAndSend(topicName, "Hello from Redis!");
	}

	static class Receiver {
		private String name;

		@Autowired
		public Receiver(String name) {
			this.name = name;
		}

		public void receiveMessage(String message) {
			log.info(name + " received <" + message + ">");
		}
	}

}


源码请戳这里。

零下九度
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
redis 的java客户端 基础（一）
diaolove的博客
11-25 731
为了减少内存的消耗，我们可以采用手动序列化的方式，换句话说，就是不借助默认的序列化器，而是我们自己来控制序列化的动作，同时，我们只采用String的序列化器，这样，在存储value时，我们就不需要在内存中就不用多存储数据，从而节约我们的内存空间。有关池化思想，并不仅仅是这里会使用，很多地方都有，比如说我们的数据库连接池，比如我们tomcat中的线程池，这些都是池化思想的体现。为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。
四阶段--day14--Java中操作redis实践
weixin_58580280的博客
09-03 199
本章节主要对Java中操作redis数据库的方式及API应用进行了分析和实践，具体方法的理解可以在实践中基于结果进行分析，逐步进行强化记忆。 一 创建工程,添加依赖 1 工程结构 创建maven父工程，例如05-jt-redis,并在此工程下创建两个子工程，一个为jt-jedis,一个为jt-tempate,例如： 2添加项目依赖 2.1jt-jedis 工程依赖 <dependency> <groupId>redis.clients&l...
【Redis】关于redisTemplate.opsForValue().set数据本地redis客户端库中查不到问题的解决记录，或者查到的key或者value是乱码
最新发布
qq_39666711的博客
07-05 665
二进制串，所以通过get name3 未拿到数据，由于我制定了向redis中存储的时候了，key的序列化的方式了，所以这个里面的key 直接就以name3 的形式存储到了redis中，所以此时通过 get name3 能读取到了数据；但是随之另外一个问题出现了，key序列化之后，通过key：name3 能读取到数据了，而且读取到的数据在console中显示正常。然后在本地redis库中，通过key值读取maven工程中刚才通过redisTemplate存储的数值时，发现获取不到，于是我实验了一番。
redis中用到的api(leftPush(K key, V pivot, V value))
qq_42664961的博客
09-20 2714
在key的列表中指定的value左边（前面）插入一个新的value.如果 指定的value不存在则不插入任何值 把最后一个参数值放到指定集合的第一个出现中间参数的前面，如果中间参数值存在的话。 redisTemplate.opsForList().leftPush ("listTest",lotteryActivity.getId()+1,sLotteryActivity); ...
使用java代码来操作Redis
m0_61639114的博客
09-04 334
注意：需要字节写配置类，优化RedisTemplate的可读性【读官方文档】@Bean//1.创建自定义模板类//2.配置json类型的序列化工具//这样key会用字符串方式保存//3.给模板配置工厂@Autowired【按名字装配】@Test//保存对象Student stu = new Student(1,"厉顾城",25);//获取对象 ----Student stu2 = new Student(2,"厉顾城",25);
java操作redis
weixin_63001822的博客
08-27 149
【代码】java操作redis。
Java操作Redis的多种数据类型
11-02
本文将深入探讨如何使用Java操作Redis的四种主要数据类型：字符串（String）、列表（List）、哈希（Hash）和集合（Set）。 首先，我们来看**字符串类型**（String）。在Redis中，字符串是最基础的数据类型，可以...
java操作Redis缓存设置过期时间的方法
08-19
Java 操作 Redis 缓存设置过期时间的方法 Java 操作 Redis 缓存设置过期时间是指在 Java 应用程序中使用 Redis 缓存时设置缓存项的过期时间，以便自动删除缓存项。下面将详细介绍 Java 操作 Redis 缓存设置过期...
java操作redis.docx
04-18
本文档将详细介绍使用 Java 操作 Redis 的方法，包括基本命令、数据类型、string 操作、list 操作等。 一、基本命令 在使用 Java 操作 Redis 之前，需要了解基本的 Redis 命令。这些命令包括连接操作命令、持久化...
redis的java基本操作（二）
qq_40749830的博客
11-16 606
文章目录一、SpringDataRedis简介1、Redis2、Jedis3、Spring Data Redis二、RedisTemplate中API使用1、pom.xml依赖2、配置文件3、RedisTemplate的直接方法三、redis的五大类型操作1、ValueOperations：简单K-V操作2、HashOperations：针对map类型的数据操作3、ListOperations：针对list类型的数据操作2、SetOperations：set类型数据操作3、ZSetOperations：zs
springboot redis简单消息队列实现
getIt的博客
09-23 2377
消息队列，核心：一发一存一消费。
Redis中 put和putIfAbsent方法的区别
m0_57512160的博客
04-30 3914
Redis中put和putIfAbsent方法的区别
RedisTemplate最常用方法
何哥的博客
02-20 3001
RedisTemplate常用方法介绍，根据RedisTemplate封装了Redis的一些常用的原生操作RedisUtil工具类
【Redis】Redis使用和RedisTemplate的方法介绍
别倒在黎明之前的博客
09-05 2575
leftPush ：从集合左边插入值 | | 从集合左边开始在v值后边插入新值v1leftPushAll ：从左边批量插入新值 | | 从左边批量插入新值(同上)leftPushIfPresent ：如果key存在，从左边插入新值leftPop ：默认移除key中最左的一个值| |指定过期时间后删除key最左的一个值rightPopAndLeftPush ：移除k1中最右的值，并将移除的值插入k2中最左侧| |指定过期时间后，移除k1中最右的值，并将移除的值插入k2中最左侧（同上）
springboot中封装的redistemplate模板操作redis常用命令
背景模版
08-18 664
平常测试redis操作命令，可能用的是cmd窗口 操作redis，记录一下 java程序操作reids， 操作redis的方法 可以用Jedis ，在springboot 提供了两种 方法操作 RedisTemplate 和StringRedisTemplate 两种方法的区别 可参考：https://blog.csdn.net/yifanSJ/article/details/79513179 当然 springboot 中也可以使用Jedis ，本次记录的是 如何使用RedisTemplate 操作rei
RedisTemplet批量插入数据
mlwsmqq的博客
10-24 4084
通过RedisTemplet快速、批量的插入数据
Redis 排序分页
weixin_36451151的博客
10-19 3791
使用Redis实现分页出发点基础架构Redis Sort功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 出发点 在目前...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值