Redis- 技术专题 -Jedis 实战入门

用户头像
李博@Alex
关注
发布于: 2020 年 10 月 10 日
Redis-技术专题-Jedis实战入门

Redis是一个开源,高级的键值存储和一个适用的解决方案,用于构建高性能,可扩展的Web应用程序。本文将概要介绍Redis的特性和语法,并以实例代码的形式介绍如何通过Jedis在java语言环境下控制Redis,帮助各位读者快速入门。

NoSQL概述

Redis是NoSQL数据库的代表之一,那什么是NoSQL?

NoSQL = not only SQL,即非关系型数据库。

Why NoSQL?

和传统的关系型数据库相比,NoSQL具有以下的优势:

  • High Performance:高并发读写;

  • Huge Storage: 海量数据的高效存储和访问;

  • High Scalability & High Availability:高可扩展和高可用性

NoSQL的分类:

  • Key-Value,如Redis,快速查询,但是数据存储缺少结构化;

  • 列存储,如HBase, 扩展性强,查找速度快,但是功能局限;

  • 文档数据库,如MongoDB,数据格式灵活,查询性能不高,缺少统一的查询语法;

  • 图形数据库,如InfoGrid,基于图的算法,但是不容易做分布式的查询;

Redis概述

Redis是一个开源,高性能的键值对数据库, 其优点包括:

  • 异常快 :Redis非常快,每秒可执行大约110000次的设置(SET)操作,每秒大约可执行81000次的读取/获取(GET)操作。

  • 支持丰富的数据类型 :Redis支持开发人员常用的大多数数据类型,例如列表集合排序集散列等等。这使得Redis很容易被用来解决各种问题,因为我们知道哪些问题可以更好使用地哪些数据类型来处理解决。

  • 操作具有原子性 : 所有Redis操作都是原子操作,这确保如果两个客户端并发访问,Redis服务器能接收更新的值。

  • 多实用工具 : Redis是一个多实用工具,可用于多种用例,如:缓存任务队列;网站统计;数据过期处理;应用排行榜;分布式集群的Session分离

Redis与其他键值存储系统

  • Redis是键值数据库系统的不同进化路线,它的值可以包含更复杂的数据类型,可在这些数据类型上定义原子操作。

  • Redis是一个内存数据库,但在磁盘数据库上是持久的,因此它代表了一个不同的权衡,在这种情况下,在不能大于存储器(内存)的数据集的限制下实现非常高的写和读速度。

  • 内存数据库的另一个优点是,它与磁盘上的相同数据结构相比,复杂数据结构在内存中存储表示更容易操作。 因此,Redis可以做很少的内部复杂性。

Redis的安装和使用

Redis的安装是否简单,在Ubuntu上安装Redis,打开终端并键入以下命令即可

sudo apt-get update
sudo apt-get install redis-server

启动服务器:redis-server

启动客户端:redis-cli

如果是Windows环境下,则参照以下文章:

http://download.csdn.net/download/fengxinyixiao/9860813http://blog.csdn.net/joyhen/article/details/47358999

Jedis入门

Jedis是Redis官网首选的Java客户端开发包.

Jedis是Redis官网首选的Java客户端开发包

其GItHub地址为:

https://github.com/xetorthio/jedis

在Maven中,添加如下依赖即可使用:

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
<type>jar</type>
<scope>compile</scope>
</dependency>


以下是官网是上给出的示例代码,连接本地Redis,进行操作.

@Test
public void ConnectionTest(){
//1. Connecting to Redis server on localhost
Jedis jedis = new Jedis("localhost");
System.out.println("Connection to server sucessfully");
//2. set the data in redis string
jedis.set("username", "Roxin");
//3. Get the stored data and print it
System.out.println("Stored string in redis:: "+ jedis.get("username"));
//4. Close the Redis connection;
jedis.close();
}

其中通过调用set方法来设置键值对,通过get方法获取键值对。

除此之外,Jedis还提供连接池的方式控制连接

@Test
public void ConnectionPoolTest(){
//连接池设定
JedisPoolConfig config = new JedisPoolConfig();
//设定最大连接数
config.setMaxTotal(30);
//设置最大空闲连接数
config.setMaxIdle(10);
//创建连接池
JedisPool jedisPool = new JedisPool(config, "127.0.0.1");
//获得服务资源
Jedis jedis = jedisPool.getResource();
jedis.select(1);
jedis.set("username", "Roxin By Jedis Pool");
System.out.println(jedis.get("username"));
jedis.close();
jedisPool.close();
}


Redis的数据类型

Redis中的数据类型有:

  • 字符串(String)

  • 列表(list)

  • 有序集合(sorted set)

  • 散列(hash)

  • 集合(set)

无论哪种数据类型都需要为其设定键值Key,设置Key的注意点:

  1. 不要太长(<1024字节);

  2. 不要太短,有可读性;

  3. 统一命名规范;

String

Redis中的字符串是一个字节序列。Redis中的字符串是二进制安全的,这意味着它们的长度不由任何特殊的终止字符决定。因此,可以在一个字符串中存储高达512兆字节的任何内容。

除了上面提到的set/get方法,还有其他命令如下表:

Hash

相当于Map,在Redis中,每个哈希(散列)可以存储多达4亿个键-值对。

Jedis示例代码如下

@Test
public void HashTest(){
Jedis jedis = jedisPool.getResource();
String hashKey = "hashKey";
//hset设置一个键值对
jedis.hset(hashKey,"user","Roxin");
HashMap<String, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.put("field"+i,"value"+i);
}
//设置多个键值对
jedis.hmset(hashKey,map);
//获得键值对的个数
Long hlen = jedis.hlen(hashKey);
System.out.println("Hash Size in redis:: "+hlen);
assert hlen==11;
//得到全部键值对
List<String> user = jedis.hmget(hashKey, "user");
System.out.println("Stored string in redis:: "+ user);
assert user.get(0).equals("Roxin");
//删除键值
jedis.del(hashKey);
jedis.close();
}


Redis关于Hash类型的常见命令如下表:

list

Redis列表只是字符串列表,按插入顺序排序。可以在列表的头部或尾部添加Redis列表中的元素。

列表的最大长度为2^32 - 1个元素(即4294967295,每个列表可存储超过40亿个元素)

Jedis中示例代码如下

@Test
public void ListTest(){
Jedis jedis = jedisPool.getResource();
String listKey = "LISTKEY";
for (int i = 0; i < 10; i++) {
//从头插入一个元素
jedis.lpush(listKey,"L-value");
}
List<String> list = jedis.lrange(listKey, 0, -1);//从第一个到最后一个,负数代表倒数第几个
assert list.size() == 10;
assert "L-value".equals(jedis.rpop(listKey));//从尾部取出一个元素
assert 9==jedis.llen(listKey);
jedis.rpush(listKey,"R-valure");//从尾部加入一个元素
jedis.lrem(listKey,2,"L-value");//删除从左数2两个"L-value"元素
jedis.lrem(listKey,0,"L-value"); //0表示删除全部"L-value"元素
assert "R-valure".equals(jedis.lpop(listKey));//从头部加入一个元素
jedis.del(listKey);
jedis.close();
}

Redis中关于list的命令如下表:

需要特别说明下:

rpoplpush source destination

  删除列表中的最后一个元素,将其附加到另一个列表并返回,在消息队列中,可以用于消息备份:当消息被发布后,一个消息从主消息队列中被取出,被放入到缓存队列中,当确认发生成功之后,再将其彻底删除,如果发送不成功,就恢复该消息。

Set

Redis集合是唯一字符串的无序集合。 唯一值表示集合中不允许键中有重复的数据。

在Redis中设置添加,删除和测试成员的存在(恒定时间O(1),而不考虑集合中包含的元素数量)。列表的最大长度为2^32 - 1个元素(即4294967295,每组集合超过40亿个元素)。

存储Set的使用场景:

  • 跟踪唯一性数据

  • 用于维护数据对象之间的关联关系;

Jedis的代码示例:

@Test
public void SetTest(){
Jedis jedis = jedisPool.getResource();
String setKey1 = "SETKEY-1";
for (int i = 0; i < 10; i++) {
//添加一个元素
jedis.sadd(setKey1,"value-"+i);
}
assert 10 == jedis.scard(setKey1); //获得元素个数
jedis.sadd(setKey1,"value-1");//添加重复的元素将失效
assert 10 == jedis.scard(setKey1);
String s= jedis.srandmember(setKey1);//随机获取一个元素
assert jedis.sismember(setKey1,s);//是否为集合成员
String setKey2 = "SETKEY-2";
for (int i = 1; i < 11; i++) {
jedis.sadd(setKey2,"value-"+i);
}
assert jedis.sdiff(setKey1,setKey2).size() == 1;//补集
assert jedis.sinter(setKey1,setKey2).size() == 9;//交集
assert jedis.sunion(setKey1,setKey2).size() == 11;//并集
jedis.del(setKey1,setKey2);
jedis.close();
}


Redis中关于Set的命令如下表:

Sorted-Set

Redis可排序集合类似于Redis集合,是不重复的字符集合。 不同之处在于,排序集合的每个成员都与分数相关联,这个分数用于按最小分数到最大分数来排序的排序集合。虽然成员是唯一的,但分数值可以重复。

Sorted-Set的使用场景:

  • 大型在线游戏的积分排名;

  • 构建索引数据;

Jedis中的示例:

@Test
public void SortedSetTest(){
Jedis jedis = jedisPool.getResource();
String sortedSetKey = "SORTEDSETKEY";
for (int i = 0; i < 10; i++) {
//添加一个元素
jedis.zadd(sortedSetKey,i*10,"v-"+i);
}
assert 10 == jedis.zcard(sortedSetKey);//获得集合中元素个数
assert 20 == (jedis.zscore(sortedSetKey,"v-2"));//获得集合中元素对应的分数
Set<String> set = jedis.zrange(sortedSetKey, 0, -2);//从第一个到倒数第二个
assert 9 == set.size() ;
assert !set.contains("v-9");
jedis.zincrby(sortedSetKey,20,"v-1");//让元素的分数增长20
assert 30 == jedis.zscore(sortedSetKey,"v-1");
assert 3 == jedis.zcount(sortedSetKey,20,30);//获得分数段中元素个数
jedis.del(sortedSetKey);
jedis.close();
}

Keys的通用操作

Jedis中关于键值操作的实例:

@Test
public void KeyTest(){
Jedis jedis = jedisPool.getResource();
String key = "TESTKEY-1";
String key2 = "TESTKEY-2";
jedis.set(key2,"");//设置键值
jedis.rename(key2,key);//键值重命名
System.out.println("Key Type:"+jedis.type(key));//键值的类型
assert jedis.exists(key);//键值是否存在
jedis.expire(key,1);//设置键值过期时间
assert 1 == jedis.ttl(key);//查看键值过期时间
try {
Thread.sleep(2000);//睡眠2s
} catch (InterruptedException e) {
e.printStackTrace();
}
assert !jedis.exists(key);//键值已过期,不存在
}


Redis中关于键值的其他命令:

KEYS pattern 查找与指定模式匹配的所有键:

  • keys * 查看所有的key;

  • keys xx? 模糊匹配key;

Redis的特性

多数据

提供16个数据库(0-15),默认为0号数据库,可是通过select index选择。

事务

和关系型数据库一样,Redis也提供事务性操作:

  1. DISCARD 丢弃在MULTI之后发出的所有命令(放弃事务,回滚)

  2. EXEC 执行MULTI后发出的所有命令(提交事务)

  3. MULTI 标记事务块的开始(开始事务)

  4. UNWATCH 取消 WATCH 命令对所有 key 的监视。

  5. WATCH key [key …] 监视给定的键以确定MULTI / EXEC块的执行

Redis中示例代码如下:

@Test
public void TransactionTest(){
//获得服务资源
Jedis jedis = jedisPool.getResource();
jedis.select(1);
Transaction transaction = jedis.multi();//开启事务
transaction.set("username", "Roxin in transaction1");
System.out.println(transaction.get("username"));
transaction.exec();//提交事务
System.out.println(jedis.get("username"));
transaction = jedis.multi();//开启事务
transaction.set("username", "Roxin in transaction2");
System.out.println(transaction.get("username"));
transaction.discard();//撤销事务
System.out.println(jedis.get("username"));
jedis.close();
}


Redis持久化

Redis是一个内存数据库,但在磁盘数据库上是持久化的,持久化的方式分为两种:

  • RDB:默认方式,定时将内存数据集快照写入磁盘;

  • AOF:以日志的方式,记录所有操作;

RDB

优势

  • 数据只存在一个文件中,便于数据归档和整理;

  • 多线程启动,性能好;

劣势

  • 如果在两次快照写操作之间出现问题,将无法回复期间的数据;

  • 多线程启动的时候,可能会有停顿;

配置文件为Redis按照目录下的 redis.conf:

redis.conf 保存频率的设施

这是配置文件设置内存快照写入磁盘的条件

# In the example below the behaviour will be to save:
# after 900 sec (15 min) if at least 1 key changed
# after 300 sec (5 min) if at least 10 keys changed
# after 60 sec if at least 10000 keys changed
save 900 1
save 300 10
save 60 10000


数据文件被定义为dump.rdb,保存路径为Redis的按照路径。

# The filename where to dump the DB
dbfilename dump.rdb

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
#
# The Append Only File will also be created inside this directory.
#
# Note that you must specify a directory here, not a file name.
dir ./




Redis数据文件,只有一个数据文件

AOF

优势:

  1. 更高的数据安全性,有三种数据同步策略:

  2. 日志是追加(append)模式,即使有宕机,也不会用问题。 如果是数据写入一半出现问题,可以使用redis-check-aof,恢复数据一致;

  3. 日志自动重写,以防止日志过大;

  4. 日志格式清楚明了,可用于数据重建;

劣势:

  • 文件要更大;

  • 运行效率更低;

配置文件中关于AOF的配置:

关于AOF的配置

默认不使用;

日志文件为 appendonly.aof

# The name of the append only file (default: "appendonly.aof")
appendfilename "appendonly.aof"


上面提高的三种同步策略;

# no: don't fsync, just let the OS flush the data when it wants. Faster.
# always: fsync after every write to the append only log. Slow, Safest.
# everysec: fsync only one time every second. Compromise.
#
# The default is "everysec",If unsure, use "everysec".

# appendfsync always
appendfsync everysec
# appendfsync no



用户头像

李博@Alex

关注

我们始于迷惘,终于更高的迷惘. 2020.03.25 加入

一个酷爱计算机技术、健身运动、悬疑推理的极客狂人

评论

发布
暂无评论
Redis-技术专题-Jedis实战入门