NoSQL，指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。
NoSQL用于超大规模数据的存储。（例如谷歌或Facebook每天为他们的用户收集万亿比特的数据）。这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。

随着大数据时代的到来，越来越多的网站、应用系统需要支撑海量数据存储，高并发请求、高可用、高可扩展性等特性要求，传统的关系型数据库在应付这些调整已经显得力不从心，暴露了许多能以克服的问题。由此，各种各样的NoSQL（Not Only SQL）数据库作为传统关系型数据的一个有力补充得到迅猛发展。

• 1、NoSQL的优点
• 灵活性：NoSQL 数据库通常提供灵活的架构，以实现更快速、更多的迭代开发。灵活的数据模型使 NoSQL 数据库成为半结构化和非结构化数据的理想之选。
• 可扩展性：NoSQL 数据库通常被设计为通过使用分布式硬件集群来横向扩展，而不是通过添加昂贵和强大的服务器来纵向扩展。一些云提供商在后台将这些操作处理为完全托管服务。
• 高性能：NoSQL 数据库针对特定的数据模型（如文档、键值和图形）和访问模式进行了优化，这与尝试使用关系数据库完成类似功能相比可实现更高的性能。
• 强大的功能：NoSQL 数据库提供功能强大的 API 和数据类型，专门针对其各自的数据模型而构建。
• 2、NoSQL缺点
• 没有标准化
• 有限的查询功能（到目前为止）
• 最终一致是不直观的程序

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。
Redis 与其他 key - value 缓存产品有以下三个特点：

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

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

• 1、windows安装redis
  这个安装比较简单，网上百度下即可。
  启动时候先启动服务端redis-server.exe，再启动客户端redis-cli.exe。
  上面虽然启动了redis服务，但是，只要一关闭cmd窗口，redis服务就关闭了。所以，把redis设置为一个windows服务。安装之前，windows服务是不包含redis服务的。
  我给个参考链接：https://www.cnblogs.com/dingguofeng/p/8709476.html
• 2、Linux安装redis
  我是通过kubernetes(k8s)使用redis的docker镜像安装的redis，如果没有k8s环境的小伙伴，可以到网上百度下安装方法。
  a)创建redis-rc.yaml文件，

apiVersion: v1
kind: ReplicationController
metadata:
  name: redis
spec:
   replicas: 1
   selector:
     app: redis
   template:
     metadata:
       labels:
         app: redis
     spec:
       containers:
       - name: redis
         image: redis
         resources:
           requests:
             cpu: 100m
             memory: 100Mi
         ports:
         - containerPort: 6379

b)创建redis-svc.yaml文件

apiVersion: v1
kind: Service
metadata:
  name: redis
spec:
  type: NodePort
  ports:
   - port: 6379
     nodePort: 30009
  selector:
    app: redis

c)kubectl运行下上面的yaml文件即可创建redis

查看下是否创建成功，

下面访问下是否可以使用，

可以正常访问并存储和读取数据。

命令这块网上有很多例子，大家可以百度下，建议每个命令都实地执行 下。
常用命令链接：https://www.runoob.com/redis/redis-commands.html
下面只说下常用的命令如下：

• 1、查询所有的key
  redis 127.0.0.1:6379> keys *
• 2、查询以xxx开头的所有Key，例如，下面查询所有以user开头的所有的key。
  redis 127.0.0.1:6379> keys user*
• 3、判断xxx这个key是否存在，使用exists关键字，如下，usermap存在返回值为1，testmao不存在返回0
  redis 127.0.0.1:6379> exists usermap
  (integer) 1
  redis 127.0.0.1:6379> exists testmap
  (integer) 0
• 4、修改某个key的名字，使用rename
  redis 127.0.0.1:6379> rename usermap umsp
  OK
  redis 127.0.0.1:6379> keys u*

1. “umsp”
2. “userset”
3. “username”
4. “userlist”
   redis 127.0.0.1:6379>

• 5、设置Key的超时时间，超时的key将不会被keys查询到
  redis 127.0.0.1:6379> keys u*

1. “umsp”
2. “userset”
3. “username”
4. “userlist”
   redis 127.0.0.1:6379> expire umsp 1 -->expire设置超时时间
   (integer) 1
   redis 127.0.0.1:6379> ttl umsp -->返回的值是还剩余多少超时时间
   (integer) 5
   redis 127.0.0.1:6379> ttl umsp
   (integer) 2
   redis 127.0.0.1:6379> ttl umsp
   (integer) 0
   redis 127.0.0.1:6379> ttl umsp
   (integer) -1
   redis 127.0.0.1:6379> keys u* -->查询不到超时的key
5. “userset”
6. “username”
7. “userlist”

• 6、获取某个key的数据类型
  redis 127.0.0.1:6379> type username
  string
  redis 127.0.0.1:6379> type userlist
  list
  redis 127.0.0.1:6379> type userset
• 7、获取数据库信息及其统计信息
  redis 127.0.0.1:6379> info
  redis_version:2.6.12
  redis_git_sha1:00000000
  redis_git_dirty:0
  redis_mode:standalone
  os:Windows
  arch_bits:64
  multiplexing_api:winsock_IOCP
  gcc_version:0.0.0
  process_id:7140

redis默认有16个数据库，从0~15库，默认情况下使用0库

• 1 切换数据库，关键字select
  redis 127.0.0.1:6379> select 1
  OK
  redis 127.0.0.1:6379[1]> select 6
  OK
  redis 127.0.0.1:6379[6]> select 9
  OK
  redis 127.0.0.1:6379[9]>
  …
  redis 127.0.0.1:6379[8]> select 16 -->这里说明确实只存在16个库，索引从0开始
  (error) ERR invalid DB index
  redis 127.0.0.1:6379[16]> select 15
  OK
  redis 127.0.0.1:6379[15]>
• 2 切换数据库，关键字move
  例如，redis-0库中存在age这个key，而redis-14库不存在
  redis 127.0.0.1:6379> keys *

1. “stuset”
2. “username”
3. “jiaoset”
4. “jsondemo”
5. “usermap”
6. “age”
7. “userlist”
8. “stumap”
9. "xacxedx00x05tx00x03sex
10. “userset”
    下面把这个age移动到redis-14数据库中，使用Move关键字，
    redis 127.0.0.1:6379[14]> select 0
    OK
    redis 127.0.0.1:6379> move age 14
    (integer) 1
    redis 127.0.0.1:6379> select 14
    OK
    redis 127.0.0.1:6379[14]> keys *
11. “age”
    redis 127.0.0.1:6379[14]>

• 3 删除数据库中所有的key和删除当前数据库的key
  特别提醒：这个命令无论在哪个redis-xx数据库中执行都会删除所有库里面的所有key，慎重使用。
  redis 127.0.0.1:6379[8]> keys *

1. “test8redis”
2. “plist”
   redis 127.0.0.1:6379[8]> flushall -->删除数据库中所有key
   OK
   redis 127.0.0.1:6379[8]> keys *
   (empty list or set)
   redis 127.0.0.1:6379[8]> select 0
   OK
   redis 127.0.0.1:6379> keys *
   (empty list or set)
   redis 127.0.0.1:6379>
   redis 127.0.0.1:6379[1]> flushdb -->删除当前数据库中的所有key
   OK

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。
Redis 客户端可以订阅任意数量的频道。
下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

实例
以下实例演示了发布订阅是如何工作的。在我们实例中我们创建了订阅频道名为 redisChat:
redis 127.0.0.1:6379> SUBSCRIBE redisChat
Reading messages… (press Ctrl-C to quit)

1. “subscribe”
2. “redisChat”
3. (integer) 1

现在，我们先重新开启个 redis 客户端，然后在同一个频道 redisChat 发布两次消息，订阅者就能接收到消息。
redis 127.0.0.1:6379> PUBLISH redisChat “Redis is a great caching technique”
(integer) 1
redis 127.0.0.1:6379> PUBLISH redisChat “Learn redis by runoob.com”
(integer) 1

订阅者的客户端会显示如下消息

1. “message”
2. “redisChat”
3. “Redis is a great caching technique”
4. “message”
5. “redisChat”
6. “Learn redis by runoob.com”

Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：
批量操作在发送 EXEC 命令前被放入队列缓存。
收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。
一个事务从开始到执行会经历以下三个阶段：

• 开始事务。
• 命令入队。
• 执行事务。

以下是一个事务的例子， 它先以 MULTI 开始一个事务， 然后将多个命令入队到事务中， 最后由 EXEC 命令触发事务， 一并执行事务中的所有命令：
redis 127.0.0.1:6379> MULTI
OK
redis 127.0.0.1:6379> SET book-name “Mastering C++ in 21 days”
QUEUED
redis 127.0.0.1:6379> GET book-name
QUEUED
redis 127.0.0.1:6379> SADD tag “C++” “Programming” “Mastering Series”
QUEUED
redis 127.0.0.1:6379> SMEMBERS tag
QUEUED
redis 127.0.0.1:6379> EXEC

1. OK
2. “Mastering C++ in 21 days”
3. (integer) 3
4. 1. “Mastering Series”
   2. “C++”
   3. "Programming
      备注：
      单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。
      事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

这里主要讲解下非springboot项目如何通过Jedis访问redis数据库，实现方法大体下6.2.1的通过jedis访问redis数据库类似。

• 6.1.1、使用IDE创建Java工程，点击next即可
  
• 6.1.2、添加lib和bin目录
  lib用于存放jar文件
  bin用于存放工程的输出文件
• 6.1.3、下载依赖jar文件
  本次需要用到如下三个Jar文件：
  commons-pool2-2.6.2.jar
  jedis-3.1.0.jar
  slf4j-api-1.7.25.jar
  下载地址：https://mvnrepository.com/artifact/redis.clients/jedis
  点击上面的下载地址进去，
  
  按照如下图示操作，即可下载三个jar文件
  
• 6.1.4 设置java工程的输出目录，编译级别，引入外部jar文件
  -打开project structure窗口，如下
  
  a) 设置project language level和project complier output
  
  b)、点击Dependencies–>点击右边的加号±->JARS or directories，在打开的创建选择要使用的jar文件即可。
  
• 6.1.5 在src目录下面添加redis.properties

#redis jedis配置
# Redis数据库索引（默认为0）
redis.database=0
# Redis服务器地址
redis.host=127.0.0.1
# Redis服务器连接端口
redis.port=6379
# Redis服务器连接密码（默认为空）
#redis.password=
# 连接池最大连接数（使用负值表示没有限制）
redis.jedis.pool.max-active=200
# 连接池最大阻塞等待时间（使用负值表示没有限制）
redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
redis.jedis.pool.min-idle=3
# 连接超时时间（毫秒）
redis.timeout=0

• 6.1.6 编写Jedis2RedisClient代码
  a) 创建com.nick.jedis.demo.Jedis2RedisClient.java文件
  b) Jedis2RedisClient内容如下，

package com.nick.jedis.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @author Nick
 */
public class Jedis2RedisClient {

    private static JedisPool jedisPool;

    static {
        Properties props = new Properties();
        InputStream in = Jedis2RedisClient.class.getResourceAsStream("/redis.properties");
        try {
            props.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //创建jedis池配置实例
        String maxActive = props.getProperty("redis.jedis.pool.max-active");
        String maxWaitMillis = props.getProperty("redis.jedis.pool.max-wait");
        String maxIdle = props.getProperty("redis.jedis.pool.max-idle");
        String minIdle = props.getProperty("redis.jedis.pool.min-idle");
        String host = props.getProperty("redis.host");
        String port = props.getProperty("redis.port");
        String password = props.getProperty("redis.password");
        String timeout = props.getProperty("redis.timeout");

        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(Integer.valueOf(maxIdle));
        jedisPoolConfig.setMaxWaitMillis(Integer.valueOf(maxWaitMillis));
        jedisPoolConfig.setMaxTotal(Integer.valueOf(maxActive));
        jedisPoolConfig.setMinIdle(Integer.valueOf(minIdle));
        jedisPool = new JedisPool(jedisPoolConfig,host,Integer.valueOf(port),Integer.valueOf(timeout),password);
        System.out.println("JedisPool注入成功！");
        System.out.println("redis地址：" + host + ":" + port);
    }

    public static Jedis getResource() {
        return jedisPool.getResource();
    }

    @Deprecated
    public static void returnResource(Jedis jedis) {
        if (jedis != null){
            jedis.close();
        }
    }

    public static void main(String[] args) throws IOException {
        Jedis jedis = null;
        jedis = getResource();
        jedis.set("wangteng", "Hello World");
        System.out.println("向redis插入数据成功.........");
        String value = jedis.get("wangteng");
        System.out.println("从redis数据库中获取数据，key=wangteng， value=" + value);
    }
}
备注：
这里建议导入下
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
以上两个文件依赖，否则，会导致报错“SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder"”
但是，报错信息不影响操作redis数据库。

至此本章节就讲解完了，有疑问的读者欢迎留言讨论。

操作方法：

• 1、创建springboot项目，添加web,redis依赖starter
  
• 2、在pom.xml文件中添加依赖

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

这里补充说明下，如果项目中添加了spring­-boot-­starter-­data­-redis这个启动器，在springboot2.xx之后的版本，这个启动器由原来springboot 1.xx版本的jedis修改为lettuce来实现访问redis数据库的。如果非要使用jedis访问的话，可以exclusion去掉lettuce，然后手动添加jedis。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring­boot­starter­data­redis</artifactId>
            <!--springboot2.o默认使用的redis客户端是lettuce -->
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce­core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

• 3、配置redis数据库信息
  在application.properties配置文件中添加如下内容，redis数据库地址，端口根据实际情况填写，

#redis jedis配置
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
#spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=200
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=3
# 连接超时时间（毫秒）
spring.redis.timeout=0
#spring-session 使用
spring.session.store-type=none

• 4、创建Jedis配置类
  创建Jedis配置类，配置类的作用是在项目启动的时候将jedis注入，接着我们就可以在其他类中获取到JedisPool类的信息。
  在com.nick.config目录下创建RedisConfig.java

package com.nick.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.security.PrivilegedAction;

@Configuration
@EnableAutoConfiguration
public class RedisConfig extends CachingConfigurerSupport {
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

    @Bean
    public JedisPool redisPoolFactory(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        jedisPoolConfig.setMaxTotal(maxActive);
        jedisPoolConfig.setMinIdle(minIdle);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig,host,port,timeout,null);
        System.out.println("JedisPool注入成功！");
        System.out.println("redis地址：" + host + ":" + port);
        return  jedisPool;
    }
}

在此springboot项目启动的时候在控制台可以看到上面打印的日志“JedisPool注入成功“。
至此，已经连接上redis数据库，接下来就可以使用了。
可以直接创建一个进行redis数据库操作的工具类xxxUtils.java或者以接口服务的形式实现，然后使用xxxController.java的形式调用。

• 5、声明redis服务接口类及其实现类
  –>RedisService.java

package com.nick.service;

import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import redis.clients.jedis.Jedis;

import java.util.Set;

public interface RedisService  {
    public Jedis getResource();
    public void returnResource(Jedis jedis);
    public String set(String key, String value);
    public String get(String key);
    public String type(String key);
    public Set<String> keysBySelect(String pattern, int database);
    public Set<String> keys(String pattern);
}

–>RedisServiceImpl.java

package com.nick.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.Set;

@Service
public class RedisServiceImpl implements RedisService{

    @Autowired
    private JedisPool jedisPool;


    @Override
    public Jedis getResource() {
        return jedisPool.getResource();
    }

    @Override
    public void returnResource(Jedis jedis) {
        if (jedis != null){
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 向redis插入string类型的数据
     * @param key value
     * @return String
     */
    @Override
    public String set(String key, String value) {
        Jedis jedis = null;
        String result = null;
        try {
            jedis = jedisPool.getResource();
            result = jedis.set(key, value);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            result = "0";
        } finally {
            returnResource(jedis);
            return result;
        }
    }

    /**
     * 返回指定Key的value值
     * @param key
     * @return String
     */
    @Override
    public String get(String key) {
        Jedis jedis = null;
        String result = null;
        try {
            jedis = jedisPool.getResource();
            result = jedis.get(key);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            returnResource(jedis);
            return result;
        }
    }

    /**
     * 返回指定Key的数据类型
     * @param key
     * @return String
     */
    @Override
    public String type(String key) {
        Jedis jedis = null;
        String result = null;
        try {
            jedis = jedisPool.getResource();
            result = jedis.type(key);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            returnResource(jedis);
            return result;
        }
    }

    /**
     * 返回满足pattern和指定redis数据库的所有key
     * @param pattern
     * @return Set<String>
     */
    @Override
    public Set<String> keysBySelect(String pattern, int database) {
        Jedis jedis = null;
        Set<String> result = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(database);
            result = jedis.keys(pattern);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            returnResource(jedis);
            return result;
        }
    }

    /**
     * 返回满足pattern的所有key
     * @param pattern
     * @return Set<String>
     */
    @Override
    public Set<String> keys(String pattern) {
        Jedis jedis = null;
        Set<String> result = null;
        try {
            jedis = jedisPool.getResource();
            result = jedis.keys(pattern);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            returnResource(jedis);
            return result;
        }
    }
}

• 6、发布rest服务接口
  –>RedisController.java

package com.nick.controller;

import com.nick.service.RedisService;
import jdk.nashorn.internal.ir.ReturnNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class RedisController {

    @Autowired
    private RedisService redisService;

    @RequestMapping("set")
    public String set(String key, String value){
        System.out.println("-----开始写入----");
        String result = redisService.set(key,value);
        System.out.println("-----写入-------成功----");
        return  result;

    }

    @RequestMapping("get")
    public String get(String key){
        String result = redisService.get(key);
        System.out.println("---------key=" + key+", value=" + result);
        return redisService.get(key);
    }

    @RequestMapping("type")
    public String type(String key){
        String result = redisService.type(key);
        return result;
    }

}

• 7、启动主程序类，然后访问下rest接口
  
  至此完成了springboot通过Jedis访问redis数据库的操作。

这个可以参考我的另一个博客地址的示例学习下，
https://blog.csdn.net/qq_34533957/article/details/97981189#74_Springbootredis_1944