redis依赖jemalloc redis依赖包配置

1.Redis安装

(要保证虚拟机能连接外网)

下载地址：https://redis.io/download 一般下载稳定版（Stable）。

1.1下载安装包

• 下载安装到 /usr/local/src 目录

wget -P /usr/local/src  https://download.redis.io/releases/redis-6.0.9.tar.gz

• 如果没有wget 先安装wget

yum install -y wget

1.2 解压Redis

tar -zxvf redis-6.0.9.tar.gz

1.3编译Redis

进入redis目录

cd /usr/local/src/redis-6.2.6

因为Redis是用C语言开发的，在编译的时候会依赖C语言环境，所以我们要先安装依赖。

yum install -y gcc-c++ autoconf automake

1.3.1升级GCC

这里要说明一下，yum安装的GCC版本很低，默认版本是4.8.5，在版本过低时编译会报错。

#查看GCC版本
gcc -v

版本过低编译报错：

所以我们需要升级GCC。

#安装scl语言
yum install -y centos-release-scl scl-utils-build
#安装 9版本的gcc 、gcc-c++、gdb 工具链
yum install -y devtoolset-9-toolchain
#临时覆盖系统原有的gcc引用
scl enable devtoolset-9 bash
#查看gcc版本
gcc-v

重新编译Redis,此时就编译成功了

make

此时Redis已经安装成功了，但是会安装在Centos的默认目录下，现在给安装的Redis更换到指定目录

1.4 安装Redis

#创建目录文件
mkdir -p /usr/local/redis
#把之前编译好的redis 安装到指定目录
make PREFIX=/usr/local/redis install

到这里安装就结束了。

1.5 启动Redis

#进入redis的bin目录
cd /usr/local/redis/bin
#直接运行redis
./redis-server

这种方式为前置启动，但是这样运行控制台会显示Redis界面，不能进行其他操作

所以我们换一种方式运行，守护进程的方式运行。先Ctrl+C退出这个界面。因为Redis启动时记载配置文件启动的。找到这个配置文件

#进入配置文件目录
cd /usr/local/src/redis-6.0.9/
#将配置文件复制一份到新创建的redis目录中 
cp redis.conf /usr/local/redis/bin

修改第224行，把no改为yes，这个代表的是：是否以守护进程的方式启动，默认为no。

启动redis

#指定配置文件路径的方式启动redis，指定配置文件目录为刚才修改的配置文件的目录
./redis-server ./redis.conf

2. Redis的配置

2.1 Redis的配置文件

Redis支持很多的参数，都有默认值。

• daemonize:Redis是否后台启动，默认为no。
• bind : redis只接受来自该Ip的请求 (如果不是在自己的虚拟机上千万不要配成0.0.0.0，如果使用的服务器请配成指定IP，不然会被黑大哥用来挖矿。)
• port：启动端口，默认6379
• database：设置数据库个数，默认使用的数据库是0
• save：设置Redis进行数据库镜像的频率
• dbfilename：镜像备份文件的文件名。
• dir：数据库镜像备份的的文件的放置路径
• requirepass：设置客户端连接后进行其他任何操作前需要使用的密码（尽量配上，防止黑哥挖矿）
• maxclients：限制同时连接的客户端数量。
• maxmemory：设置redis最大的使用缓存。

修改配置文件让客户端能连上

修改bind

因为我是本机上的虚拟机Redis ，所以我配置的0.0.0.0

修改password(尽量配置的复杂一点)

杀掉redis进程，重启redis

kill -9 端口号（pid）
./redis-server /usr/local/redis/bin/redis.conf

使用Redis Desktop Manager测试连接

这样就连接成功了

使用Redis自带客户端连接

cd /usr/local/redis/bin
#启动进入客户端
./redis-cli 
#如果设置了密码进入后还需要一个命令
auth 密码

3.Redis命令

参考文档：http://doc.redisfans.com/

1.Redis连接后的命令

1.1 select

#切换当前数据库
127.0.0.1:6379> select 2 ##切换到2号数据库
127.0.0.1:6379[2]> select 3  ##切换到3号数据库，注意Redis现在的命令提示符多了个 [2]

1.2 quit

请求服务器关闭与当前客户端的连接。

#推出客户端
127.0.0.1:6379[2]> quit

2.Redis基本数据类型

Redis作为内存中的数据结构存储系统，它可以用作数据库，缓存，消息中间件，他的value支持多种类型的数据结构，基本数据类型包括：字符串，散列，列表，集合，有序集合五种。这五种数据结构在我们工作中经常用到，面试过程中经常被问到，因此熟练掌握这5中基本数据结构的使用和应用场景是Redis最基础也是最重要的部分。

2.1 字符串（Strings）

2.1.1 类型介绍

字符串是Redis最简单的存储类型，存储的值可以是字符串，整数，浮点数。可以对整数进行自增（increment）和自减（decrement）操作。

Redis字符串是一个有字节组成的序列，跟Java的ArrayList有点相似，采用预分配冗余空间减少内存的频繁分配，当字符串长度小于1MB时，都是翻倍增长，如果超过1MB。每次扩容只会增加1MB.字符串最大长度为512MB

2.1.2 应用场景

字符串类型在工作中使用广泛，主要用于缓存数据(不怎么更改，频繁查询的数据)，提高查询性能，比如存储登录用户信息，电商中存储商品信息，可以当计数器（比如一个IP访问了几次）

2.1.3 常用操作指令

set key value  		#设置一个键值对,如果key存在会覆盖内容
get key value   	#获取一个键值对
mset key1 value1 key2 value2 .... 	#设置多个键值对
mget key1 key2....  	#获取多个键值对。
incr key 			#自增1，key必须是数值型
decr key 			#自减1，key必须是数值型
incrby key step 	#按照指定长度自增，step：指定自增长度
decrby key step  	#按照指定长度自减，step：指定自增长度
del key 			#删除一个键值对

2.2散列（hashes）

2.2.1类型介绍

散列相当于Java的HashMap，内部是无序字典，实现原理和HashMap一致，一个哈希有多个节点，一个节点只能保存一个键值对。

与Java中的HashMap不同的是，rehash的方式不一样，因为Java的HashMap在字典很大时，rehash是个耗时的操作，需要一次性全部rehash,Redis为了高性能，不能堵塞服务，所以采用了渐进式rehash的策略。

渐进式rehash会在rehash的同时，保留新旧两个hash结构，查询时会同时查询两个hash结构，然后在后续的定时任务中以及hash操作指令中，循序渐进的将旧hash的内容一点点迁移到新的hash结构中，当搬迁完成了，就会使用新的hash结构取而代之。

当hash移除了最后一个元素后，该数据结构自动被删除，内存被回收。

2.2.2应用场景

hash也可以用于对象存储，比如存储用户信息，与字符串不一样的是，字符串需要将对象进行序列化（比如json序列化）之后才能保存，而hash则可以将用户对象的每个字段单独存储，这样能省序列化和反序列化的时间。

此外还可以用于保存用户的购买记录，比如key为用户ID，field为商品id，value为商品数量。同样还可以用于购物车数据的存储，比如key为用户id，field为商品id，value为购买的数量等等。。。

2.2.3 常用操作指令

hset key field value 			#将哈希表 key 中的域 field 的值设为 value 。如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。如果域 field 已经存在于哈希表中，旧值将被覆盖。
hget key field  				#返回哈希表 key 中给定域 field 的值。
hincrby  key field increment 	 #为哈希表 key 中的域 field 的值加上增量 increment,增量也可以为负数，相当于对给定域进行减法操作。
hgetall key 					#返回哈希表 key 中，所有的域和值。
hmget key field [field ...]       #返回哈希表 key 中，一个或多个给定域的值。
hlen key                          #返回哈希表 key 中域的数量。

2.3 列表（lists）

2.3.1类型介绍

List相当于Java中的LinkedList，实现原理是一个双向链表（底层是一个快速表），可以支持反向查找和遍历，更方便操作。插入和删除都非常快，时间复杂度O(1),但是索引定位很慢，时间复杂度O（N）

2.3.2应用场景

可以利用List实现热销榜，实现工作队列（利用lists的push操作，将任务存在lists中，然后工作线程再用pop操作建任务取出进行执行）。可以实现最新列表，比如最新评论。

2.3.3 常用操作指令

lpush key value [value ...] #将一个或多个值 value 插入到列表 key 的表头，按顺序插入表头
rpush key value [value ...] #将一个或多个值 value 插入到列表 key 的表尾(最右边)。
lpop key      #移除并返回列表 key 的头元素。
rpop key      #移除并返回列表 key 的尾元素。
lrange key start stop #返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。这是一个闭区间，超出范围的下标值不会引起错误。
llen key    #返回列表 key 的长度。

2.4 集合（Set）

2.4.1 类型介绍

相当于Java中的HashSet（无序的），内部实现是一个Value永远为空的HashMap，实际就是通过计算hash的方式来快速排重，这也是set能提供一个成员是否在集合内的原因。

2.4.2 应用场景

redis的set类型是使用哈希表构造的，因此复杂度是O（1）它支持集合内的增删改查，并且支持几个集合的交集，并集，差集。可以利用这些来实现：计算网站的独立IP，用户画像中用的用户标签，共同好友功能。

2.4.3常用操作指令。

sadd key member [member ...] #将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
spop key # 随机移除并返回集合中的一个元素。
smembers key #返回集合 key 中的所有成员
Sinter key [key ...] #返回几个集合key之间的交集。
sdiff key [key ...]  #返回几个集合key之间的差集。
sunion key [key ...] #返回一个集合的全部成员，该集合是所有给定集合的并集。
srandmember key [count] #如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。

2.5有序集合（sorted Set）

2.5.1 类型介绍

相当于是Redis的Set和HashMap的结合体，一方面他是一个Set，保证了内部Value的唯一性，另一方面它可以给每个Value分配一个Score，代表这个Value的权重。内部使用HashMap和跳跃表来保证数据的存储和有序，HashMap里放的是成员到score的映射。而跳跃表里存放的是所有的成员，排序依据是HashMap里村的score，使用跳跃表结构可以获得比较高的查询效率，并且在实现上比较简单，sorted set 中最后一个Value被移除后，数据结构自动删除。

2.5.2应用场景

主要应用于 根据权重进行排序的队列场景，比如：游戏积分排行榜，设置优先级的任务列表，学生成绩表等等。。。

2.5.3常用操作指令

zadd key score member [[score member] [score member] ...] #将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果member存在则更新score
zcard key #返回有序集 key 的成员个数
zcount key min max #统计score在min和max之间的成员个数。
zrange key start stop #返回有序集 key 中，指定区间内的成员,其中成员的位置按 score 值递增(从小到大)来排序。
zrevrange key start stop #返回有序集 key 中，指定区间内的成员,其中成员的位置按 score 值递增(从大到小)来排序。
zrank key member #返回 member 成员按score排名的结果。
zrem key member #删除成员

Redis的Java客户端

1.客户端介绍

Redis支持很多语言的客户端，也是redis受欢迎的原因。文档 : https://redis.io/clients#java

2Java客户端

RedisJava客户端文档：https://redis.io/clients#java

Redis的Java客户端也有很多，其中最受欢迎的是jedis和lettuce

• Jedis在实现上是直接连接redis server，如果在多线程环境下是线程不安全的，这个时候只有使用连接池，为每个Jedis实例增加物理连接。官方推荐
• lettuce的连接是基于Netty的，线程安全。
• SpringBoot Data Redis 1.X之前使用的Jedis ，但目前新版2.X改为了Lettuce。
• 总的来说Jedis性能优于Lettuce。

2.1 Jedis客户端

• 第一步：导入Jedis依赖包。
• 第二步：编写测试代码。

第一步：导入Jedis依赖包

<dependencies>
<!--        jedis客户端 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>
      <!--        单元测试Juint  -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

第二步：编写测试代码

package com.test;/*
 * @ClassName JedisTest
 * @Desc TODO
 * @Author 19637
 * @Date 2022/2/12 0:12
 * @Version 1.0
 */

import org.junit.Test;
import redis.clients.jedis.Jedis;

public class JedisTest {
    @Test
    public void test(){
        //创建Jedis客户端连接Redis
        Jedis jedis = new Jedis("192.168.152.129",6379);
        //密码认证
        jedis.auth("0211");
        //验证连接，心跳机制
        String pong = jedis.ping();
        //返回结果为pong则连接成功
        System.out.println(pong);
        //操作Redis，命令和Redis自带客户端命令相同。（String命令实例）
        jedis.set("user","zhangsan");
        String user = jedis.get("user");
        System.out.println(user);
        //关闭jedis
        jedis.close();
    }
}

执行结果

2.2Jedis连接池优化

我们都是知道Jedis是直接操作Redis的，当并发量特别大的时候，那么Jedis操作redis接可能发生异常。因此为了提高操作效率，引入连接池

• 第一步：编写连接池类
• 第二步：通过连接池获取连接，通过测试案例

第一步：编写连接池类

public class JedisPoolTest {
    //这个类就在Jedis依赖中
    private static final JedisPool jedisPool ;
    static{
        //创建连接池配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        //最大连接数，默认为8
        config.setMaxTotal(5);
        //最大空闲数量，默认为8
        config.setMaxIdle(5);
        //最小空闲数量，默认为0
        config.setMinIdle(0);
        //设置等待时间(ms)
        config.setMaxWaitMillis(100);
        jedisPool = new JedisPool(config,"192.168.152.129",6379,100,"0211");
    }

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

第二步：通过连接池获取Jedis对象，通过案例。

import org.junit.Test;
import redis.clients.jedis.Jedis;

public class JedisTest {
    @Test
    public void test(){
        //通过连接池获取Jedis
     	Jedis jedis = JedisPoolTest.getConnection();
        //验证连接，心跳机制
        String pong = jedis.ping();
        //返回结果为pong则连接成功
        System.out.println(pong);
        //操作Redis，命令和Redis自带客户端命令相同。（String命令实例）
        jedis.set("user","zhangsan");
        String user = jedis.get("user");
        System.out.println(user);
        //关闭jedis
        jedis.close();
    }

}

SpringBoot集成Redis

• 第一步：引入依赖
• 第二步：配置yml文件
• 第三步： 编写测试类。

第一步：引入依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Jedis-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <version>2.3.4.RELEASE</version>
        <artifactId>spring-boot-starter-parent</artifactId>
    </parent>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
<!--        Spring整合的Redis客户端 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
<!--        让连接池使用lettuce-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
    </dependencies>

</project>

第二步：配置yml文件

server:
  port: 8088
spring:
  redis:
    port: 6379 #端口号
    password: "0211" #密码
    host: 192.168.152.129 #Redis所在主机IP
    lettuce:  #使用lettuce 连接池
      pool:
        max-wait: 100  #最长等待时间
        max-active: 5 #最大连接数
        max-idle: 1  #最大空闲数量
        min-idle: 1 #最小空闲数量

第三步： 编写测试类。

package com.nkym;/*
 * @ClassName SpringBootRedisTest
 * @Desc TODO
 * @Author 19637
 * @Date 2022/2/12 1:33
 * @Version 1.0
 */

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootRedisTest {
    @Autowired
    RedisTemplate redisTemplate;
    @Test
    public void test(){
        //获取连接
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
		// 测试连接
        String pong = connection.ping();
        //简单案例  使用 （String类型）
        redisTemplate.opsForValue().set("hello","zhangsan");
        //获取值
        System.out.println(redisTemplate.opsForValue().get("hello"));
    }
}

运行结果。

但是这样存储数据我们发现存在Redis中的数据根本看不懂

所以我们要重新定义RedisTemplate的默认序列化器

第四步：重新定义RedisTemplate的默认序列化器

在springboot中RedisTemplate默认使用的是Java本地的序列化（JdkSerializationRedisSerializer）方式

创建Redis配置类重新定义序列化

package com.nkym.config;/*
 * @ClassName RedisConfig
 * @Desc TODO
 * @Author 19637
 * @Date 2022/2/12 2:18
 * @Version 1.0
 */

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@SpringBootConfiguration
public class RedisConfig{

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    }

测试类

package com.nkym;/*
 * @ClassName SpringBootRedisTest
 * @Desc TODO
 * @Author 19637
 * @Date 2022/2/12 1:33
 * @Version 1.0
 */

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootRedisTest {
    @Autowired
    RedisTemplate<Object,Object> redisTemplate;
    @Test
    public void test(){
        //获取连接
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        //简单案例  使用 （String类型）
        redisTemplate.opsForValue().set("你好","世界");
    }
}

运行结果,变成我们看得懂的了，不是十六进制了。