[大数据]Redis

Redis

一、NoSQL与RMDBS

1.1.1 Redis 简介

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

Redis 是完全开源的，遵守 BSD 协议，是一个高性能的 key-value 数据库。

Redis 与其他 key - value 缓存产品有以下三个特点：

• Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
• Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
• Redis支持数据的备份，即master-slave模式的数据备份。

1.1.2 Redis 优势

• 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
• 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
• 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
• 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

1.1.3 Redis与其他key-value存储有什么不同？

• Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。
• Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问

1.2.1 NoSQL 简介

NoSQL(NoSQL = Not Only SQL )，意即"不仅仅是SQL"。

在现代的计算系统上每天网络上都会产生庞大的数据量。

这些数据有很大一部分是由关系数据库管理系统（RMDBS）来处理。 1970年 E.F.Codd’s提出的关系模型的论文 “A relational model of data for large shared data banks”，这使得数据建模和应用程序编程更加简单。

通过应用实践证明，关系模型是非常适合于客户服务器编程，远远超出预期的利益，今天它是结构化数据存储在网络和商务应用的主导技术。

NoSQL 是一项全新的数据库革命性运动，早期就有人提出，发展至2009年趋势越发高涨。NoSQL的拥护者们提倡运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。

1.2.2 关系型数据库遵循ACID规则

事务在英文中是transaction，和现实世界中的交易很类似，它有如下四个特性：

1、A (Atomicity) 原子性

原子性很容易理解，也就是说事务里的所有操作要么全部做完，要么都不做，事务成功的条件是事务里的所有操作都成功，只要有一个操作失败，整个事务就失败，需要回滚。

比如银行转账，从A账户转100元至B账户，分为两个步骤：1）从A账户取100元；2）存入100元至B账户。这两步要么一起完成，要么一起不完成，如果只完成第一步，第二步失败，钱会莫名其妙少了100元。

2、C (Consistency) 一致性

一致性也比较容易理解，也就是说数据库要一直处于一致的状态，事务的运行不会改变数据库原本的一致性约束。

例如现有完整性约束a+b=10，如果一个事务改变了a，那么必须得改变b，使得事务结束后依然满足a+b=10，否则事务失败。

3、I (Isolation) 独立性

所谓的独立性是指并发的事务之间不会互相影响，如果一个事务要访问的数据正在被另外一个事务修改，只要另外一个事务未提交，它所访问的数据就不受未提交事务的影响。

比如现在有个交易是从A账户转100元至B账户，在这个交易还未完成的情况下，如果此时B查询自己的账户，是看不到新增加的100元的。

4、D (Durability) 持久性

持久性是指一旦事务提交后，它所做的修改将会永久的保存在数据库上，即使出现宕机也不会丢失。

1.2.3 分布式系统

分布式系统（distributed system）由多台计算机和通信的软件组件通过计算机网络连接（本地网络或广域网）组成。

分布式系统是建立在网络之上的软件系统。正是因为软件的特性，所以分布式系统具有高度的内聚性和透明性。

因此，网络和分布式系统之间的区别更多的在于高层软件（特别是操作系统），而不是硬件。

分布式系统可以应用在不同的平台上如：Pc、工作站、局域网和广域网上等。

1.2.4 分布式计算的优点

**可靠性（容错） ：**分布式计算系统中的一个重要的优点是可靠性。一台服务器的系统崩溃并不影响到其余的服务器。

**可扩展性：**在分布式计算系统可以根据需要增加更多的机器。

**资源共享：**共享数据是必不可少的应用，如银行，预订系统。

**灵活性：**由于该系统是非常灵活的，它很容易安装，实施和调试新的服务。

**更快的速度：**分布式计算系统可以有多台计算机的计算能力，使得它比其他系统有更快的处理速度。

**开放系统：**由于它是开放的系统，本地或者远程都可以访问到该服务。

**更高的性能：**相较于集中式计算机网络集群可以提供更高的性能（及更好的性价比）。

1.2.5 分布式计算的缺点

**故障排除：**故障排除和诊断问题。

**软件：**更少的软件支持是分布式计算系统的主要缺点。

**网络：**网络基础设施的问题，包括：传输问题，高负载，信息丢失等。

**安全性：**开放系统的特性让分布式计算系统存在着数据的安全性和共享的风险等问题。

1.2.6 什么是NoSQL?

NoSQL，指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。

NoSQL用于超大规模数据的存储。（例如谷歌或Facebook每天为他们的用户收集万亿比特的数据）。这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。

1.2.7 为什么使用NoSQL ?

今天我们可以通过第三方平台可以很容易的访问和抓取数据。用户的个人信息，社交网络，地理位置，用户生成的数据和用户操作日志已经成倍的增加。我们如果要对这些用户数据进行挖掘，那SQL数据库已经不适合这些应用了, NoSQL 数据库的发展却能很好的处理这些大的数据。

1.2.8 RDBMS vs NoSQL

RDBMS
- 高度组织化结构化数据
- 结构化查询语言（SQL） (SQL)
- 数据和关系都存储在单独的表中。
- 数据操纵语言，数据定义语言
- 严格的一致性
- 基础事务

NoSQL
- 代表着不仅仅是SQL
- 没有声明性查询语言
- 没有预定义的模式

• 键 - 值对存储，列存储，文档存储，图形数据库
  - 最终一致性，而非ACID属性
  - 非结构化和不可预知的数据
  - CAP定理
  - 高性能，高可用性和可伸缩性

1.2.9 NoSQL 简史

NoSQL一词最早出现于1998年，是Carlo Strozzi开发的一个轻量、开源、不提供SQL功能的关系数据库。

2009年，Last.fm的Johan Oskarsson发起了一次关于分布式开源数据库的讨论[2]，来自Rackspace的Eric Evans再次提出了NoSQL的概念，这时的NoSQL主要指非关系型、分布式、不提供ACID的数据库设计模式。

2009年在亚特兰大举行的"no:sql(east)“讨论会是一个里程碑，其口号是"select fun, profit from real_world where relational=false;”。因此，对NoSQL最普遍的解释是"非关联型的"，强调Key-Value Stores和文档数据库的优点，而不是单纯的反对RDBMS。

1.2.10 CAP定理（CAP theorem）

在计算机科学中, CAP定理（CAP theorem）, 又被称作 布鲁尔定理（Brewer’s theorem）, 它指出对于一个分布式计算系统来说，不可能同时满足以下三点:

• 一致性(Consistency) (所有节点在同一时间具有相同的数据)
• 可用性(Availability) (保证每个请求不管成功或者失败都有响应)
• 分隔容忍(Partition tolerance) (系统中任意信息的丢失或失败不会影响系统的继续运作)

CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求，最多只能同时较好的满足两个。

因此，根据 CAP 原理将 NoSQL 数据库分成了满足 CA 原则、满足 CP 原则和满足 AP 原则三 大类：

• CA - 单点集群，满足一致性，可用性的系统，通常在可扩展性上不太强大。
• CP - 满足一致性，分区容忍性的系统，通常性能不是特别高。
• AP - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。

1.2.11 NoSQL的优点/缺点

优点:

• - 高可扩展性
• - 分布式计算
• - 低成本
• - 架构的灵活性，半结构化数据
• - 没有复杂的关系

缺点:

• - 没有标准化
• - 有限的查询功能（到目前为止）
• - 最终一致是不直观的程序

1.2.12 BASE

BASE：Basically Available, Soft-state, Eventually Consistent。 由 Eric Brewer 定义。

CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求，最多只能同时较好的满足两个。

BASE是NoSQL数据库通常对可用性及一致性的弱要求原则:

• Basically Availble --基本可用
• Soft-state --软状态/柔性事务。 “Soft state” 可以理解为"无连接"的, 而 “Hard state” 是"面向连接"的
• Eventual Consistency – 最终一致性， 也是 ACID 的最终目的。

1.2.13 ACID vs BASE

1.2.14 NoSQL 数据库分类

二、Redis安装 （deepin v20 在线安装）

2.1 服务器端安装redise

sudo apt-get -y install redis

2.2 安装图形化客户端

windown 版本github地址https://github.com/lework/RedisDesktopManager-Windows

https://blog.csdn.net/cc20110101/article/details/87301562
http://www.cc123.net.cn
https://sourceforge.net/projects/redisview/files/
https://github.com/cc20110101/RedisView/releases
http://www.pc6.com/softview/SoftView_676493.html

三、Redis常用命令

3.1 redis常用数据结构

3.2 远程访问

#连接远程服务器 -h 远程服务器地址 -p 远程服务器端口号 --raw 避免中文乱码
redis-cli -h localhost -p 6379 --raw 

#检测redis服务是否启动 正常启动后响应信息为pong
ping

#查看信息 info [section]
info

#查看服务器信息
info Server

四、Redis添加认证

#修改配置文件
sudo vim /etc/redis/redis.conf 
#将配置文件中bing 127.0.0.1 ::1修改为bind 0.0.0.0 0:0:0:0:0:0:0:0指定任意主机都可以访问
#将配置文件中requirepass foobared 去掉注释 foobared修改为修改后的密码，例如requirepass 123456
#保存修改后的配置文件重启redis服务
sudo systemctl restart redis
#连接远程服务器 -h 远程服务器地址 -p 远程服务器端口号 -a 密码
redis-cli -h localhost -p 6379 --raw -a "123456"
#无密码连接远程服务器 -h 远程服务器地址 -p 远程服务器端口号
redis-cli -h localhost -p --raw 6379 
#连接成功后 使用密码认证 auth 密码 提示OK通过认证
auth 123456

#或者使用config命令
config set requirepass 123456
config get requirepass

五、 5种常见数据类型命令行操作

5.1 String

# 添加值 set key value ex 秒 nx 毫秒 ex或nx 可加可不加 ex 生存时间单位秒 nx 生存时间单位毫秒
# set 已经存在的key 则为修改该key对应的value值
set slogan 桃李不言下自成蹊 ex 30

#读取值 get key
get slogan

#del key
del slogan

#incr key key中存储的数字加1
set fans 999
incr fans

#decr key key中存储的数字减1 
decr fans

#incrby key 变化量
incrby fans 100

#decrby key 变化量
decrby fans 100

#setex seconds key 生存时间单位秒
setex 15311484568 30 6633 

#setnx key value 当这个key不存在的时候添加
setnx slogan 桃李不言下自成蹊 hash

#mset 批量存储mset key value [key value...]
#mget 批量读取mset key [key...]

5.2 hash

#hset key filed value
hset person nickname 李昊哲

#hset key filed value [filed value...] 批量存储
hmset person gender 1 birthday 1983-11-22

# hget key filed 单独读取对象属性
hget person nickname
hget person gender
hget person birthday

#hmget key filed [filed...] 批量读取对象属性
hmget person nickname gender birthday

5.3 list

#从开始index插入 lpush key value [value...]
lpush teacher 李昊哲 小文
#从结束index追加 rpush key value [value...]
#从开始index插入,如果key不存在什么都不做 如果key存在但是不是list结构什么都不做 lpushx key value [value...]
#从结束index追加,如果key不存在什么都不做 如果key存在但是不是list结构什么都不做 rpushx key value [value...]

#指定index插入数据 lset key index value[value]

#弹栈方式获取数据
lpop teacher
rpop teacher

#指定范围获取 lrange key start stop (start 从0开始 stop -1代表最后一个)
lpush teacher 李昊哲 小文 小刀 小二 小三
lrange teacher 0 -1

#lindex key index
lindex teacher 3

#获取整合列表从长度 llen key
llen teacher

#删除列表中count个的value lrem key count value
lrem teacher 0 小二

# ltrim key start stop 保留范围 范围外的全部删除

5.4 set

#sadd key value [value...] 存储数据
sadd courses java html css javascript

#获取全部数据 smember key
smembers courses

#获取交集sinter set1 set2...

#获取并集sunion set1 set2...

#获取差集sdiff set1 set2...

#srem key value 删除集合中的数据
#sismember key member 集合中是否存在某value
smembers courses java

5.5 zset

#zadd key score member [score member...]
zadd salary 2000 小二  3000 小三  4000 小四  5000 小五

#zincrby key score member
zincrby salary 1000 小五
zincrby salary 6000 小六

#zcard key

#zcount key min max

#zrem key member

#zrange key start stop [withscores]
zrange salary 0 -1 
zrange salary 0 -1 withscores

#zrevrange key start stop [withscores]
zrevrange salary 0 -1
zrevrange salary 0 -1 withscores

#zrangebyscore key min max [withscores]
zrangebyscore salary 1000 8000 limit 0 2
zrangebyscore salary 1000 8000 withscores limit 0 2

#zrevrangebyscore key min max [withscores]
zrangebyscore salary 1000 8000 limit 0 2
zrangebyscore salary 1000 8000 withscores limit 0 2

六、 key的常用命令

#查看全部的key keys pattern
keys *

#查看某一个key是否存在 exists key
exists teacher

#删除kek  del key
del teacher

#设置生存时间
expire key seconds
pexpire key millisseconds

#设置生存时间 时间戳 
expireat key timestap
pexpireat key millisseconds

#ttl key 剩余生存时间(返回-2当前key不存在 返回-1当前key没有设施生存时间)
ttl key
pttl key

#persist key 移除生存时间

七、 数据库操作命令

#select 0~15 使用哪个库
select 1

#移动key到那个库move key db

#清空当前所在数据库
flushdb

#清空全部数据库
flushall

#查看当前库有多少个key
dbsize

#最后一次操作
lastsave

#实时监控redis接受到的命令
monitor

八、 java连接Redis

8.1 编写pojo类便于测试

package cn.kgc.tantcco.pojo;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import java.io.Serializable;
import java.util.Date;

/**
 * @author 李昊哲
 * @Description
 * @create 2020/10/5 12:42
 */
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class Person implements Serializable {
    private static final long serialVersionUID = 5880156611749342161L;
    private String nickname;
    private Integer gender;
    @JSONField(format="yyyy-MM-dd")
    private Date birthday;
}

8.2 编写工具类

package cn.kgc.tantcco.utils.redis;

import cn.hutool.setting.dialect.Props;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/**
 * @author 李昊哲
 * @Description
 * @create 2020/10/5 11:45
 */
public abstract class BaseJedisUtil {
    private static ThreadLocal<Jedis> t = new ThreadLocal<Jedis>();
    private static Props props = new Props("redis.properties");
    private static String host = props.getProperty("host");
    private static String port = props.getProperty("port");
    private static String password = props.getProperty("password");
    private static String timeout = props.getProperty("timeout");
    private static String maxTotal = props.getProperty("maxTotal");
    private static String database = props.getProperty("database");

    /**
     * 获取redis客户端 Jedis对象
     * @return
     */
    public static Jedis getClient(){
        if (t.get() != null) {
            return t.get();
        }
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setMaxTotal(Integer.parseInt(maxTotal));
        JedisPool jedisPool = new JedisPool(config,host,Integer.parseInt(port),Integer.parseInt(timeout),password,Integer.parseInt(database));
        Jedis jedis = jedisPool.getResource();
        t.set(jedis);
        return  jedis;
    }
    public static Jedis getClient(int database){
        if (t.get() != null) {
            return t.get();
        }
        if (database < 0) {
            database = 0;
        } else if (database > 15){
            database = 15;
        }
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setMaxTotal(Integer.parseInt(maxTotal));
        JedisPool jedisPool = new JedisPool(config,host,Integer.parseInt(port),Integer.parseInt(timeout),password,database);
        Jedis jedis = jedisPool.getResource();
        t.set(jedis);
        return  jedis;
    }

    /**
     * 释放资源
     */
    public static void close(){
        getClient().close();
    }
}

8.3 编写测试类测试

package cn.kgc.tangcco.redis;

import cn.binarywang.tools.generator.ChineseNameGenerator;
import cn.kgc.tantcco.pojo.Person;
import cn.kgc.tantcco.utils.redis.BaseJedisUtil;
import com.alibaba.fastjson.JSON;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.junit.Test;
import org.springframework.util.SerializationUtils;
import redis.clients.jedis.*;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @author 李昊哲
 * @Description
 * @create 2020/10/5 11:37
 */
public class JedisTest {
    @Test
    public void conn() {
        Jedis jedis = new Jedis("172.16.0.6", 6379, 60);
        jedis.auth("123456");
        System.out.println(jedis.ping());
        jedis.close();
    }

    @Test
    public void pool() {
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setMaxTotal(160);
        JedisPool jedisPool = new JedisPool(config, "172.16.0.6", 6379, 30, "123456", 15);
        Jedis jedis = jedisPool.getResource();
        System.out.println(jedis.ping());
        jedis.close();
    }

    @Test
    public void getClient() {
        Jedis client = BaseJedisUtil.getClient();
        System.out.println(client.ping());
        BaseJedisUtil.close();
    }

    @Test
    public void opString() {
        Jedis jedis = BaseJedisUtil.getClient();
        jedis.set("slogan", "桃李不言下自成蹊");
        // 设置key的生存时间
        jedis.expire("slogan", 30);
        String slogan = jedis.get("slogan");
        BaseJedisUtil.close();
        System.out.println(slogan);
    }

    @Test
    public void opStringWithByte() {
        Person person = new Person("李昊哲", 1, new Date());
        Jedis jedis = BaseJedisUtil.getClient();
        jedis.set(SerializationUtils.serialize("李昊哲"), SerializationUtils.serialize(person));
        // 设置key的生存时间
        // jedis.expire("slogan",30);
        Person value = (Person) SerializationUtils.deserialize(jedis.get(SerializationUtils.serialize("李昊哲")));
        jedis.del(SerializationUtils.serialize("李昊哲"));
        BaseJedisUtil.close();
        System.out.println(JSON.toJSONString(value));
    }

    @Test
    public void opStringWithJSon() {
        Person person = new Person("李昊哲", 1, new Date());
        Jedis jedis = BaseJedisUtil.getClient();
        jedis.set("李昊哲", JSON.toJSONString(person));
        // 设置key的生存时间
        // jedis.expire("slogan",30);
        Person value = JSON.parseObject(jedis.get("李昊哲"), Person.class);
        jedis.del("李昊哲");
        BaseJedisUtil.close();
        System.out.println(JSON.toJSONString(value));
    }

    @Test
    public void list() {
        List<String> jsonList = new ArrayList<String>();
        ChineseNameGenerator instance = ChineseNameGenerator.getInstance();
        for (int i = 0; i < 10; i++) {
            jsonList.add(JSON.toJSONString(new Person(instance.generate(), ThreadLocalRandom.current().nextInt(2), new Date())));

        }
        String[] params = new String[jsonList.size()];
        for (int i = 0; i < jsonList.size(); i++) {
            params[i] = jsonList.get(i);
        }
        Jedis jedis = BaseJedisUtil.getClient();
        Pipeline pipeline = jedis.pipelined();
        pipeline.lpush("persons", params);
        // 设置key的生存时间
        pipeline.expire("persons", 60);
        Response<Long> response = pipeline.llen("persons");
        pipeline.close();
        List<String> list = jedis.lrange("persons", 0, response.get());
        // jedis.del("persons");
        BaseJedisUtil.close();
        list.forEach(text -> System.out.println(text));
    }

    @Test
    public void transaction() {
        Jedis jedis = BaseJedisUtil.getClient();
        Transaction transaction = jedis.multi();
        try {
            transaction.set("ka", "va");
            transaction.set("kb", "vb");
            // int num = 1 / 0;
            transaction.set("kc", "vc");
            transaction.exec();
            System.out.println("提交事务");
        } catch (Exception e) {
            transaction.discard();
            System.out.println("事务回滚");
        }

    }
}

九、 Redis持久化

9.1 RDB

sudo vim /etc/redis/redis.conf

save 900 1
save 300 10
save 60 10000

rdbcompression yes
dbfilename dump.rdb
dir /var/lib/redis

9.2 AOF

sudo vim /etc/redis/redis.conf
appendonly yes

appendfilename "appendonly.aof"

#每次key被修改都会被持久化
#appendfsync always
#每秒钟持久化一次
appendfsync everysec
#根据部署环境不同不定期持久化
#appendfsync no

十、 事务

#multi 开启事务队列
#exec 提交事务执行队列
#discard 事务取消清空队列
#watch监听一个或多个key 被监听的key开启事务后被监听的key改变提交队列 被监听的key开启时候后没有执行事务 另外一个session修改了被监听的key 事务自动取消
#unwatch取消监听

tem.out.println(“提交事务”);
} catch (Exception e) {
transaction.discard();
System.out.println(“事务回滚”);
}

}

}

### 九、 Redis持久化

#### 9.1 RDB

```shell
sudo vim /etc/redis/redis.conf

save 900 1
save 300 10
save 60 10000

rdbcompression yes
dbfilename dump.rdb
dir /var/lib/redis

9.2 AOF

sudo vim /etc/redis/redis.conf
appendonly yes

appendfilename "appendonly.aof"

#每次key被修改都会被持久化
#appendfsync always
#每秒钟持久化一次
appendfsync everysec
#根据部署环境不同不定期持久化
#appendfsync no

十、 事务

#multi 开启事务队列
#exec 提交事务执行队列
#discard 事务取消清空队列
#watch监听一个或多个key 被监听的key开启事务后被监听的key改变提交队列 被监听的key开启时候后没有执行事务 另外一个session修改了被监听的key 事务自动取消
#unwatch取消监听