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、两者在不断地取长补短，呈现融合趋势
Redis是一个高性能的kv对缓存和内存数据库(存的不像mysql那样的表)
Redis的存储结构就是key-value，形式如下：
注： redis中的value内部可以支持各种数据结构类型，比如可以存入一个普通的string，还可以存list，set，hashmap，sortedSet（有序的set）
A、用来做缓存(ehcache/memcached)——redis的所有数据是放在内存中的（内存数据库）
B、可以在某些特定应用场景下替代传统数据库——比如社交类的应用
C、在一些大型系统中，巧妙地实现一些特定的功能：session共享、购物车
只要你有丰富的想象力，redis可以用在可以给你无限的惊喜…….
1、redis数据访问速度快（数据在内存中）
2、redis有数据持久化机制（持久化机制有两种：1、定期将内存数据dump到磁盘；2、aof(append only file)持久化机制——用记日志的方式记录每一条数据更新操作，一旦出现灾难事件，可以通过日志重放来恢复整个数据库）
3、redis支持集群模式（容量可以线性扩展）
4、redis相比其他缓存工具（ehcach/memcached），有一个鲜明的优势：支持丰富的数据结构
新建一个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);
}
}
(常作为缓存使用)
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);
}
}
#从头部（左边）插入数据
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>
任务调度系统：
生产者不断产生任务，放入task-queue排队
消费者不断拿出任务来处理，同时放入一个tmp-queue暂存，如果任务处理成功，则清除tmp-queue，否则，将任务弹回task-queue
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）
Redis中的Hashes类型可以看成具有String Key和String Value的map容器
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"
集合的特点：无序、无重复元素
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);
}
}
}
sortedset中存储的成员都有一个附带的分数值
而redis就可以根据分数来对成员进行各种排序（正序、倒序）
1、 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("");
}
}
}
