Redis笔记

1.Redis简要介绍

Redis：键值数据库，key | value。属于NoSQL非关系型数据库

1.1SQL与NoSQL区别

SQL：

• ​ 结构化（Structured）：表结构、约束固定，一旦固定，严格按照约束来建表

• ​ 关联的（Relational）：外键关联

• ​ SQL查询：固定的语法格式

SQL: SELECT id,name,age FROM table_test WHERE id = 1

• ACID：原子性、一致性、隔离性、持久性

NoSQL：

• ​ 非结构化：对表结构没有严格的约束，以键值对的形式存储，约束较松散

1. 键值类型（Redis）
2. 文档类型（MongoDB）
3. 列表型（HBase）
4. Graph类型（Neo4j）

• ​ 无关联的：以json文档嵌套的方式直接存储

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

• 非SQL：无固定的语法格式，如：

Redis: get user:1

MongoDB: db.user.find(_id: 1)

elasticsearch: GET http://localhost:92000/users/1

• BASE：无法满足全部ACID，无事务，只能基本一致

	SQL	NoSQL
数据结构	结构化（Structured）	非结构化
数据关联	关联的（Relational）	无关联的
查询方式	SQL查询	非SQL
事务特性	ACID	BASE
存储方式	磁盘	内存
扩展性	垂直	水平
使用场景	1)数据结构固定；2）相关业务对数据安全性、一致性要求高	1）数据结构不固定；2）对一致性、安全性要求不高；3）对性能要求

1.2认识Redis

Remote Dictionary Server，远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征：

• 键值型（key-value）型，value支持多种不同数据结构，功能丰富
• 单线程，每个命令具备原子性
• 低延迟，速度快（基于内存、IO多路复用、良好的编码）
• 支持数据持久化
• 支持主从集群、分片集群
• 支持多语言客户端

1.3Redis下载使用

SVN下载地址：https://10.1.65.178/svn/ShareFiles/Redis/Redis-x64-3.2.100

本地存放地址：D:\dev_env\Redis\Redis-x64-3.2.100

在安装目录下打开cmd窗口，输入redis-server.exe启动redis，或直接在目录下点击redis-server.exe程序运行

然后另外启动一个cmd窗口，原来启动的窗口不要关闭，不然无法访问服务端

切换到redis目录下运行：redis-cli.exe -h 127.0.0.1 -p 6379

接下来，就可以开始敲redis命令进行操作啦！

可以将ip:port填入到RedisView中进行图形化界面操作

2.Redis基础命令

2.1Redis数据结构介绍

Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样

基本类型	String	hello world
	Hash	{name:“Jack”，age:21}
	List	[A -> B -> C -> C]
	Set	{A, B, C}
	SortedSet	{A:1, B:2, C:3}
特殊类型	GEO	{A:(120.3, 30.5)}
	BitMap	0110110101110101011
	HyperLog	0110110101110101011

2.2Redis通用命令

通过【help [command]】可以查看一个命令的具体用法。

• KEYS：查看符合模板的所有key。不建议在生产环境设备上使用。

  如：KEYS *
  

• del：删除一个指定的key

  如：del test1
  

• EXISTS：判断key是否存在

  如：EXISTS test1
  

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

  如设置test1有效期为20秒：EXPIRE test1 20
  

• TTL：查看一个key的剩余有效期。有效期内显示有效期时间，有效期过显示“-2”，永久有效期显示“-1”

  如：TTL test1
  

2.3String类型常见命令

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

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

1. String：普通字符串
2. int：整数类型，可以做自增、自减操作
3. float：浮点类型，可以做自增、自减操作

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

• SET：添加或修改已经存在的一个String类型的键值对。【添加和修改同一个操作命令】

如：SET name Rose

• GET：根据key获取String类型的value。

如：GET name

• MSET：批量添加多个String类型的键值对。【k和v对应】

如：MSET k1 v1 k2 v2

• MGET：根据多个key获取多个String类型的value。【传入k，获取到v】

如：MGET k1  k2 

• INCR：让一个整型的key自增1。【每执行一次value增加1】

如：INCR age

• INCRBY：让一个整型的key自增并指定步长，例如：incrby num 2，让num值自增2。【可以将数值设为负数来实现自减】

如：INCRBY age 2

• INCRBYFLOAT：让一个浮点类型的数字自增并指定步长。【浮点类型没有默认增长，只能指定步长】

如：INCRBYFLOAT scope 0.1

• SETNX：添加一个String类型的键值对，前提是这个key不存在，否则不执行。【只有新增效果】

如：SETNX name1 chen   /    SET name1 dan NX

• SETEX：添加一个String类型的键值对，并且指定有效期

如：SETEX name1 10 chen  /  SET name1  chen EX 10

2.4Key的层级格式

多个不同表的key都是id，id的value都是1，要如何区分？

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

【项目名：业务名：类型：id】

这个格式并非固定，也可以根据自己的需求来删除或添加词条。

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

SET chendanTest:user:1 '{"id":1, "name":"Jack", "age":18}'
SET chendanTest:product:1 '{"id":1, "name":"小米", "price":3999}'

Redis的key的格式：[项目名]:[业务名]:[类型]:[id]

2.5Hash类型

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

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

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

Hash类型常见命令如下：

• HSET key field value：添加或修改hash类型key的field的值

HSET heima:user:3 name Lucy
HSET heima:user:3 age 20

• HGET key field：获取一个hash类型key的field的值
• HMSET：批量添加多个hash类型key的field的值

HMSET　heima:user:4 name LiLei age 20 sex man

• HMGET：批量获取多个hash类型key的field的值
• HGETALL：获取一个hash类型的key中的所有的field和value

HGETALL heima:user:4
类似于java中hashMap的方法entrySet()，返回所有键值对

• HKEYS：获取一个hash类型的key中的所有field
• HVALS：获取一个hash类型的key中的所有value
• HINCRBY：让一个hash类型key的字段值自增并指定步长

HINCRBY heima:user:4 age 2
执行一次增长一次

• HSETNX：添加一个hash类型的key的field的值，前提是这个field不存在，否则不执行

2.6List类型

Redis中的List类型与Java中的LinkedList类似，可以看作是一个双向链表结构。既可以支持正向检索，也可以支持反向检索。特征也与LinkedList类似：有序、元素可以重复、插入和删除快、查询速度一般

常用来存储一个有序数据，例如：朋友圈点赞列表、评论列表等

常见命令如下：

• LPUSH key element…：向列表左侧插入一个或多个元素

LPUSH user 1 2 3
//从左侧推，存入第一个元素是3

• LPOP key：移除并返回列表左侧的第一个元素，没有则返回null
• RPUSH key element…：向列表右侧插入一个或多个元素

RPUSH user 4 5 6
//从右侧推，存入第一个元素是4

• RPOP key：移除并返回列表右侧的第一个元素
• LRANGE key star end：返回一段角标范围内的所有元素
• BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回null

2.7Set类型

Redis的Set结构与Java中的HashSet类似，可以看作是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：无序、元素不可重复、查找快、支持交集&并集&差集等功能

常见命令如下：

• SADD key member…：向set中添加一个或多个元素
• SREM key member…：移除set中的指定元素
• SCARD key：返回set中元素的个数
• SISMEMBER key member：判断一个元素是否存在于set中
• SMEMEBRS：获取set中的所有元素
• SINTER key1 key2 …：求key1与key2的交集
• SDIFF key1 key…：求key1与key2的差集
• SUNION key1 key2…：求key1与key2的并集

2.8SortedSet类型

Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层结构却差别很大。SortedSet中的每一个元素都带有以恶搞score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加hash表。SortedSet具备下列特性：可排序、元素不重复、查询速度快

因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能

常见命令如下：

• ZADD key score member：添加一个或多个元素到sorted set，如果已经存在则更新其score值
• ZREM key member：删除sorted set中的一个指定元素
• ZSCORE key member：获取sorted set中的指定元素的score值
• ZRANK key member：获取sorted set中的指定元素的排名
• ZCARD key：获取sorted set中的元素个数
• ZCOUNT key min max：统计score值在给定范围内的所有元素的个数
• ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值
• ZRANGE key min max：按照score排序后，获取指定排名范围内的元素
• ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围内的元素
• ZDIFF、ZINTER、ZUNION：求差集、交集、并集

注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可，如：

ZREVRANK stus Rose

3.Redis的Java客户端

3.1常用客户端介绍

jedis：以Redis命令作为方法名称，学习成本低，简单实用。但是Jedis实例时线程不安全的，多线程环境下需要基于连接池来使用

lettuce：Lettuce是基于Netty实现的，支持同步、异步和响应式编程方式，并且是线程安全的。支持Redis的哨兵模式、集群模式和管道模式

Redisson：是一个Redis实现的分布式、可伸缩的Java数据结构集合。包含了诸如Map、Queue、Lock、Semaphore、AtomicLong等强大功能

Spring Data Reids：兼容jedis和lettuce，但某些企业可能还是使用原生的jedis。QMS和MIS开发环境下使用的是Spring Data Reids，项目中的依赖导入如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3.2Jedis学习

Jedis使用的基本步骤：

1. 引入依赖
2. 创建Jedis对象，建立连接
3. 使用Jedis，方法名与Redis命令一致
4. 释放资源

3.2.1Jedis基础学习

3.2.1.1引入依赖

可在官网查询，引入依赖：

<dependency>
    <groupId>reids.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>

3.2.1.2Jedis连接与操作

先创建Redis连接，填写相关Redis数据库配置

使用Redis类似语法插入数据：演示String和Hash两种类型的操作，其他与之相似

操作完成后释放连接

import reids.clients.jedis.Jedis

public class JedisTest {
	private Jedis jedis;
	
	//建立连接
    @BeforeEach
    void setUp() {
        //建立连接
        jedis = new Jedis("ip地址",6379);
        //设置密码
        jedis.auth("123456");
        //连接库，选择一个库，不选的话默认是0号库
        jedis.select(0);
    }
    
    //String类型操作
    @Test
    void testString() {
        //存入数据
        String result = jedis.set("name","zhangsan");
        System.out.println("result = "+result);
        //获取数据
        String name = jedis.get("name");
        System.out.println("name = "+name);
	}
	
	//Hash类型操作
	@Test
    void testHash() {
        //插入hash，第一个为key，第二个为field，第三个为value
        jedis.hset("user:1","name","Jack");
        jedis.hset("user:1","age","21");
        //获取全部数据，得到一个Map
        Map<String,String> map = jedis.hgetAll("user:1");
        System.out.println(map);
    }
    
	//释放连接
    @AfterEach
    void tearDown() {
        if (jedis != null) {
            jedis.close();
        }
    }
}

3.2.2Jedis连接池学习

Jedis本身是线程不安全的，如果在多线程的环境下，并发地去访问、使用的话，是有可能出现线程安全的问题的，因此在并发的环境下，Jedis一定要给每一个线程创建独立的Jedis对象，最好的方案是使用线程池

并且，频繁的创建和销毁连接会有性能损耗，推荐使用Jedis连接池代替Jedis的直连方式

3.2.2.1Jedis连接

定义一个工具类：jeidsPool传的是连接的参数，jedisPoolConfig传的是池的参数

连接池创建好之后，提供一个静态方法，便于获取Jedis对象

只要调用getJedis()方法就可以从池子里拿取Jedis对象，用完也会还回去，避免频繁地创建和销毁jedis对象了

public class JedisConnectionFactory {
    
    //静态成员变量连接池
    private static final JedisPool jeidsPool;
    
    //通过静态代码块初始化jedisPool
    static {
    	//连接池的参数
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接，【最多允许创建8个连接】
        jedisPoolConfig.setMaxTotal(8);
        //最大空闲连接，【最多预备8个连接，有需要使用就可以直接用，不用重新创建】
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接，【如果预备的一直无人访问，则空闲连接会释放，直到为0]
        jedisPoolConfig.setMinIdle(0);
        //设置最长等待时间，ms，【当连接池没有连接可用的时候，是否等待及等待时长，默认是-1（无限等待，直到有空闲的可用连接）】
        jedisPoolConfig.setMaxWaitMillis(1000);
        
        //传入jedis配置、ip、端口、超时时间、密码
        jeidsPool = new JedisPool(jedisPoolConfig,"ip地址",6379,1000,"123456");
    }
    
    //获取Jedis对象
    public static Jedis getJedis() {
        return jeidsPool.getResource();
    }
}

3.2.2.2Jedis连接池操作

调用配置的连接池工具类来创建连接，替代直连方式，其他步骤正常使用即可

释放资源的close()在使用连接池后，底层不再是销毁，而是return，归还连接

public class JedisTest {
	private Jedis jedis;
	
	//建立连接
    @BeforeEach
    void setUp() {
        //建立连接，直接调用连接池内的连接
        jedis = JedisConnectionFactory.getJedis();
        //设置密码
        jedis.auth("123456");
        //连接库，选择一个库，不选的话默认是0号库
        jedis.select(0);
    }
    
    //String类型操作
    @Test
    void testString() {
        //存入数据
        String result = jedis.set("name","zhangsan");
        System.out.println("result = "+result);
        //获取数据
        String name = jedis.get("name");
        System.out.println("name = "+name);
	}
	
	//Hash类型操作
	@Test
    void testHash() {
        //插入hash，第一个为key，第二个为field，第三个为value
        jedis.hset("user:1","name","Jack");
        jedis.hset("user:1","age","21");
        //获取全部数据，得到一个Map
        Map<String,String> map = jedis.hgetAll("user:1");
        System.out.println(map);
    }
    
    //释放连接，当使用连接池后，底层的close()便不是销毁，而是归还
    @AfterEach
    void tearDown() {
        if (jedis != null) {
            jedis.close();
        }
    }
}

3.3SpringDataRedis学习

3.3.1SpringDataRedis介绍

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

• 提供了对不同Redis客户端的整合（Lettuce和Jedis）
• 提供了RedisTemplate统一API来操作Redis
• 支持Redis的发布订阅模型
• 支持Redis哨兵和Redis集群
• 支持基于Lettuce的响应式变成
• 支持基于JDk、JSON、字符串、Spring对象的数据序列化及反序列化
• 支持基于Redis的DKCollection实现

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

API	返回值类型	说明
redisTemplate.opsForValue()	ValueOperations	操作String类型数据
redisTemplate.opsForHash()	HashOperations	操作Hash类型数据
redisTemplate.opsForList()	ListOperations	操作List类型数据
redisTemplate.opsForSet()	SetOperations	操作Set类型数据
redisTemplate.opsForZSet()	ZSetOperations	操作SortedSet类型数据
redisTemplate		通用命令

利用对象封装的形式，把不同数据类型的方法封装的到不同对象里面

实际使用的时候可以根据场景选择调用不同的API

3.3.2SpringDataRedis使用

SpringDataRedis的使用步骤：

1. 引入spring-boot-starter-data-redis依赖
2. 在application.yml配置Redis信息
3. 注入RedisTemplate

3.3.2.1引入依赖

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

<!-- Redis依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 连接池依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

3.3.2.2redis配置

在application.yml文件中配置redis信息

spring:
  redis:
    host: ip地址
    port: 6379
    password: 123456
    #默认使用连接池是lettuce，如果要使用jedis还需要在pom文件里面额外导入相关依赖
    #虽然默认lettuce，但是也要手动配置才会生效，否则是不会生效的
    lettuce:
      pool:
        max-active: 8 #最大连接
        max-idle: 8 #最大空闲连接
        min-idle: 0 #最小空闲连接
        max-wait: 100 #连接等待时间

3.3.2.3Redis简单使用

首先，注入RedisTemplate，直接在使用类中注入即可

@Autowired
private RedisTemplate redisTemplate;

使用测试，示例如下：

@Autowired
private RedisTemplate redisTemplate;

@Test
void testString() {
    //插入一条String类型数据
    redisTemplate.opsForValue().set("name","李四");
    //读取一条String类型数据
    Object name = redisTemplate.opsForValue().get("name");
    System.out.println("name = "+name);
}

3.3.3SpringDataRedis的序列化方式

3.3.3.1默认序列化

RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果：

如上述存入可能为：\xe6\x9d\x8e\xe5\x9b\x9b\

“以为name修改了，但是没改，是set一个新的东西进去了，key被序列化了”

缺点：可读性差、内存占用较大

这时我们需要去改变Redis的序列化方式，即我们要“所见即所得”，设置存入什么就能在数据库展示什么

3.3.3.2自定义序列化

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

@Configuration
public class RedisConfig {

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

测试，value写入一个对象：

@Resource
private RedisTemplate<String, Object> redisTemplate;

@GetMapping("/testObject")
public User testObJect() {
    //写入数据，value为User对象
    redisTemplate.opsForValue().set("user:1", new User("Jack",18));
    //获取数据
    User user = (User) redisTemplate.opsForValue().get("user:1");
    System.out.println("user = " + user);
    return user;
}

代码运行中可能出现的报错信息：

• 1.Consider renaming one of the beans or enabling overriding by setting spring.main.allow-bean-definition-overriding=true

在.yml文件中添加如下配置

spring:
	main:
    	allow-bean-definition-overriding: true

• 2.Consider defining a bean of type ‘org.springframework.data.redis.core.RedisTemplate’ in your configuration.

将注入RedisTemplate的注解从@Autowired修改为@Resource

@Resource
private RedisTemplate<String, Object> redisTemplate;

3.3.3.3StringRedisTemplate解决自定义存储冗余

尽管JSON的序列化方式可以满足我们的需求，但依然存在一些问题。

通过上述自定义序列化配置及测试代码运行后，可在redis数据库中查看到数据格式如下：

{
	"@type":"com.byd.micro.scraps.dancyTest.User",
	"age":18,
	"name":"Jack"
}

为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销，如：“@type”:“com.byd.micro.scraps.dancyTest.User”

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

Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程：

【原来的配置类不需要使用了，直接注入StringRedisTemplate即可】

@Autowired
private StringRedisTemplate stringRedisTemplate;

private static final ObjectMapper MAPPER = new ObjectMapper();

@GetMapping("/testSpingObject")
public User testSpingObject() throws JsonProcessingException {
    //创建对象
    User user = new User("Dancy",21);
    //手动序列化
    String json = MAPPER.writeValueAsString(user);
    //写入数据
    stringRedisTemplate.opsForValue().set("user:2", json);
    //获取数据
    String jsonUser = stringRedisTemplate.opsForValue().get("user:2");
    //手动反序列化
    User user1 = MAPPER.readValue(json,User.class);
    System.out.println("user = " + user);
    return user1;
}

可查看到Redis存入的数据如下，非常清爽，没有冗余的数据

{
	"name":"Dancy",
	"age":21
}

上述代码需要注意的是，value存入对象时，需要使用到序列化工具手动进行JSON序列化和反序列化

如果value存入为string，则不需要，直接将redisTemplate替换成stringRedisTemplate即可

@GetMapping("/testString")
public Object testString() {
    //插入一条String类型数据
    stringRedisTemplate.opsForValue().set("name","李四");
    //读取一条String类型数据
    Object name = stringRedisTemplate.opsForValue().get("name");
    System.out.println("name = "+name);
    return name;
}

3.3.3.4序列化方式总结

RedisTemplate的两种序列化实践方案：

方案一：

1.自定义RedisTemplate

2.修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer

这样在做JSON的序列化和反序列化的时候会自动处理，但是它的弊端是会占用额外的内存空间去记录class的类型

方案二：

1.使用StringRedisTemplate

2.写入Redis时，手动把对象序列化为JSON

3.读取Redis时，手动把读取到的JSON反序列化为对象

每次都要手动设置写入和读取的序列化和反序列化，但是存入Redis的数据会变得非常清爽

以上两种方式各有利弊，可根据实际使用场景或喜好进行选择，从Redis性能方面，更推荐第二种

3.3.3.5补充：hash类型使用

hash类型用法与Map差不多，写入都是用的.put，读取key和value用entries方法，返回一个map集合

@GetMapping("/testHash")
public Map<Object,Object> testHash(){
	//写入数据
    stringRedisTemplate.opsForHash().put("user:9","name","dandan");
    stringRedisTemplate.opsForHash().put("user:9","age","21");
    
    //读取数据
    Map<Object,Object> entries = stringRedisTemplate.opsForHash().entries("user:9");
    
    System.out.println("entries = "+entries);
    return entries;
}

4.Redis实战场景应用

以黑马点评项目为例。

数据库表包含如下：

tb_user：用户表

tb_user_info：用户详情表

tb_shop：商户信息表

tb_shop_type：商户类型表

tb_blog：用户日记表（达人探店日记）

tb_follow：用户关注表

tb_voucher：优惠券表

tb_voucher_order：优惠券的订单表

4.1短信登录

Redis的共享session应用

4.1.1基于session实现登录

1.发送短信验证码

校验手机格式的正则表达式没有找到合适的，此处用的数字校验的表达式代替执行

发送验证码需要调用第三方平台较为复杂，此处暂时不实现，仅作模拟成功发送

//Controller层：

@PostMapping("/code")
    public AjaxResult sendCode(@RequestParam("phone") String phone, HttpSession session) {
        // TODO 发送短信验证码并保存验证码
        return userService.sendCode(phone,session);
    }

//ServiceImpl层：

public AjaxResult sendCode(String phone, HttpSession session) {
    //1.校验手机号是否符合规范--可用手机号验证的正则表达式来完成
    Pattern pattern = Pattern.compile("[0-9]*\\.?[0-9]+");
    Matcher isPhoneInvalid = pattern.matcher(phone);
    if (!isPhoneInvalid.matches()) {
    //2.如果不符合，返回错误信息
    return AjaxResult.error("手机格式错误！");
    }
    //3.符合，生成验证码--调用hutool工具随机生成6位数字
    String code = RandomUtil.randomNumbers(6);
    //4.保存验证码到session
    session.setAttribute("code",code);
    //5.发送验证码--需要调用第三方平台，暂时不实现
    log.debug("发送短信验证码成功，验证码：{}",code);
    //返回ok
    return AjaxResult.success("发送成功");
}

2.短信验证码登录、注册

3.校验登录状态

4.1.2集群的session共享问题

4.1.3基于Redis实现共享session登录

4.2商户查询缓存

企业的缓存使用技巧

缓存雪崩、穿透等问题解决

4.3优惠券秒杀

Redis的计数器、Lua脚本Redis

分布式锁

Redis的三种消息队列

4.4达人探店

基于List的点赞列表

基于SortedSet的点赞排行榜

4.5好友关注

基于Set集合的关注、取关、共同关注、消息推送等功能

4.6附近的商户

Redis的GeoHash的应用

4.7用户签到

Redis的BitMap数据统计功能

4.8UV统计

ult sendCode(String phone, HttpSession session) {
//1.校验手机号是否符合规范–可用手机号验证的正则表达式来完成
Pattern pattern = Pattern.compile(“[0-9]*\.?[0-9]+”);
Matcher isPhoneInvalid = pattern.matcher(phone);
if (!isPhoneInvalid.matches()) {
//2.如果不符合，返回错误信息
return AjaxResult.error(“手机格式错误！”);
}
//3.符合，生成验证码–调用hutool工具随机生成6位数字
String code = RandomUtil.randomNumbers(6);
//4.保存验证码到session
session.setAttribute(“code”,code);
//5.发送验证码–需要调用第三方平台，暂时不实现
log.debug(“发送短信验证码成功，验证码：{}”,code);
//返回ok
return AjaxResult.success(“发送成功”);
}

2.短信验证码登录、注册

3.校验登录状态

### 4.1.2集群的session共享问题

### 4.1.3基于Redis实现共享session登录

## 4.2商户查询缓存

企业的缓存使用技巧

缓存雪崩、穿透等问题解决

## 4.3优惠券秒杀

Redis的计数器、Lua脚本Redis

分布式锁

Redis的三种消息队列

## 4.4达人探店

基于List的点赞列表

基于SortedSet的点赞排行榜

## 4.5好友关注

基于Set集合的关注、取关、共同关注、消息推送等功能

## 4.6附近的商户

Redis的GeoHash的应用

## 4.7用户签到

Redis的BitMap数据统计功能

## 4.8UV统计

Redis的HyperLogLog的统计功能