Redisson操作Redis之基础篇

原创 2015年06月01日 11:40:10

记录redis的学习笔记  基础篇

redis是一个开源的,C语言编写、bsd协议的,键值对的缓存和存储的、通常被作为NoSql的内存数据库
   键值包含--字符串、列表、集合、有序集合、散列表、位图、hyperloglogs

  set key value  -->设置键值对
  get key           --获取键对应的值
 getset key field--设置新的键值 并返回key的旧值
Hget key field

 del   key       --删除key和关联值
Hdel key value  --删除删列表的字段的值

 incr key  --以key所对应的值的数字值加一
decr key
incrby key num
decrby key num   --如果key不存在,或者key所对应的值的类型不正确  则将key所对应的值置为0 再进行操作

Exists  key  --判断key是否存在
Hexists key field  --判断key或者字段是否存在

help
help del --查看命令帮助
expire key seconds   --设置key的过期时间
quit   --退出redis的客户端


Hget key field   --获取hash字段的值

主要命令

DECR, DECRBY, DEL, EXISTS, EXPIRE, GET, GETSET, HDEL, HEXISTS, HGET, HGETALL, HINCRBY, HKEYS, HLEN, HMGET, HMSET, HSET, HVALS, INCR, INCRBY, KEYS, LINDEX, LLEN, LPOP, LPUSH, LRANGE, LREM, LSET, LTRIM, MGET, MSET, MSETNX, MULTI, PEXPIRE, RENAME, RENAMENX, RPOP, RPOPLPUSH, RPUSH, SADD, SCARD, SDIFF, SDIFFSTORE, SET, SETEX, SETNX, SINTER, SINTERSTORE, SISMEMBER, SMEMBERS, SMOVE, SORT, SPOP, SRANDMEMBER, SREM, SUNION, SUNIONSTORE, TTL, TYPE, ZADD, ZCARD, ZCOUNT, ZINCRBY, ZRANGE, ZRANGEBYSCORE, ZRANK, ZREM, ZREMRANGEBYSCORE, ZREVRANGE, ZSCORE

源文档 <http://try.redis.io/> 


主要命令分为5类

string类型   --例如 get set

hash类型    --hget hgetall

list类型      -- lrange

set类型     --smembers

sortedset类型  ---zremrangebyscore



命令的返回值
      --状态返回--status reply--OK
     --错误返回--error reply--(error)some 
    --整数返回--integer reply--(integer)1
    --字符串返回--bulk reply--"1"--(nil)
   --多行字符串回复--multi bulk reply--1) "bar"

通配符
 --* ? [a-z] \.

一个redis实例 支持16个字典 使用 select 数字 进行切换 0--15


Map
SortedSet
Set
Bucket
List


相关参考资料

Redis官网--http://redis.io/

                 在线测试redis命令 http://try.redis.io/

               Redis文档 https://github.com/antirez/redis-doc

               官方文档 http://redis.io/documentation 

Redis 支持的客户端编程语言  http://redis.io/clients

我是用的是java版本的  Redisson  最新版1.2.2

Redisson源码  https://github.com/mrniko/redisson

Redisson的wiki https://github.com/mrniko/redisson/wiki



测试代码提供了12种java类型的映射 

主要有String Map  List  Set  SortedSet  Queue DQueue  CountDownLatch Lock Topic AtomicLong

BlockingQueue在Redisson1.2中还未加入  因此没有测试

测试代码  必要的代码都已加了注释

工具类

package com.undergrowth;

import org.redisson.Config;
import org.redisson.Redisson;
import org.redisson.core.RAtomicLong;
import org.redisson.core.RBucket;
import org.redisson.core.RCountDownLatch;
import org.redisson.core.RDeque;
import org.redisson.core.RList;
import org.redisson.core.RLock;
import org.redisson.core.RMap;
import org.redisson.core.RQueue;
import org.redisson.core.RSet;
import org.redisson.core.RSortedSet;
import org.redisson.core.RTopic;

/***
 * Redis client的辅助工具类
 * 用于连接Redis服务器 创建不同的Redis Server对应的客户端对象
 * @author u1
 *
 */
public class RedisUtils {
	
	private static RedisUtils redisUtils;
	
	private RedisUtils(){}
	
	/**
	 * 提供单例模式
	 * @return
	 */
	public static RedisUtils getInstance(){
		if(redisUtils==null) 
			synchronized (RedisUtils.class) {
				if(redisUtils==null) redisUtils=new RedisUtils();
			}
		return redisUtils;
	}
	
	
	/**
	 * 使用config创建Redisson
	 * Redisson是用于连接Redis Server的基础类
	 * @param config
	 * @return
	 */
	public Redisson getRedisson(Config config){
		Redisson redisson=Redisson.create(config);
		System.out.println("成功连接Redis Server");
		return redisson;
	} 
	
	/**
	 * 使用ip地址和端口创建Redisson
	 * @param ip
	 * @param port
	 * @return
	 */
	public Redisson getRedisson(String ip,String port){
		Config config=new Config();
		config.useSingleServer().setAddress(ip+":"+port);
		Redisson redisson=Redisson.create(config);
		System.out.println("成功连接Redis Server"+"\t"+"连接"+ip+":"+port+"服务器");
		return redisson;
	}
	
	/**
	 * 关闭Redisson客户端连接
	 * @param redisson
	 */
	public void closeRedisson(Redisson redisson){
		redisson.shutdown();
		System.out.println("成功关闭Redis Client连接");
	}
	
	/**
	 * 获取字符串对象
	 * @param redisson
	 * @param t
	 * @param objectName
	 * @return
	 */
	public <T> RBucket<T> getRBucket(Redisson redisson,String objectName){
		RBucket<T> bucket=redisson.getBucket(objectName);
		return bucket;
	}
	
	/**
	 * 获取Map对象
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public <K,V> RMap<K, V> getRMap(Redisson redisson,String objectName){
		RMap<K, V> map=redisson.getMap(objectName);
		return map;
	}
	
	/**
	 * 获取有序集合
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public <V> RSortedSet<V> getRSortedSet(Redisson redisson,String objectName){
		RSortedSet<V> sortedSet=redisson.getSortedSet(objectName);
		return sortedSet;
	}
	
	/**
	 * 获取集合
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public <V> RSet<V> getRSet(Redisson redisson,String objectName){
		RSet<V> rSet=redisson.getSet(objectName);
		return rSet;
	}
	
	/**
	 * 获取列表
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public <V> RList<V> getRList(Redisson redisson,String objectName){
		RList<V> rList=redisson.getList(objectName);
		return rList;
	}
	
	/**
	 * 获取队列
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public <V> RQueue<V> getRQueue(Redisson redisson,String objectName){
		RQueue<V> rQueue=redisson.getQueue(objectName);
		return rQueue;
	}
	
	/**
	 * 获取双端队列
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public <V> RDeque<V> getRDeque(Redisson redisson,String objectName){
		RDeque<V> rDeque=redisson.getDeque(objectName);
		return rDeque;
	}
	
	/**
	 * 此方法不可用在Redisson 1.2 中 
	 * 在1.2.2版本中 可用
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	/**
	public <V> RBlockingQueue<V> getRBlockingQueue(Redisson redisson,String objectName){
		RBlockingQueue rb=redisson.getBlockingQueue(objectName);
		return rb;
	}*/
	
	/**
	 * 获取锁
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public RLock getRLock(Redisson redisson,String objectName){
		RLock rLock=redisson.getLock(objectName);
		return rLock;
	}
	
	/**
	 * 获取原子数
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public RAtomicLong getRAtomicLong(Redisson redisson,String objectName){
		RAtomicLong rAtomicLong=redisson.getAtomicLong(objectName);
		return rAtomicLong;
	}
	
	/**
	 * 获取记数锁
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public RCountDownLatch getRCountDownLatch(Redisson redisson,String objectName){
		RCountDownLatch rCountDownLatch=redisson.getCountDownLatch(objectName);
		return rCountDownLatch;
	}
	
	/**
	 * 获取消息的Topic
	 * @param redisson
	 * @param objectName
	 * @return
	 */
	public <M> RTopic<M> getRTopic(Redisson redisson,String objectName){
		 RTopic<M> rTopic=redisson.getTopic(objectName);
		 return rTopic;
	}
	
	
}


测试代码

import io.netty.util.concurrent.Future;

import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.redisson.Redisson;
import org.redisson.core.MessageListener;
import org.redisson.core.RAtomicLong;
import org.redisson.core.RBucket;
import org.redisson.core.RCountDownLatch;
import org.redisson.core.RDeque;
import org.redisson.core.RList;
import org.redisson.core.RLock;
import org.redisson.core.RMap;
import org.redisson.core.RQueue;
import org.redisson.core.RSet;
import org.redisson.core.RSortedSet;
import org.redisson.core.RTopic;

import com.undergrowth.RedisUtils;

public class RedisUtilsTest {

	Redisson redisson;

	/**
	 * 每次在测试方法运行之前 运行此方法
	 * 创建客户端连接服务器的redisson对象
	 */
	@Before
	public void before() {
		String ip = "192.168.1.160";
		String port = "6379";
		redisson = RedisUtils.getInstance().getRedisson(ip, port);
	}

	/**
	 * 每次测试方法运行完之后 运行此方法
	 * 用于关闭客户端连接服务器的redisson对象
	 */
	@After
	public void after(){
		RedisUtils.getInstance().closeRedisson(redisson);
	}
	
	/**
	 * RBucket 映射为 redis server 的 string 类型
	 * 只能存放最后存储的一个字符串
	 * redis server 命令:
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testBucket
	 * 查看key的值 ---->get testBucket
	 */
	@Test
	public void testGetRBucket() {
		RBucket<String> rBucket=RedisUtils.getInstance().getRBucket(redisson, "testBucket");
		//同步放置
		rBucket.set("redisBucketASync");
		//异步放置
		rBucket.setAsync("测试");
		String bucketString=rBucket.get();
		System.out.println(bucketString);
	}

	/**
	 * RMap  映射为  redis server 的 hash 类型
	 * 分为
	 * put(返回键值) 、 fast(返回状态)
	 * 同步    异步
	 * redis server 命令:
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testMap
	 * 查看key的值 ---->hgetall testMap
	 * @throws InterruptedException
	 * @throws ExecutionException
	 */
	@Test
	public void testGetRMap() throws InterruptedException, ExecutionException {
		RMap<String, Integer> rMap=RedisUtils.getInstance().getRMap(redisson, "testMap");
		//清除集合
		rMap.clear();
		//添加key-value 返回之前关联过的值
		Integer firrtInteger=rMap.put("111", 111);
		System.out.println(firrtInteger);
		//添加key-value 返回之前关联过的值
		Integer secondInteger=rMap.putIfAbsent("222", 222);
		System.out.println(secondInteger);
		//移除key-value
		Integer thirdInteger=rMap.remove("222");
		System.out.println(thirdInteger);
		//添加key-value 不返回之前关联过的值
		boolean third=rMap.fastPut("333", 333);
		System.out.println(third);
		Future<Boolean> fiveFuture=rMap.fastPutAsync("444", 444);
		System.out.println(fiveFuture.isSuccess());
		//异步移除key
		Future<Long> sixFuture=rMap.fastRemoveAsync("444");
		System.out.println(String.valueOf(sixFuture.get()));
		//遍历集合
		for(String key :rMap.keySet()){
			System.out.println(key+":"+rMap.get(key));
		}
		
	}

	/**
	 * RSortedSet 映射为 redis server 的 list 类型
	 * 存储以有序集合的形式存放
	 *  redis server 命令:
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testSortedSet
	 * 查看key的值 ---->lrange testSortedSet 0 10
	 */
	@Test
	public void testGetRSortedSet() {
		RSortedSet<Integer> rSortedSet=RedisUtils.getInstance().getRSortedSet(redisson, "testSortedSet");
		//清除集合
		rSortedSet.clear();
		rSortedSet.add(45);
		rSortedSet.add(12);
		rSortedSet.addAsync(45);
		rSortedSet.add(100);
		//输出结果集
		System.out.println(Arrays.toString(rSortedSet.toArray()));;
	}

	/**
	 * RSet 映射为 redis server 的set 类型
	 *  redis server 命令:
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testSet
	 * 查看key的值 ---->smembers testSet 
	 */
	@Test
	public void testGetRSet() {
		RSet<Integer> rSet=RedisUtils.getInstance().getRSet(redisson, "testSet");
		//清除集合
		rSet.clear();
		Collection<Integer> c=Arrays.asList(12,45,12,34,56,78);
		rSet.addAll(c);
		//输出结果集
		System.out.println(Arrays.toString(rSet.toArray()));
	}

	/**
	 * RList 映射为 redis server的list类型
	 *  redis server 命令:
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testList
	 * 查看key的值 ---->lrange testList 0 10
	 */
	@Test
	public void testGetRList() {
		RList<Integer> rList=RedisUtils.getInstance().getRList(redisson, "testList");
		//清除集合
		rList.clear();
		Collection<Integer> c=Arrays.asList(12,45,12,34,56,78);
		rList.addAll(c);
		//输出结果集
		System.out.println(Arrays.toString(rList.toArray()));
	}

	/**
	 * RQueue 映射为 redis server的list类型
	 * 队列--先入先出
	 *  redis server 命令:
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testQueue
	 * 查看key的值 ---->lrange testQueue 0 10 
	 */
	@Test
	public void testGetRQueue() {
		RQueue<Integer> rQueue=RedisUtils.getInstance().getRQueue(redisson, "testQueue");
		//清除队列
		rQueue.clear();
		Collection<Integer> c=Arrays.asList(12,45,12,34,56,78);
		rQueue.addAll(c);
		//查看队列元素
		System.out.println(rQueue.peek());
		System.out.println(rQueue.element());
		//移除队列元素
		System.out.println(rQueue.poll());
		System.out.println(rQueue.remove());
		//输出队列
		System.out.println(Arrays.toString(rQueue.toArray()));
	}

	/**
	 * RDeque 映射为 redis server 的 list类型
	 * 双端队列--对头和队尾都可添加或者移除,也遵循队列的先入先出
	 *  redis server 命令:
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testDeque
	 * 查看key的值 ---->lrange testDeque 0 10  
	 */
	@Test
	public void testGetRDeque() {
		RDeque<Integer> rDeque=RedisUtils.getInstance().getRDeque(redisson, "testDeque");
		//清空双端队列
		rDeque.clear();
		Collection<Integer> c=Arrays.asList(12,45,12,34,56,78);
		rDeque.addAll(c);
		//对头添加元素
		rDeque.addFirst(100);
		//队尾添加元素
		rDeque.addLast(200);
		System.out.println(Arrays.toString(rDeque.toArray()));
		//查看对头元素
		System.out.println(rDeque.peek());
		System.out.println(rDeque.peekFirst());
		//查看队尾元素
		System.out.println(rDeque.peekLast());
		System.out.println(Arrays.toString(rDeque.toArray()));
		//移除对头元素
		System.out.println(rDeque.poll());
		System.out.println(rDeque.pollFirst());
		//移除队尾元素
		System.out.println(rDeque.pollLast());
		System.out.println(Arrays.toString(rDeque.toArray()));
		//添加队尾元素
		System.out.println(rDeque.offer(300));
		System.out.println(rDeque.offerFirst(400));
		System.out.println(Arrays.toString(rDeque.toArray()));
		//移除对头元素
		System.out.println(rDeque.pop());
		//显示双端队列的元素
		System.out.println(Arrays.toString(rDeque.toArray()));
		
	}

	/**
	 * RLock 映射为redis server的string 类型
	 * string中存放 线程标示、线程计数
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testLock1
	 * 查看key的值 ---->get testLock1 
	 * 如果想在redis server中 看到 testLock1
	 * 就不能使用   rLock.unlock();
	 * 因为使用 rLock.unlock(); 之后 就会删除redis server中的 testLock1
	 * 
	 */
	@Test
	public void testGetRLock() {
		RLock rLock=RedisUtils.getInstance().getRLock(redisson, "testLock1");
		if(rLock.isLocked()) rLock.unlock();
		else rLock.lock();
		//
		System.out.println(rLock.getName());
		System.out.println(rLock.getHoldCount());
		System.out.println(rLock.isLocked());
		rLock.unlock();
	}

	/**
	 * RAtomicLong 映射为redis server的string 类型
	 * string中数值
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testAtomicLong
	 * 查看key的值 ---->get testAtomicLong 
	 */
	@Test
	public void testGetRAtomicLong() {
		RAtomicLong rAtomicLong=RedisUtils.getInstance().getRAtomicLong(redisson, "testAtomicLong");
		rAtomicLong.set(100);
		System.out.println(rAtomicLong.addAndGet(200));
		System.out.println(rAtomicLong.decrementAndGet());
		System.out.println(rAtomicLong.get());
	}

	/**
	 * RCountDownLatch 映射为redis server的string 类型
	 * string中数值
	 * 闭锁--等待其他线程中的操作都做完 在进行操作
	 * 查看所有键---->keys *
	 * 查看key的类型--->type testCountDownLatch
	 * 查看key的值 ---->get testCountDownLatch 
	 */
	@Test
	public void testGetRCountDownLatch() throws InterruptedException {
		RCountDownLatch rCountDownLatch=RedisUtils.getInstance().getRCountDownLatch(redisson, "testCountDownLatch");
		System.out.println(rCountDownLatch.getCount());
		//rCountDownLatch.trySetCount(1l);
		System.out.println(rCountDownLatch.getCount());
		rCountDownLatch.await(10, TimeUnit.SECONDS);
		System.out.println(rCountDownLatch.getCount());
	}

	/**
	 * 消息队列的订阅者
	 * @throws InterruptedException
	 */
	@Test
	public void testGetRTopicSub() throws InterruptedException {
		RTopic<String> rTopic=RedisUtils.getInstance().getRTopic(redisson, "testTopic");
		rTopic.addListener(new MessageListener<String>() {
			
			@Override
			public void onMessage(String msg) {
				// TODO Auto-generated method stub
				System.out.println("你发布的是:"+msg);
			}
		});
		//等待发布者发布消息
		RCountDownLatch rCountDownLatch=RedisUtils.getInstance().getRCountDownLatch(redisson, "testCountDownLatch");
		rCountDownLatch.trySetCount(1);
		rCountDownLatch.await();
	}
	
	/**
	 * 消息队列的发布者
	 */
	@Test
	public void testGetRTopicPub() {
		RTopic<String> rTopic=RedisUtils.getInstance().getRTopic(redisson, "testTopic");
		System.out.println(rTopic.publish("今天是儿童节,大家儿童节快乐"));
		//发送完消息后 让订阅者不再等待
		RCountDownLatch rCountDownLatch=RedisUtils.getInstance().getRCountDownLatch(redisson, "testCountDownLatch");
		rCountDownLatch.countDown();
	}

}



上面只是对redis的初步了解    接下来分模块进行研究



redisson的pom依赖

<dependencies>
		<dependency>
			<groupId>org.redisson</groupId>
			<artifactId>redisson</artifactId>
			<version>1.2.0</version>
		</dependency>
	</dependencies>




版权声明:本文为博主原创文章,未经博主允许不得转载。

Redis分布式客户端-Redisson介绍

简介Redisson - 是一个高级的分布式协调Redis客服端,能帮助用户在分布式环境中轻松实现一些Java的对象 (Bloom filter, BitSet, Set, SetMultimap, ...

Redisson教程

Redisson入门     Author:Ricky  Date:2017-04-24 Redisson概述       Redisson是架设在Redis基础上的一个Java驻内存数据...

Redisson分布式锁的简单使用

redis分布式锁学习和集成框架Redisson分布式锁的一些简单使用

redisson的理解和使用-调用流程

redisson的理解和使用-调用流程

redis - Java操作 用redisson 和 jedis 操作redis数据库

上一篇搭建好的服务器一直开着要。Java连接Redis的使用示例 Redis是开源的key-value存储工具,redis通常用来存储结构化的数据,因为redis的key可以包含String、...

redisson实现分布式锁原理

Redisson分布式锁 之前的基于注解的锁有一种锁是基本redis的分布式锁,锁的实现我是基于redisson组件提供的RLock,这篇来看看redisson是如何实现锁的。 不同版本实现锁的机...

redisson使用第一次碰到的坑

1、由于用的jersey,而jersey使用的jack-json版本和redison使用的不一样,导致maven依赖冲突。 解决思路,优先考虑使用exclusions排除重复的jar包。如果解决不了,...

redisson整合spring

首先讲下什么是Redisson:Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid)。它不仅提供了一系列的分布式的Java常用对象,还提...

Redis分布式锁 Redisson

之前使用setnx没能解决问题,现在使用  Redisson Redisson 功能和jedis类似,封装了连接操作,但没有jedis全面。要使用Redisson的分布式锁需要redis支持eva...

基于Redis实现分布式锁,Redisson使用及源码分析

在分布式场景下,有很多种情况都需要实现最终一致性。在设计远程上下文的领域事件的时候,为了保证最终一致性,在通过领域事件进行通讯的方式中,可以共享存储(领域模型和消息的持久化数据源),或者做全局XA事务...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Redisson操作Redis之基础篇
举报原因:
原因补充:

(最多只允许输入30个字)