1 .初识Redis

Redis是一种键值型的NoSql数据库，这里有两个关键字：

   键值型

   NoSql

其中键值型，是指Redis中存储的数据都是以key、value对的形式存储，而value的形 式多种多样，可以是字符串、数值、甚至json：

而NoSql则是相对于传统关系型数据库而言，有很大差异的一种数据库。

1 .1 .认识NoSQL

NoSql可以翻译做Not  Only  Sql  （不仅仅是SQL），或者是No  Sql （非Sql的）数据   库。是相对于传统关系型数据库而言，有很大差异的一种特殊的数据库，因此也称之为非关系型数据库。

1 .1 .1 .结构化与非结构化

传统关系型数据库是结构化数据，每一张表都有严格的约束信息：字段名、字段数据类 型、字段约束等等信息，插入的数据必须遵守这些约束：

而NoSql则对数据库格式没有严格约束，往往形式松散，自由。

可以是键值型：

也可以是文档型：

甚至可以是图格式：

1 .1 .2 .关联和非关联

传统数据库的表与表之间往往存在关联，例如外键：

 非关系型数据库不存在关联关系，要维护关系要么靠代码中的业务逻辑，要么靠数据之间的耦合

{
   id:  1 ,
   name:  "张三 " ,
   orders:  [
  {
     id:  1 ,
     item:  {
     id:  10 ,  title:  "荣耀6" ,  price :  4999
        }
  },
  {
     id:  2 ,
     item:  {
     id:  20 ,  title:  "小米11" ,  price :  3999
        }
   }
   ]
}

此处要维护 “张三 ”的订单与商品 “荣耀 ”和 “小米11”的关系，不得不冗余的将这两个商品 保存在张三的订单文档中，不够优雅。还是建议用业务来维护关联关系。

1 .1 .3 .查询方式

传统关系型数据库会基于Sql语句做查询，语法有统一标准；

而不同的非关系数据库查询语法差异极大，五花八门各种各样。

1 .1 .4 .事务

传统关系型数据库能满足事务ACID的原则。

 

而非关系型数据库往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致 性。 

1 .1 .5 .总结

除了上述四点以外，在存储方式、扩展性、查询性能上关系型与非关系型也都有着显著差 异，总结如下：

  存储方式

○    关系型数据库基于磁盘进行存储，会有大量的磁盘IO，对性能有一定影响

○    非关系型数据库，他们的操作更多的是依赖于 内存 来操作，内存的读写速度会非常快，性能自然会好一些

  扩展性

○    关系型数据库集群模式一般是主从，主从数据一致，起到数据备份的作用，称为 垂直扩展 。

○    非关系型数据库可以将数据拆分，存储在不同机器上，可以保存海量数据，解决内存大小有限的问题。称为 水平扩展 。

○    关系型数据库因为表之间存在关联关系，如果做水平扩展会给数据查询带来很多 麻烦

   单线程，每个命令具备原子性

   低延迟，速度快（基于内存、  IO多路复用、良好的编码 ）

   支持数据持久化

   支持主从集群、分片集群

   支持多语言客户端

作者 ：Antirez

Redis的官方网站地址：  https: ˌredis.io/

1 .3 .安装Redis

大多数企业都是基于Linux服务器来部署项目，而且Redis官方也没有提供Windows版本 的安装包。因此课程中我们会基于Linux系统来安装Redis .

此处选择的Linux版本为CentOS  7，建议下载一个可视化工具，例如FinalShell

1 .3 .1 .依赖库

Redis是基于C语言编写的，因此首先需要安装Redis所需要的gcc依赖：

yum  install  -y  gcc  tcl

1 .3 .2 .上传安装包并解压

然后将课前资料提供的Redis安装包上传到虚拟机的任意目录：

 

例如，我放到了/usr/local/src  目录：

解压缩：

tar  -xzf  redis-6.2.6.tar.gz

 解压后：

 进入redis目录：

cd  redis-6.2.6

运行编译命令：

make

如果没有安装 gcc直接进行 make会报错： 

# 表示没有这个文件

Jemalloc/jemalloc.h

解决方案：

• 安装gcc
• 运行make distclean
• 然后再进行make

 如果没有出错，应该就安装成功了。

默认的安装路径是在  /usr/local/bin 目录下：

该目录已经默认配置到环境变量，因此可以在任意目录下运行这些命令。其中：

   redis-cli：是redis提供的命令行客户端

   redis-server ：是redis的服务端启动脚本

   redis-sentinel：是redis的哨兵启动脚本

1 .3 .3 .启动

redis的启动方式有很多种，例如：

  默认启动

  指定配置启动

  开机自启

1 .3 .4 .默认启动

安装完成后，在任意目录输入redis-server命令即可启动Redis：

 这种启动属于 前台启动 ，会阻塞整个会话窗口，窗口关闭或者按下 CTRL  +  C 则Redis停 止。不推荐使用。

1 .3 .5 .指定配置启动

如果要让Redis以 后台 方式启动，则必须修改Redis配置文件，就在我们之前解压的 redis安装包下（/usr/local/src/redis-6.2.6 ），名字叫redis.conf：

 我们先将这个配置文件备份一份：(以防出错）

cp  redis.conf  redis.conf.bck

 然后修改redis.conf文件中的一些配置：

#  允许访问的地址，默认是127.0.0.1 ，会导致只能在本地访问。修改为 0.0.0.0则 可以在任意IP访问，生产环境不要设置为0.0.0.0

bind  0.0.0.0

#  守护进程，修改为yes后即可后台运行

daemonize  yes

#  密码，设置后访问Redis必须输入密码

requirepass  123321

Redis的其它常见配置： 

#  监听的端口

port  6379

#  工作目录，默认是当前目录，也就是运行redis-server时的命令，日志、持久化 等文件会保存在这个目录

dir   .

#  数据库数量，设置为1，代表只使用1个库，默认有16个库，编号0~15

databases  1

#  设置redis能够使用的最大内存

maxmemory  512mb

#  日志文件，默认为空，不记录日志，可以指定日志文件名

logfile  "redis.log"

启动Redis：

#  进入redis安装目录

cd  /usr/local/src/redis-6.2.6

#  启动

redis-server  redis.conf

停止服务：

 #  利用redis-cli来执行  shutdown  命令，即可停止  Redis  服务， #  因为之前配置了密码，因此需要通过  -u  来指定密码

redis-cli  -u  123321  shutdown

1 .3 .6 .开机自启

我们也可以通过配置来实现开机自启。

首先，新建一个系统服务文件：

vi  /etc/systemd/system/redis.service

内容如下

[Unit]

Description=redis-server

After=network.target

[Service]

Type=forking

ExecStart=/usr/local/bin/redis-server  /usr/local/src/redis- 6.2.6/redis.conf

PrivateTmp=true

[Install]

WantedBy=multi-user.target

然后重载系统服务：

systemctl  daemon-reload 

现在，我们可以用下面这组命令来操作redis了： 

#  启动

systemctl  start  redis

#  停止

systemctl  stop  redis

#  重启

systemctl  restart  redis

#  查看状态

systemctl  status  redis 

 执行下面的命令，可以让redis开机自启：

systemctl  enable  redis 

1 .4 .Redis桌面客户端

安装完成Redis，我们就可以操作Redis，实现数据的CRUD了。这需要用到Redis客户 端，包括：

·  命令行客户端

  图形化桌面客户端

  编程客户端

1 .4 .1 .Redis命令行客户端

Redis安装完成后就自带了命令行客户端：  redis-cli，使用方式如下：

 redis-cli  [options]  [commonds]

其中常见的options有：

·   -h  127.0.0.1 ：指定要连接的redis节点的IP地址，默认是127.0.0.1

   -p  6379 ：指定要连接的redis节点的端口，默认是6379

   -a  123321 ：指定redis的访问密码

其中的commonds就是Redis的操作命令，例如：

   ping ：与redis服务端做心跳测试，服务端正常会返回 pong

不指定commond时，会进入 redis-cli 的交互控制台： 

这个时候使用 auth 指定你的密码

1 .4 .2 .图形化桌面客户端

GitHub上的大神编写了Redis的图形化桌面客户端

1 .4 .3 .安装

在课前资料中可以找到Redis的图形化桌面客户端：

解压缩后，运行安装程序即可安装：

安装完成后，在安装目录下找到rdm.exe文件：

双击即可运行：

1 .4 .4 .建立连接

点击左上角的 连接到Redis服务器 按钮：

在弹出的窗口中填写Redis服务信息：

这些信息都要求是你自己的虚拟机地址和端口，同时记得在虚拟机内关闭防火墙放出端口，可以在cmd中 ping 你的地址测试是否可以连接上 

 点击确定后，在左侧菜单会出现这个链接：

 点击即可建立连接了。 

 Redis默认有16个仓库，编号从0至15.    通过配置文件可以设置仓库数量，但是不超过

16，并且不能自定义仓库名称。

如果是基于redis-cli连接Redis服务，可以通过select命令来选择数据库：

#  选择  0号库

select  0

2 .Redis常见命令

Redis是典型的key-value数据库，  key一般是字符串，而value包含很多不同的数据类型：

Redis为了方便我们学习，将操作不同数据类型的命令也做了分组，在官网( https: ˌredis.io/commands）可以查看到不同的命令

不同类型的命令称为一个group，我们也可以通过help命令来查看各种不同group的命 令：

2 .1 .Redis通用命令

通用指令是部分数据类型的，都可以使用的指令，常见的有：

   KEYS：查看符合模板的所有key

   DEL：删除一个指定的key

   EXISTS：判断key是否存在

   EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除

   TTL：查看一个KEY的剩余有效期

通过help  [command]  可以查看一个命令的具体用法，例如：

#  查看keys命令的帮助信息：

127.0.0.1 :6379>  help  keys

KEYS  pattern

summary:  Find  all  keys  matching  the  given  pattern

since:  1.0.0

group:  generic

2 .2 .String类型

String类型，也就是字符串类型，是Redis中最简单的存储类型。

其value是字符串，不过根据字符串的格式不同，又可以分为3类：

   string：普通字符串

   int：整数类型，可以做自增、自减操作

   float：浮点类型，可以做自增、自减操作

不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最 大空间不能超过512m 

我们可以通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范：

Redis的key允许有多个单词形成层级结构，多个单词之间用':'隔开，格式如下：

项目名 :业务名 :类型:id

这个格式并非固定，也可以根据自己的需求来删除或添加词条。这样以来，我们就可以把 不同类型的数据区分开了。从而避免了key的冲突问题。

例如我们的项目名称叫  heima，有user和product两种不同类型的数据，我们可以这样 定义key：

   user相关的key： heima:user:1

   product相关的key： heima:product:1

如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储：

KEY	VALUE
heima:user:1	{"id":1,  "name":  "Jack",  "age":  21}
heima:product:1	{"id":1,  "name":  "小米11",  "price":  4999}

在Redis的桌面客户端中，还会以相同前缀作为层级结构，让数据看起来层次分明关系清晰： 

2 .3 .Hash类型

Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。

String结构是将对象序列化为JSON字符串后存储，当需要修改对象某个字段时很不方便：

Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD：

     有序

例如两个集合：  s1和s2:

求交集：  SINTER  s1  s2

求s1与s2的不同：  SDIFF  s1  s2

 

  判断李四是否是张三的好友

  判断张三是否是李四的好友

·  将李四从张三的好友列表中移除

将班级的下列学生得分存入Redis的SortedSet中：

Jack  85,  Lucy  89,  Rose  82,  Tom  95,  Jerry  78,  Amy  92,  Miles  76

并实现下列功能：

  删除Tom同学

  获取Amy同学的分数

  获取Rose同学的排名

  查询80分以下有几个学生

  给Amy同学加2分

  查出成绩前3名的同学

  查出成绩80分以下的所有同学

3 .Redis的Java客户端

在Redis官网中提供了各种语言的客户端

 

 其中Java客户端也包含很多：

标记为*的就是推荐使用的java客户端，包括：

 Jedis和Lettuce：这两个主要是提供了Redis命令对应的API，方便我们操作

Redis，而SpringDataRedis又对这两种做了抽象和封装，因此我们后期会直接以 SpringDataRedis来学习。

  Redisson：是在Redis基础上实现了分布式的可伸缩的java数据结构，例如Map、 Queue等，而且支持跨进程的同步机制：  Lock、 Semaphore等待，比较适合用来实 现特殊的功能需求。

 3 .1 .Jedis客户端

 3 .1 .1 .快速入门

我们先来个快速入门：

1）引入依赖：

<dependency>
  <groupId>redis.clients <groupId>
  <artifactId>jedis <artifactId>
  <version>3.7.0 <version>
<dependency>

<dependency>
  <groupId>org.junit.jupiter <groupId>
  <artifactId>junit-jupiter <artifactId>
  <version>5.7.0 <version>
  <scope>test <scope>
<dependency>

2）建立连接

新建一个单元测试类，内容如下：

private  Jedis  jedis;

@BeforeEach
void  setUp ()  {
  //  1.建立连接
  jedis  =  new  Jedis("192.168.150.101 ",  6379);
  jedis  =  JedisConnectionFactory .getJedis();
  // 2.设置密码
  jedis .auth ( "123321" );
  // 3.选择库
  jedis .select (0 );
}

3）测试：

@Test
void  testString()  {
// 存入数据
  String  result  =  jedis .set ( "name" ,  "虎哥 " );
  System .out .println("result  =  "  +  result );
// 获取数据
  String  name  =  jedis .get ( "name" );
  System .out .println("name  =  "  +  name );
}

@Test
void  testHash ()  {
//插入hash数据
jedis .hset ( "user:1" ,  "name" ,  "Jack" );
jedis .hset ( "user:1" ,  "age" ,  "21" );

// 获取
 Map<String ,  String>  map  =  jedis .hgetAll ( "user:1" );
 System .out .println(map );
}

4）释放资源

@AfterEach
void  tearDown ()  {
  if  (jedis  !=  null)  {
    jedis .close ();
  }
}

3 .1 .2 .连接池

Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大 家使用Jedis连接池代替Jedis的直连方式。

package  com .heima .jedis .util;

import  redis .clients .jedis .*;

public  class  JedisConnectionFactory  {

  private  static  JedisPool  jedisPool;

  static  {
  // 配置连接池
  JedisPoolConfig  poolConfig  =  new  JedisPoolConfig(); 
  poolConfig .setMaxTotal (8 );
  poolConfig .setMaxIdle (8 );
  poolConfig .setMinIdle (0 );
  poolConfig .setMaxWaitMillis (1000 );
  // 创建连接池对象，参数：连接池配置、服务端ip、服务端端口、超时时 间、密码
  jedisPool  =  new  JedisPool (poolConfig ,
  "192.168.150.101 " ,  6379 ,  1000 ,  "123321" );
}

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

3 .2 .SpringDataRedis客户端

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，

  官网提供了对不同Redis客户端的整合（Lettuce和Jedis）

  提供了RedisTemplate统一API来操作Redis

  支持Redis的发布订阅模型

  支持Redis哨兵和Redis集群

  支持基于Lettuce的响应式编程

  支持基于JDK、JSON、字符串、  Spring对象的数据序列化及反序列化

  支持基于Redis的JDKCollection实现

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操 作。并且将不同数据类型的操作API封装到了不同的类型中：

3 .2 .1 .快速入门

SpringBoot已经提供了对SpringDataRedis的支持，使用非常简单。

首先，新建一个maven项目，然后按照下面步骤执行：

1）引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12-SNAPSHOT</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yj</groupId>
    <artifactId>Redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Redis</name>
    <description>Redis</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--        Redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--common pool -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--        jackson-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </pluginRepository>
    </pluginRepositories>

</project>

2）配置Redis  application.yaml中

Spring:
  redis:
    host: 192.168.150.101
    port: 6379
    password: 123321
    pool:
      max-active: 8
      max-idle: 8
      min-idle: 0
      max-wait: 1000ms

3）注入RedisTemplate

因为有了SpringBoot的自动装配，我们可以拿来就用：

@SpringBootTest
class  RedisStringTests  {

  @Autowired
  private  RedisTemplate  redisTemplate;
}

4）编写测试

@SpringBootTest
class  RedisStringTests  {

   @Autowired
   private  RedisTemplate  edisTemplate;

   @Test
   public void  testString()  {
  // 写入一条String数据
   redisTemplate .opsForValue ().set ( "name" ,  "虎哥 " );
  //获取string数据
   Object  name  =stringRedisTemplate .opsForValue ().get ( "name" ); 
   System .out .println("name  =  "  +  name );
   }
}

3 .2 .2 .自定义序列化

RedisTemplate可以接收任意Object作为值写入Redis：

只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：

缺点：

    可读性差

   内存占用较大

我们可以自定义RedisTemplate的序列化方式，代码如下：

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        //创建RedisTemplate对象
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(connectionFactory);
        //创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //设置Key的序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        //设置Value的序列化
        redisTemplate.setValueSerializer(jsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jsonRedisSerializer);
        //返回RedisTemplate对象
        return redisTemplate;
    }

}

这里采用了JSON序列化来代替默认的JDK序列化方式。最终结果如图：

整体可读性有了很大提升，并且能将Java对象自动的序列化为JSON字符串，并且查询时 能自动把JSON反序列化为Java对象。不过，其中记录了序列化时对应的class名称，目 的是为了查询时实现自动反序列化。这会带来额外的内存开销。

3 .2 .3 .StringRedisTemplate

为了节省内存空间，我们可以不使用JSON序列化器来处理value，而是统一使用String 序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完 成对象的序列化和反序列化。

因为存入和读取时的序列化及反序列化都是我们自己实现的，  SpringDataRedis就不会 将class信息写入Redis了。

这种用法比较普遍，因此SpringDataRedis就提供了RedisTemplate的子类：

StringRedisTemplate，它的key和value的序列化方式默认就是String方式。

 

 省去了我们自定义RedisTemplate的序列化方式的步骤，而是直接使用：

 @Autowired
 private  StringRedisTemplate  stringRedisTemplate;
  // JSON序列化工具
 private  static  final  ObjectMapper  mapper  =  new  ObjectMapper();

  @Test
  void  testSaveUser ()  throws  JsonProcessingException  { 
  //创建对象
  User  user  =  new  User ( "虎哥 " ,  21 );
  // 手动序列化
  String  json  =  mapper .writeValueAsString(user );
  // 写入数据
  stringRedisTemplate .opsForValue ().set ( "user:200" ,  json);
  // 获取数据
  String  jsonUser  =stringRedisTemplate .opsForValue ().get ( "user:200" );
  // 手动反序列化
  User  user1  =  mapper . readValue (jsonUser ,  User .class ); 
  System .out .println("user1  =  "  +  user1 );
}

Redis基础篇到此结束，如果对你有帮助的话，请留下你的赞吧