您的位置：首页 > 理论基础 > 数据结构算法

Redis和nosql简介,api调用；Redis数据功能（String类型的数据处理）；List数据结构（及Java调用处理）；Hash数据结构；Set数据结构功能；sortedSet（有序集合）数

2017-01-15 02:19 1336 查看

1、Redis和nosql简介,api调用

14.1/ nosql介绍

NoSQL：一类新出现的数据库(not only sql)，它的特点：

1、 不支持SQL语法

2、 存储结构跟传统关系型数据库中的那种关系表完全不同，nosql中存储的数据都是KV形式

3、 NoSQL的世界中没有一种通用的语言，每种nosql数据库都有自己的api和语法，以及擅长的业务场景

4、 NoSQL中的产品种类相当多：

a) Mongodb 文档型nosql数据库，擅长做CMS系统（内容管理系统）

b) Redis 内存数据库，数据结构服务器，号称瑞士军刀（精巧），只要你有足够的想象力，它可以还给你无限惊喜

c) Hbase hadoop生态系统中原生的一种nosql数据库，重量级的分布式nosql数据库，用于海量数据的场景

d) Cassandra hadoop生态系统中原生的一种分布式nosql数据库，后起之秀

NoSQL和SQL数据库的比较：

1、适用场景不同：sql数据库适合用于关系特别复杂的数据查询场景，nosql反之

2、“事务”特性的支持：sql对事务的支持非常完善，而nosql基本不支持事务

3、两者在不断地取长补短，呈现融合趋势

14.2/ redis介绍

14.2.1 简述

Redis是一个高性能的kv对缓存和内存数据库(存的不像mysql那样的表)

Redis的存储结构就是key-value，形式如下：



注： redis中的value内部可以支持各种数据结构类型，比如可以存入一个普通的string，还可以存list，set，hashmap，sortedSet（有序的set）

14.2.2 redis应用场景

A、用来做缓存(ehcache/memcached)——redis的所有数据是放在内存中的（内存数据库）

B、可以在某些特定应用场景下替代传统数据库——比如社交类的应用

C、在一些大型系统中，巧妙地实现一些特定的功能：session共享、购物车

只要你有丰富的想象力，redis可以用在可以给你无限的惊喜…….

14.2.3 redis的特性

1、redis数据访问速度快（数据在内存中）

2、redis有数据持久化机制（持久化机制有两种：1、定期将内存数据dump到磁盘；2、aof(append only file)持久化机制——用记日志的方式记录每一条数据更新操作，一旦出现灾难事件，可以通过日志重放来恢复整个数据库）

3、redis支持集群模式（容量可以线性扩展）

4、redis相比其他缓存工具（ehcach/memcached），有一个鲜明的优势：支持丰富的数据结构

14.3.Redis的api客户端连接

新建一个maven工程，导入jedis的maven依赖坐标

<dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

<version>2.7.2</version>

<type>jar</type>

<scope>compile</scope>

</dependency>

然后写一个类用来测试服务器跟客户端的连通性:

public class RedisClientConnectionTest {

public static void main(String[] args) {

// 构造一个redis的客户端对象

Jedis jedis = new Jedis("pinshutang.zicp.net", 6379);

String ping = jedis.ping();

System.out.println(ping);

}

}

15、Redis数据功能（String类型的数据处理）

15.1 String类型的数据

(常作为缓存使用)

1/插入和读取一条string类型的数据

redis notrue-centos:6379> set sessionid-0001 "zhangsan"

OK

redis notrue-centos:6379> get sessionid-0001

"zhangsan"

2/对string类型数据进行增减（前提是这条数据的value可以看成数字）

192.168.106.80:6379> DECR key

(integer) -1

192.168.106.80:6379> DECR key

(integer) -2

192.168.106.80:6379> DECR key

(integer) -3

192.168.106.80:6379> INCR key

(integer) -2

192.168.106.80:6379> INCR key

(integer) -1

192.168.106.80:6379> DECRBY key 4

(integer) -5

192.168.106.80:6379> DECRBY key -7

(integer) 2

192.168.106.80:6379> INCRBY key 2

(integer) 4

192.168.106.80:6379> INCRBY key -9

(integer) -5

3/一次性插入或者获取多条数据

192.168.106.80:6379> MSET key1 1 key2 2 key3 3

OK

192.168.106.80:6379> MGET key1 key2 key3

1) "1"

2) "2"

3) "3"

4/在插入一条string类型数据的同时为它指定一个存活期限

setex key seconds value

例如：

# bancao这条数据就只会存活10秒钟，过期会被redis自动清除

192.168.106.80:6379> setex bancao 10 testvalue

OK

192.168.106.80:6379> get bancao

"testvalue"

192.168.106.80:6379> get bancao

"testvalue"

192.168.106.80:6379> get bancao

(nil)

192.168.106.80:6379> get bancao

(nil)

案例：

其中maven项目的pom文件的内容如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>cn.toto.redis</groupId>

<artifactId>redistest</artifactId>

<version>0.0.1-SNAPSHOT</version>

<dependencies>

<!-- <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId>

<version>2.7.2</version> <type>jar</type> <scope>compile</scope> </dependency> -->

<dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

<version>2.8.0</version>

</dependency>

<dependency>

<groupId>com.google.code.gson</groupId>

<artifactId>gson</artifactId>

<version>2.3.1</version>

</dependency>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.7</version>

<scope>test</scope>

</dependency>

</dependencies>

</project>

代码：

package cn.toto.redis.client;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import org.junit.Before;

import org.junit.Test;

import com.google.gson.Gson;

import cn.toto.redis.bean.ProductInfo;

import redis.clients.jedis.Jedis;

public class StringStructureData {

private Jedis jedis = null;

@Before

public void init() {

//这里的是hadoop2可以用ip地址替换

jedis = new Jedis("hadoop2",6379);

}

@Test

public void testString() {

jedis.set("user02:name", "ruhua");

jedis.set("user03:name", "滑板鞋");

String u02 = jedis.get("user02:name");

String u03 = jedis.get("user03:name");

System.out.println(u02);

System.out.println(u03);

}

@Test

public void testObjectCache() throws Exception {

ProductInfo p = new ProductInfo();

p.setName("username");

p.setDescription("备注信息");

p.setCatelog("unknow");

p.setPrice(10.8);

//将对象序列化成字节数组

ByteArrayOutputStream ba = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(ba);

//用对象序列化流来将p对象序列化，然后把序列化之后的二进制数据写到ba流中

oos.writeObject(p);

//将ba流转成byte数组

byte[] pBytes = ba.toByteArray();

//将对象序列化之后的byte数组存到redis的string结构数组中

jedis.set("product:01".getBytes(), pBytes);

//根据key从redis中取出对象的byte数据

byte[] pBytesResp = jedis.get("product:01".getBytes());

//将byte数据反序列化列出对象

ByteArrayInputStream bi = new ByteArrayInputStream(pBytesResp);

ObjectInputStream oi = new ObjectInputStream(bi);

//从对象读取流中取出对象

ProductInfo pResp = (ProductInfo) oi.readObject();

System.out.println(pResp);

}

@Test

public void testObjectToJsonCache() {

ProductInfo p = new ProductInfo();

p.setName("ABC");

p.setDescription("刘亦菲专用");

p.setCatelog("化妆品");

p.setPrice(10.8);

//利用gson将对象转成json串

Gson gson = new Gson();

String pJson = gson.toJson(p);

//将json串存入redis

jedis.set("prodcut:02", pJson);

//从redis中取出对象的json串

String pJsonResp = jedis.get("prodcut:02");

//将返回的json解析成对象

ProductInfo pResponse = gson.fromJson(pJsonResp, ProductInfo.class);

//显示对象的属性

System.out.println(pResponse);

}

}

16、List数据结构（及Java调用处理）

16.1 List图示



16.2 List功能演示

#从头部（左边）插入数据

redis>LPUSH key value1 value2 value3

#从尾部（右边）插入数据

redis>RPUSH key value1 value2 value3

#读取list中指定范围的values

redis>LRANGE key start end

redis> lrange task-queue 0 -1 读取整个list

#从头部弹出一个元素

LPOP key

#从尾部弹出一个元素

RPOP key

#从一个list的尾部弹出一个元素插入到另一个list

RPOPLPUSH key1 key2 ## 这是一个原子性操作

例如下面的案例：

#从头部（左边）插入数据

192.168.106.81:6379> lpush task task0 task1 task2

(integer) 3

192.168.106.81:6379> lrange task 0 2

1) "task2"

2) "task1"

3) "task0"

192.168.106.81:6379> lrange task 0 -2

1) "task2"

2) "task1"

192.168.106.81:6379> lrange task 0 -1

1) "task2"

2) "task1"

3) "task0"

#从尾部（右边）插入数据

192.168.106.81:6379> rpush ids id0 id1 id2

(integer) 3

192.168.106.81:6379> lrange ids 0 -1

1) "id0"

2) "id1"

3) "id2"

192.168.106.81:6379> lpop ids

"id0"

192.168.106.81:6379> lpop ids

"id1"

192.168.106.81:6379> rpop task

"task0"

192.168.106.81:6379> rpoplpush task ids

"task1"

192.168.106.81:6379> lrange ids 0 -1

1) "task1"

2) "id2"

192.168.106.81:6379>

16.3 List的应用案例demo

1 需求描述

任务调度系统：

生产者不断产生任务，放入task-queue排队

消费者不断拿出任务来处理，同时放入一个tmp-queue暂存，如果任务处理成功，则清除tmp-queue，否则，将任务弹回task-queue



2 代码实现

1/生产者

——模拟产生任务

package cn.toto.redis.productAndCustomer;

import java.util.Random;

import java.util.UUID;

import redis.clients.jedis.Jedis;

public class TaskProducer {

//获取一个redis的客户端连接对象

public static Jedis getRedisConnection(String host,int port) {

Jedis jedis = new Jedis(host,port);

return jedis;

}

public static void main(String[] args) {

Jedis jedis = getRedisConnection("hadoop3", 6379);

Random random = new Random();

//生成任务

while(true) {

try {

//生成任务的速度有一定的随机性，在1-2秒之间

Thread.sleep(random.nextInt(1000) + 1000);

//生成一个任务

String taskid = UUID.randomUUID().toString();

//往任务队列"task-queue"中插入，第一次插入时，"task-queue"还不存在

//但是lpush方法会在redis库中创建一条新的list数据

jedis.lpush("task-queue", taskid);

System.out.println("向任务队列中插入了一个新的任务:" + taskid);

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

2/消费者

——模拟处理任务，并且管理暂存队列

package cn.toto.redis.productAndCustomer;

import java.util.Random;

import redis.clients.jedis.Jedis;

public class TaskConsumer {

public static void main(String[] args) {

Jedis jedis = new Jedis("hadoop3",6379);

Random random = new Random();

while(true) {

try {

//从task-queue中取一个任务，同时放入tmp-queue

String taskid = jedis.rpoplpush("task-queue", "tmp-queue");

//模拟处理任务

Thread.sleep(1000);

//模拟有成功又有失败的情况

int nextInt = random.nextInt(13);

if (nextInt % 7 == 0) {//模拟失败的情况

//在失败的情况下，需要将任务从tmp-queue弹回"task-queue"

jedis.rpoplpush("tmp-queue", "task-queue");

System.out.println("----任务处理失败:" + taskid);

} else {//模拟成功的情况

//成功的情况下，将任务从"tmp-queue"清除

jedis.rpop("tmp-queue");

System.out.println("任务处理成功:" + taskid);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

上述机制是一个简化版，真实版的任务调度系统会更加复杂，如下所示：

（增加了一个专门用来管理暂存队列的角色，以便就算消费者程序失败退出，那些处理失败的任务依然可以被弹回task-queue）



17、Hash数据结构

17.1 Hash图示

Redis中的Hashes类型可以看成具有String Key和String Value的map容器



17.2 Hash功能演示

1、往redis库中插入一条hash类型的数据

redis> HSET key field value

举例：

redis 127.0.0.1:6379> hset user001:zhangsan iphone 6

(integer) 1

redis 127.0.0.1:6379> hset user001:zhangsan xiaomi 7

(integer) 1

redis 127.0.0.1:6379> hset user001:zhangsan meizu 8

(integer) 1

在redis库中就形成了这样一条数据：



2、从redis库中获取一条hash类型数据的value

ü 取出一条hash类型数据中所有field-value对

redis 127.0.0.1:6379> hgetall user001:zhangsan

1) "iphone"

2) "6"

3) "xiaomi"

4) "7"

5) "meizu"

6) "8"

ü 取出hash数据中所有fields

redis 127.0.0.1:6379> HKEYS user001:zhangsan

1) "iphone"

2) "xiaomi"

3) "meizu"

ü 取出hash数据中所有的value

redis 127.0.0.1:6379> hvals user001:zhangsan

1) "6"

2) "7"

3) "8"

ü 取出hash数据中一个指定field的值

redis 127.0.0.1:6379> hget user001:zhangsan xiaomi

"8"

ü 为hash数据中指定的一个field的值进行增减

redis 127.0.0.1:6379> HINCRBY user001:zhangsan xiaomi 1

(integer) 8

ü 从hash数据中删除一个字段field及其值

redis 127.0.0.1:6379> hgetall user001:zhangsan

1) "iphone"

2) "6"

3) "xiaomi"

4) "7"

5) "meizu"

6) "8"

redis 127.0.0.1:6379> HDEL user001:zhangsan iphone

(integer) 1

redis 127.0.0.1:6379> hgetall user001:zhangsan

1) "xiaomi"

2) "7"

3) "meizu"

4) "8"

18、Set数据结构功能

集合的特点：无序、无重复元素

1、 插入一条set数据

redis 127.0.0.1:6379> sadd frieds:zhangsan bingbing baby fengjie furong ruhua tingting

(integer) 6

redis 127.0.0.1:6379> scard frieds:zhangsan

(integer) 6

redis 127.0.0.1:6379>

2、获取一条set数据的所有members

redis 127.0.0.1:6379> smembers frieds:zhangsan

1) "fengjie"

2) "baby"

3) "furong"

4) "bingbing"

5) "tingting"

6) "ruhua"

3、判断一个成员是否属于某条指定的set数据

redis 127.0.0.1:6379> sismember frieds:zhangsan liuyifei #如果不是，则返回0

(integer) 0

redis 127.0.0.1:6379> sismember frieds:zhangsan baby #如果是，则返回1

(integer) 1

4、求两个set数据的差集

#求差集

redis 127.0.0.1:6379> sdiff frieds:zhangsan friends:xiaotao

1) "furong"

2) "fengjie"

3) "ruhua"

4) "feifei"

#求差集，并将结果存入到另一个set

redis 127.0.0.1:6379> sdiffstore zhangsan-xiaotao frieds:zhangsan friends:xiaotao

(integer) 4

#查看差集结果

redis 127.0.0.1:6379> smembers zhangsan-xiaotao

1) "furong"

2) "fengjie"

3) "ruhua"

4) "feifei"

5、 求交集，求并集

#求交集

redis 127.0.0.1:6379> sinterstore zhangsan:xiaotao frieds:zhangsan friends:xiaotao

(integer) 2

redis 127.0.0.1:6379> smembers zhangsan:xiaotao

1) "bingbing"

2) "baby"

#求并集

redis 127.0.0.1:6379> sunion frieds:zhangsan friends:xiaotao

1) "fengjie"

2) "tangwei"

3) "liuyifei"

4) "bingbing"

5) "ruhua"

6) "feifei"

7) "baby"

8) "songhuiqiao"

9) "furong"

10) "yangmi"

案例代码：

package cn.toto.redis.hashcart;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.junit.Before;

import org.junit.Test;

import redis.clients.jedis.Jedis;

public class BuyCartServiceImpl {

private Jedis jedis = null;

private static final String CART_PRIFIX = "cart:";

@Before

public void init() {

jedis = new Jedis("hadoop3",6379);

}

/**

* 添加商品到购物车

*/

@Test

public void testAddItemToCart() {

jedis.hset(CART_PRIFIX + "user02", "上衣", "2");

jedis.hset(CART_PRIFIX + "user02", "鞋子", "1");

jedis.hset(CART_PRIFIX + "user02", "毛衣", "3");

jedis.hset(CART_PRIFIX + "user02", "羽绒服", "4");

jedis.close();

}

/**

* 查看购物车信息，当本类中的其它单元测试执行完成之后，可以通过执行这个单元测试方法查看内容

* @author toto

* @date 2017-1-14

* @note begin modify by 涂作权 2017-1-14 原始创建

*/

@Test

public void testGetCartInfo() {

Map<String, String> cart = jedis.hgetAll(CART_PRIFIX + "user02");

Set<Entry<String, String>> entrySet = cart.entrySet();

for(Entry<String, String> ent : entrySet) {

System.out.println(ent.getKey() + ":" + ent.getValue());

}

jedis.close();

}

/**

* 编辑缓存中的内容

*/

@Test

public void editCart() {

//给蜡烛商品项的数量加1

jedis.hincrBy(CART_PRIFIX + "user02", "羽绒服", 1);

jedis.close();

}

/**

* 删除内存中上衣这个内容

*/

@Test

public void delItemFromCart() {

jedis.hdel(CART_PRIFIX + "user02", "上衣");

jedis.close();

}

}

生产者消费者：

生产者：

package cn.toto.redis.listqueue;

import java.util.Random;

import java.util.UUID;

import redis.clients.jedis.Jedis;

public class TaskProducer {

private static Jedis jedis = null;

public static void main(String[] args) throws Exception {

jedis = new Jedis("hadoop2",6379);

Random random = new Random();

while(true) {

int nextInt = random.nextInt(1000);

Thread.sleep(1000 + nextInt);

//生成一个任务的id

String taskid = UUID.randomUUID().toString();

jedis.lpush("task-queue", taskid);

System.out.println("生成了一个任务:" + taskid);

}

}

}

消费者：

package cn.toto.redis.listqueue;

import java.util.Random;

import redis.clients.jedis.Jedis;

/**

* @brief TaskProcessor.java 任务处理模块

*/

public class TaskProcessor {

private static Jedis jedis = null;

public static void main(String[] args) throws Exception {

Random random = new Random();

jedis = new Jedis("hadoop2",6379);

while(true) {

Thread.sleep(1500);

//从任务队列中取出一个任务，同时放入到暂存队列中

String taskid = jedis.rpoplpush("task-queue", "tmp-queue");

//处理任务

if (random.nextInt(19) % 9 == 0) {

//模拟失败

//失败的情况下，需要将任务从暂存队列弹回任务队列

jedis.rpoplpush("tmp-queue", "task-queue");

System.out.println("该任务处理失败:" + taskid);

} else {

//模拟成功

//成功的情况下，只需要将任务从暂存队列清除

jedis.rpop("tmp-queue");

System.out.println("任务处理成功:" + taskid);

}

}

}

}

Set的案例：

package cn.toto.redis.set;

import java.util.Set;

import redis.clients.jedis.Jedis;

public class TestSet {

public static void main(String[] args) {

Jedis jedis = new Jedis("hadoop2",6379);

jedis.sadd("friends:shuangshuang", "dandan","lulu","lili");

jedis.sadd("friends:laobi", "laowang","laodu","laoli","lili","lulu");

//判断一个成员是否属于指定的集合

Boolean isornot = jedis.sismember("friends:laobi", "shuangshuang");

System.out.println(isornot);

//求两个集合的差并交集

Set<String> ssDiffbb = jedis.sdiff("friends:shuangshuang","friends:laobi");

Set<String> ssUnionbb = jedis.sunion("friends:shuangshuang","friends:laobi");

Set<String> ssInterbb = jedis.sinter("friends:shuangshuang","friends:laobi");

//打印结果

for (String mb : ssUnionbb) {

System.out.println(mb);

}

}

}

19、sortedSet（有序集合）数据结构

19.1 sortedSet图示

sortedset中存储的成员都有一个附带的分数值

而redis就可以根据分数来对成员进行各种排序（正序、倒序）

1、 sortedSet存储内容示意图：



19.2 SortedSet功能演示

1、往redis库中插入一条sortedset数据

redis 127.0.0.1:6379> zadd nansheng:yanzhi:bang 70 liudehua 90 huangbo 100 weixiaobao 250 yangwei 59 xiaotao

(integer) 5

2、 从sortedset中查询有序结果

#正序结果

redis 127.0.0.1:6379> zrange nansheng:yanzhi:bang 0 4

1) "xiaotao"

2) "liudehua"

3) "huangbo"

4) "weixiaobao"

5) "yangwei"

#倒序结果

redis 127.0.0.1:6379> zrevrange nanshen:yanzhi:bang 0 4

1) "yangwei"

2) "weixiaobao"

3) "huangbo"

4) "liudehua"

5) "xiaotao"

3、 查询某个成员的名次

#在正序榜中的名次

redis 127.0.0.1:6379> zrank nansheng:yanzhi:bang xiaotao

(integer) 0

#在倒序榜中的名次

redis 127.0.0.1:6379> zrevrank nansheng:yanzhi:bang xiaotao

(integer) 4

4、修改成员的分数

redis 127.0.0.1:6379> zincrby nansheng:yanzhi:bang 300 xiaotao

"359"

redis 127.0.0.1:6379> zrevrank nansheng:yanzhi:bang xiaotao

(integer) 0

案例：

下面的这个先运行：

package cn.toto.redis.sortedset;

import java.util.Random;

import redis.clients.jedis.Jedis;

public class LolBoxPlayer {

public static void main(String[] args) throws Exception {

Jedis jedis = new Jedis("hadoop2",6379);

Random random = new Random();

String[] heros = {"易大师","德邦","剑姬","盖伦","阿卡丽","金克斯","提莫","猴子","亚索"};

while(true) {

int index = random.nextInt(heros.length);

//选择一个英雄

String hero = heros[index];

//开始玩游戏

Thread.sleep(1000);

//给集合中的该英雄的出场次数加1

//第一次添加的时候，集合不存在，zincrby方法会创建

jedis.zincrby("hero:ccl:phb", 1, hero);

System.out.println(hero + "出场了......");

}

}

}

下面的这个后运行：

package cn.toto.redis.sortedset;

import java.util.Set;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.Tuple;

public class LolBoxViewer {

public static void main(String[] args) throws Exception {

Jedis jedis = new Jedis("hadoop2",6379);

int i = 1;

while(true) {

//每隔3秒查看一次榜单

Thread.sleep(3000);

System.out.println("第" + i + "次查看榜单-----------");

//从redis中查询榜单的前N名

Set<Tuple> topHeros = jedis.zrevrangeWithScores("hero:ccl:phb", 0, 4);

for (Tuple t : topHeros) {

System.out.println(t.getElement() + " " + t.getScore());

}

i++;

System.out.println("");

System.out.println("");

System.out.println("");

}

}

}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航