资料来源：https://www.bilibili.com/video/BV1GV411U78a?p=9&spm_id_from=pageDriver

一、Redis分布式缓存设计（String专题）

1、Springboot集成Redis

1.1 Springboot+mybatis+Redis的缓存实战
1.2 案例实战：重写Redis的序列化
优化重写Redis的序列化，改为Json方式
为什么要重写Redis序列化方式，改为Json呢？
因为RedisTemplate默认使用的是JdkSerializationRedisSerializer，会出现2个问题：
1、被序列化的对象必须实现Serializable接口

@Table(name = "users")
public class User implements  Serializable {

2、被序列化会出现乱码,导致value值可读性差

127.0.0.1:6379> keys *
  1) "\xac\xed\x00\x05t\x00\auser:62"
  2) "\xac\xed\x00\x05t\x00\auser:65"
  3) "\xac\xed\x00\x05t\x00\auser:50"
  4) "\xac\xed\x00\x05t\x00\auser:36"
  5) "\xac\xed\x00\x05t\x00\x06user:6"
  6) "\xac\xed\x00\x05t\x00\auser:17"
  7) "\xac\xed\x00\x05t\x00\auser:28"
127.0.0.1:6379> get "\xac\xed\x00\x05t\x00\auser:62"
"\xac\xed\x00\x05sr\x00\x1acom.agan.redis.entity.User?\xebU\xa1\xe2\xa6\xfe\xe3\x02\x00\aL\x00\ncreateTimet
\x00\x10Ljava/util/Date;L\x00\adeletedt\x00\x10Ljava/lang/Byte;L\x00\x02idt\x00\x13Ljava/lang/Integer;L\x00
\bpasswordt\x00\x12Ljava/lang/String;L\x00\x03sexq\x00~\x00\x02L\x00\nupdateTimeq\x00~\x00\x01L\x00\buser
nameq\x00~\x00\x04xpsr\x00\x0ejava.util.Datehj\x81\x01KYt\x19\x03\x00\x00xpw\b\x00\x00\x01o+5\x1d\xf8xsr
\x00\x0ejava.lang.Byte\x9cN`\x84\xeeP\xf5\x1c\x02\x00\x01B\x00\x05valuexr\x00\x10java.lang.Number\x86\xac
\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00sr\x00\x11java.lang.Integer\x12\xe2\xa0\xa4\xf7\x81\x878\x02\x00
\x01I\x00\x05valuexq\x00~\x00\t\x00\x00\x00>t\x00\x04un59q\x00~\x00\nsq\x00~\x00\x06w\b\x00\x00\x01o+5\x1d
\xf8xt\x00\x04un59"

@Configuration
public class RedisConfiguration {
    /**
     * 重写Redis序列化方式，使用Json方式:
     * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到Redis的。
     * RedisTemplate默认使用的是JdkSerializationRedisSerializer，
     * StringRedisTemplate默认使用的是StringRedisSerializer。
     *
     * Spring Data JPA为我们提供了下面的Serializer：
     * GenericToStringSerializer、Jackson2JsonRedisSerializer、
     * JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、
     * OxmSerializer、StringRedisSerializer。
     * 在此我们将自己配置RedisTemplate并定义Serializer。
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //创建一个json的序列化对象
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //设置value的序列化方式json
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //设置key序列化方式string
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置hash key序列化方式string
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //设置hash value的序列化方式json
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

体验：

• 先把user的序列化删除
• 创建类RedisConfiguration
• flushdb：清空redis的旧数据，因为改了序列化，老数据以及不能兼容了，必须清空旧数据
• 往redis 初始化100条数据
• 用 keys 命令查看所有key ```java 127.0.0.1:6379> keys 1) “user:187” 2) “user:117” 3) “user:170” 4) “user:139” 5) “user:157”

127.0.0.1:6379> get user:187 “{\”@class\”:\”com.agan.redis.entity.User\”,\”id\”:187,\”username\”:\”un84\”,\”password\”:\”un84\”, \”sex\”:0,\”deleted\”:0,\”updateTime\”:[\”java.util.Date\”,1576983528000], \”createTime\”:[\”java.util.Date\”,1576983528000]}”

<a name="pkg4X"></a>
## 2、Springcache集成Redis
<a name="ej9o0"></a>
### 2.1 为什么要用springcache，它解决了什么问题？
 SpringCache是spring3.1版本发布出来的，他是对使用缓存进行封装和抽象，通过在方法上使用annotation注解就能拿到缓存结果。<br />    正是因为用了annotation，所以它解决了业务代码和缓存代码的耦合度问题，即再不侵入业务代码的基础上让现有代码即刻支持缓存，它让开发人员无感知的使用了缓存。<br /> 特别注意: 对于Redis的缓存，SpringCache只支持String，其他的Hash 、List、set、ZSet都不支持
<a name="wuDty"></a>
### 2.2 Springcache实现缓存
**步骤1：pom文件加入依赖包**
```java
<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--spring cache-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!--spring cache连接池依赖包-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.6.2</version>
</dependency>

步骤2：配置文件，加入redis配置信息

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

步骤3：开启缓存配置，设置序列化
重点是开启 @EnableCaching

@Configuration
@EnableCaching
public class RedisConfig {
    @Primary
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration
                // 设置缓存的默认超时时间：30分钟
                .entryTtl(Duration.ofMinutes(30L))
                // 如果是空值，不缓存
                .disableCachingNullValues()
                // 设置key序列化器
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
                // 设置value序列化器
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()));
        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration)
                .build();
    }
    /**
     *     key序列化器
     */
    private RedisSerializer<String> keySerializer() {
        return new StringRedisSerializer();
    }
    /**
     *     value序列化器
     */
    private RedisSerializer<Object> valueSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }
}

步骤4：逻辑代码

@Api(description = "用户接口")
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
    @ApiOperation("单个用户查询，按userid查用户信息")
    @RequestMapping(value = "/findById/{id}", method = RequestMethod.GET)
    public UserVO findById(@PathVariable int id) {
        User user = this.userService.findUserById(id);
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(user, userVO);
        return userVO;
    }
    @ApiOperation("修改某条数据")
    @PostMapping(value = "/updateUser")
    public void updateUser(@RequestBody UserVO obj) {
        User user = new User();
        BeanUtils.copyProperties(obj, user);
        userService.updateUser(user);
    }
    @ApiOperation("按id删除用户")
    @RequestMapping(value = "/del/{id}", method = RequestMethod.GET)
    public void deleteUser(@PathVariable int id) {
        this.userService.deleteUser(id);
    }
}

@Service
@CacheConfig(cacheNames = { "user" })
public class UserService {
    private static final Logger LOGGER = LoggerFactory.getLogger(UserService.class);
    @Autowired
    private UserMapper userMapper;
    @Cacheable(key="#id")
    public User findUserById(Integer id){
        return this.userMapper.selectByPrimaryKey(id);
    }
    @CachePut(key = "#obj.id")
    public User updateUser(User obj){
        this.userMapper.updateByPrimaryKeySelective(obj);
        return this.userMapper.selectByPrimaryKey(obj.getId());
    }
    @CacheEvict(key = "#id")
    public void deleteUser(Integer id){
        User user=new User();
        user.setId(id);
        user.setDeleted((byte)1);
        this.userMapper.updateByPrimaryKeySelective(user);
    }
}

2.3 剖析SpringCache常用注解

@CacheConfig(cacheNames = { "user" })
public class UserService {
    private static final Logger LOGGER = LoggerFactory.getLogger(UserService.class);
    @Autowired
    private UserMapper userMapper;
    @Cacheable(key="#id")
    public User findUserById(Integer id){
        return this.userMapper.selectByPrimaryKey(id);
    }
    @CachePut(key = "#obj.id")
    public User updateUser(User obj){
        this.userMapper.updateByPrimaryKeySelective(obj);
        return this.userMapper.selectByPrimaryKey(obj.getId());
    }
    @CacheEvict(key = "#id")
    public void deleteUser(Integer id){
        User user=new User();
        user.setId(id);
        user.setDeleted((byte)1);
        this.userMapper.updateByPrimaryKeySelective(user);
    }
}

@CacheConfig是类级别的注解，统一该类的所有缓存可以前缀。

@CacheConfig(cacheNames = { "user" })
public class UserService {

以上代码，代表了该类的所有缓存可以都是”user::”为前缀

@Cacheable是方法级别的注解，用于将方法的结果缓存起来。

@Cacheable(key="#id")
public User findUserById(Integer id){
    return this.userMapper.selectByPrimaryKey(id);
}

以上方法被调用时，先从缓存中读取数据，如果缓存没有找到数据，再执行方法体，最后把返回值添加到缓存中。
注意：
@Cacheable 一般是配合@CacheConfig一起使用的 例如上文的@CacheConfig(cacheNames = { “user” }) 和 @Cacheable(key=”#id”)一起使用时。 调用方法传入id=100,那redis对应的key=user::100 ,value通过采用GenericJackson2JsonRedisSerializer序列化为json 调用方法传入id=200,那redis对应的key=user::200 ,value通过采用GenericJackson2JsonRedisSerializer序列化为json

@CachePut是方法级别的注解，用于更新缓存。

@CachePut(key = "#obj.id")
public User updateUser(User obj){
    this.userMapper.updateByPrimaryKeySelective(obj);
    return this.userMapper.selectByPrimaryKey(obj.getId());
}

以上方法被调用时，先执行方法体，然后springcache通过返回值更新缓存，即key = “#obj.id”，value=User

@CachePut是方法级别的注解，用于删除缓存。

public void deleteUser(Integer id){
    User user = new User();
    user.setId(id);
    user.setDeleted((byte)1);
    this.userMapper.updateByPrimaryKeySelective(user);
}

以上方法被调用时，先执行方法体，在通过方法参数删除缓存

2.4 SpringCache的大坑

对于Redis的缓存，SpringCache只支持String，其他的Hash 、List、set、ZSet都不支持， 所以对于Hash 、List、set、ZSet只能用RedisTemplate
对于多表查询的数据缓存，SpringCache是不支持的，只支持单表的简单缓存。 对于多表的整体缓存，只能用RedisTemplate。

3、淘宝商品分布式全局ID

3.1 为什么分布式系统需要全局唯一ID
3.2 全局唯一ID必须具备什么特点
3.3 剖析淘宝商品ID的特点
3.4 基于Redis生成分布式全局唯一ID原理
3.5 案例实战：Springboot+Redis生成淘宝商品ID

4、Redis性能优化实战

4.1 真实案例分析Redis的性能瓶颈
4.2 什么事lua
4.3 Redis为什么要是有lua
4.4 LUA的语法入门
4.5 真实案例分析Redis的性能瓶颈及如何优化
4.6 案例实战：Springboot实现多条Redis命令合成一个lua
4.7 案例实战：Redis+lua 实现黑客防刷攻击
4.8 案例实战：Springboot+Redis+lua 实现黑客防刷攻击

5、微信文章的阅读量PV

5.1 微信文章的阅读量场景介绍

这样一个场景： 在微信公众号里面的文章，每个用户阅读一遍文章，该篇文章的阅读量就会加1。如下图：

对于微信这种一线互联网公司，如此大的并发量，一般不可能采用数据库来做计数器，通常都是用redis的incr命令来实现。

5.2 微信文章的阅读量原理：Redis INCR命令

INCR命令，它的全称是increment，用途就是计数器。 每执行一次INCR命令，都将key的value自动加1。 如果key不存在，那么key的值初始化为0，然后再执行INCR操作。
例如：微信文章id=100，做阅读计算如：

127.0.0.1:6379> incr article:100
(integer) 1
127.0.0.1:6379> incr article:100
(integer) 2
127.0.0.1:6379> incr article:100
(integer) 3
127.0.0.1:6379> incr article:100
(integer) 4
127.0.0.1:6379> get article:100
"4"

技术方案的缺陷：需要频繁的修改Redis，耗费CPU，高并发修改Redis会导致Redis的CPU达到100%
使用zset解决高并发问题

5.3 编码实现微信文章的阅读量

@RestController
@Slf4j
public class ViewController {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @GetMapping(value = "/view")
    public void view(Integer id) {
        // redis key
        String key="article:" + id;
        // 调用redis的increment计数器命令
        long n = stringRedisTemplate.opsForValue().increment(key);
        log.info("key={},阅读量为{}", key, n);
    }
}

5.4 课后练习

这节课，我们讲的INCR命令，都是在redis内存操作的，那如何同步到数据库呢？
如果不同步到数据库，就会出现数据丢失，请思考：如何把阅读量PV同步到mydql数据库?

二、Redis分布式缓存设计（hash专题）

1、Redis经典场景：hash存储Java对象

1.1 Redis存储Java对象

Redis存储java对象，一般是String或Hash两种
String的存储通常用在频繁读操作，它的存储格式是json，即把java对象转换为json，然后存入redis
Hash的存储场景应用在频繁写操作，即当对象的某个属性频繁修改时，不适用string+json的数据结构，因为不灵活，每次修改都需要把整个对象转换为json存储。
如果采用hash，就可以针对某个属性单独修改，不用序列号去修改整个对象。例如，商品的库存、价格、关注数、评价数经常变动时，就使用存储hash结果。

1.2 案例实战：SpringBoot+Redis+hash存储商品数据

步骤1：加入依赖包

<!--swagger-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<!--swagger-ui-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
</dependency>
<dependency>
    <groupId>commons-lang</groupId>
    <artifactId>commons-lang</artifactId>
    <version>2.6</version>
</dependency>

步骤2：创建商品的Redis处理

@RestController
@Slf4j
@RequestMapping(value = "/pruduct")
public class ProductController {
    @Autowired
    private RedisTemplate redisTemplate;
    @PostMapping(value = "/create")
    public void create(Product obj) {
        // TODO 先进db
        // 创建商品，先把数据添加到数据库，再存入redis
        String key = "product:"+1000;
        // 将Object对象里面的属性和值转化成Map对象
        Map<String, Object> map = this.objectToMap(obj);
        // 批量put操作：putAll等于hmset命令
        // String数据结构opsForValue、hash数据结构opsForHash
        this.redisTemplate.opsForHash().putAll(key, map);
        Object name = redisTemplate.opsForHash().get(key, "name");
        log.info("name={}",name);
        Object price = redisTemplate.opsForHash().get(key, "price");
        log.info("price={}",price);
        Object detail = redisTemplate.opsForHash().get(key, "detail");
        log.info("detail={}",detail);
    }
    /**
     * 将Object对象里面的属性和值转化成Map对象
     */
    public  Map<String, Object> objectToMap(Object obj)  {
        Map<String, Object> map = new HashMap<String,Object>();
        Class<?> clazz = obj.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            field.setAccessible(true);
            String fieldName = field.getName();
            Object value = null;
            try {
                value = field.get(obj);
            } catch (IllegalAccessException e) {
                log.error(e.getMessage());
            }
            map.put(fieldName, value);
        }
        return map;
    }
}

步骤3：解决序列化问题

127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x0cproduct:1000"
127.0.0.1:6379> hgetAll "\xac\xed\x00\x05t\x00\x0cproduct:1000"
1) "\xac\xed\x00\x05t\x00\x02id"
2) ""
3) "\xac\xed\x00\x05t\x00\x06detail"
4) "\xac\xed\x00\x05t\x00\x03www"
5) "\xac\xed\x00\x05t\x00\x05price"
6) "\xac\xed\x00\x05sr\x00\x11java.lang.Integer\x12\xe2\xa0\xa4\xf7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\a\xd0"
7) "\xac\xed\x00\x05t\x00\x04name"
8) "\xac\xed\x00\x05t\x00\x06huawei"
127.0.0.1:6379>
127.0.0.1:6379>
127.0.0.1:6379>
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> keys *
1) "product:1000"
127.0.0.1:6379> hgetall product:1000
1) "price"
2) "2000"
3) "name"
4) "\"huawei\""
5) "id"
6) ""
7) "detail"
8) "\"www\""

@Configuration
public class RedisConfiguration {
    /**
     * 重写Redis序列化方式，使用Json方式:
     * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到Redis的。
     * RedisTemplate默认使用的是JdkSerializationRedisSerializer，
     * StringRedisTemplate默认使用的是StringRedisSerializer。
     *
     * Spring Data JPA为我们提供了下面的Serializer：
     * GenericToStringSerializer、Jackson2JsonRedisSerializer、
     * JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、
     * OxmSerializer、StringRedisSerializer。
     * 在此我们将自己配置RedisTemplate并定义Serializer。
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 创建一个json的序列化对象
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置value的序列化方式json
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // 设置key序列化方式string
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 设置hash key序列化方式string
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 设置hash value的序列化方式json
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

步骤4：商品涨价

@PostMapping(value = "/addPrice")
public void addPrice(int id, int price) {
    String key = "product:" + id;
    // 商品价格涨价：increment等于hincrby命令
    redisTemplate.opsForHash().increment(key, "price", price);
    Object price2 = redisTemplate.opsForHash().get(key, "price");
    log.info("price={}",price2);
}

2、淘宝短链接实战

2.1 体验淘宝短链接业务场景

场景1：淘宝短信

【天猫】有优惠啦！黄皮金煌芒果（水仙芒）带箱10斤49.8元！ 
核薄无丝很甜喔！购买： c.tb.cn/c.ZzhFZ0 急鲜丰 退订回TD

打开IE，输入：c.tb.cn/c.ZzhFZ0 就转变为如下：https://h5.m.taobao.com/ecrm/jump-to-app.html?scm=20140608.2928562577.LT_ITEM.1699166744&target_url= http%3A%2F%2Fh5.m.taobao.com%2Fawp%2Fcore%2Fdetail.htm%3Fid%3D567221004504%26scm=20140607.2928562577. LT_ITEM.1699166744&spm=a313p.5.1cfl9ch.947174560063&short_name=c.ZzhFZ0&app=chrome

场景2：淘宝APP分享URL

【这个#聚划算团购#宝贝不错:【官方旗舰】步步高家教机S5英语小学初高中课本同步小天才平板 
儿童点读学习机智能学生平板电脑护眼旗舰店(分享自@手机淘宝android客户端)】 https://m.tb.cn/h.eAE6vuE  
點￡擊☆鏈ㄣ接，再选择瀏覽→噐咑ぺ鐦；或椱ァ製这句话€eyuf1YeAXFf€后打开👉淘宀┡ē👈

打开IE，输入https://m.tb.cn/h.eAE6vuE 就转变为如下: https://detail.tmall.com/item.htm?id=597254411409&price=3998-4398&sourceType=item&sourceType=item&suid= 4c8fc4d8-cb5e-40c0-b4b6-c4a06598781a&ut_sk=1.WmH11veugHoDAGWzSv+jAZg2_21646297_1574219840558.Copy.1&un =ceed7d76bfbe7a3b4b68d5f77a161062&share_crt_v=1&spm=a2159r.13376460.0.0&sp_tk=4oKzaUU0SllFcWZuRjLigrM= &cpp=1&shareurl=true&short_name=h.eF25Q3n&sm=505e90&app=chrome&sku_properties=1627207:28332
体验了以上2个场景，我们来总结：

1. 先说下什么是短链接？ 就是把普通网址，转换成比较短的网址。
2. 短链接有什么好处？

• 节省网址长度，便于社交化传播。

• 方便后台跟踪点击量、统计。

  public static void main(String[] args) {
    String str="566ab90f";
    System.out.println("2进制: " + Long.toBinaryString(0x3FFFFFFF));
    // 566ab90f
    System.out.println("2进制：" + Long.toBinaryString(0x566ab90f));
    System.out.println("格式化后：" + Long.toBinaryString(0x3fffffff & 0x566ab90f));
    System.out.println("0x0000003D：2进制：" + Long.toBinaryString(0x0000003D));
    System.out.println("0x0000003D：10进制：" + Long.parseLong("0000003D", 16));
  }

  import org.apache.commons.codec.digest.DigestUtils;
  /**
  * 将长网址 md5 生成 32 位签名串，分为 4 段, 每段 8 个字节
  * 对这四段循环处理, 取 8 个字节, 将他看成 16 进制串与 0x3fffffff(30位1) 与操作, 即超过 30 位的忽略处理
  * 这 30 位分成 6 段, 每 5 位的数字作为字母表的索引取得特定字符, 依次进行获得 6 位字符串
  * 总的 md5 串可以获得 4 个 6 位串,取里面的任意一个就可作为这个长 url 的短 url 地址
  */
  public class ShortUrlGenerator {
    //26+26+10=62
    public static  final  String[] chars = new String[]{"a", "b", "c", "d", "e", "f", "g", "h",
            "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
            "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
            "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H",
            "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
            "U", "V", "W", "X", "Y", "Z"};
    /**
     * 一个长链接URL转换为4个短KEY
     */
    public static String[] shortUrl(String url) {
        String key = "";
        // 对地址进行md5
        String sMD5EncryptResult = DigestUtils.md5Hex(key + url);
        System.out.println(sMD5EncryptResult);
        String hex = sMD5EncryptResult;
        String[] resUrl = new String[4];
        for (int i = 0; i < 4; i++) {
            // 取出8位字符串，md5 32位，被切割为4组，每组8个字符
            String sTempSubString = hex.substring(i * 8, i * 8 + 8);
            // 先转换为16进账，然后用0x3FFFFFFF进行位与运算，目的是格式化截取前30位
            long lHexLong = 0x3FFFFFFF & Long.parseLong(sTempSubString, 16);
            String outChars = "";
            for (int j = 0; j < 6; j++) {
                // 0x0000003D代表什么意思？他的10进制是61，61代表chars数组长度62的0到61的坐标。
                // 0x0000003D & lHexLong进行位与运算，就是格式化为6位，即61内的数字
                // 保证了index绝对是61以内的值
                long index = 0x0000003D & lHexLong;
                outChars += chars[(int) index];
                //每次循环按位移5位，因为30位的二进制，分6次循环，即每次右移5位
                lHexLong = lHexLong >> 5;
            }
            // 把字符串存入对应索引的输出数组
            resUrl[i] = outChars;
        }
        return resUrl;
    }
    public static void main(String[] args) {
        // 长连接
        String longUrl = "https://detail.tmall.com/item.htm?id=597254411409";
        // 转换成的短链接后6位码，返回4个短链接
        String[] shortCodeArray = shortUrl(longUrl);
        for (int i = 0; i < shortCodeArray.length; i++) {
            // 任意一个都可以作为短链接码
            System.out.println(shortCodeArray[i]);
        }
    }
  }

  2.2 案例实战：SpringBoot+Redis高并发《短链接转换器》

  《短链接转换器》的原理：

  1. 长链接转换为短链接 - 实现原理：长链接转换为短链接加密串key，然后存储于Redis的hash结构中。

  2. 重定向到原始的url - 实现原理：通过加密串key到Redis找出原始url，然后重定向出去

     @RestController
     @Slf4j
     public class ShortUrlController {
     @Autowired
     private HttpServletResponse response;
     @Autowired
     private RedisTemplate redisTemplate;
     private  final static  String SHORT_URL_KEY="short:url";
     /**
     * 长链接转换为短链接
     * 实现原理：长链接转换为短加密串key，然后存储在redis的hash结构中。
     */
     @GetMapping(value = "/encode")
     public String encode(String url) {
       // 一个长链接url转换为4个短加密串key
       String [] keys = ShortUrlGenerator.shortUrl(url);
       // 任意取出其中一个，我们就拿第一个
       String key = keys[0];
       // 用hash存储，key = 加密串，value = 原始url
       redisTemplate.opsForHash().put(SHORT_URL_KEY, key, url);
       log.info("长链接 = {}，转换 = {}", url, key);
       return "http://127.0.0.1:9090/" + key;
     }
     /**
     * 重定向到原始的URL
     * 实现原理：通过短加密串KEY到redis找出原始URL，然后重定向出去
     */
     @GetMapping(value = "/{key}")
     public void decode(@PathVariable String key) {
       // 到redis中把原始url找出来
       String url = (String)redisTemplate.opsForHash().get(SHORT_URL_KEY, key);
       try {
           // 重定向到原始的url
           response.sendRedirect(url);
       } catch (IOException e) {
           e.printStackTrace();
       }
     }
     }

     @Configuration
     public class RedisConfiguration {
     /**
     * 重写Redis序列化方式，使用Json方式:
     * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。
     * Spring Data JPA为我们提供了下面的Serializer：
     * GenericToStringSerializer、Jackson2JsonRedisSerializer、JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。
     * 在此我们将自己配置RedisTemplate并定义Serializer。
     * @param redisConnectionFactory
     * @return
     */
     @Bean
     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
       RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
       redisTemplate.setConnectionFactory(redisConnectionFactory);
       GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
       redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
       redisTemplate.setKeySerializer(new StringRedisSerializer());
       redisTemplate.setHashKeySerializer(new StringRedisSerializer());
       redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
       redisTemplate.afterPropertiesSet();
       return redisTemplate;
     }
     }

     3、京东双11购物车实战

     3.1 京东购物车多种场景分析

     步骤1：先登录你的京东账号，清空以前购物车，然后添加1件商品A，保证你的购物车只有1件商品A
     步骤2：退出登录，购物车添加商品B，然后关闭浏览器再打开。（购物车的商品B仍存在）
     步骤3：再次登录你的京东账号。（购物车有两件商品）

     3.2 图解分析：双11高并发的京东购物车技术实现

     1、登录状态添加商品到购物车

     

     2、未登录状态添加商品到购物车

     

     3、登录状态合并购物车

     

     3.3 购物车的Redis经典场景

     场景一：往购物车加入2件商品，采用hash数据结果，key=cart: user: 用户id

     127.0.0.1:6379> hset cart:user:1000 101 1
     (integer) 1
     127.0.0.1:6379> hset cart:user:1000 102 1
     (integer) 1
     127.0.0.1:6379> hgetall cart:user:1000
     1) "101"
     2) "1"
     3) "102"
     4) "1"

     场景二：修改购物车的数据，为某件商品添加数量

     127.0.0.1:6379> hincrby cart:user:1000 101 1
     (integer) 2
     127.0.0.1:6379> hincrby cart:user:1000 102 10
     (integer) 11
     127.0.0.1:6379> hgetall cart:user:1000
     1) "101"
     2) "2"
     3) "102"
     4) "11"

     场景三：统计购物车有多少件商品

     127.0.0.1:6379> hlen cart:user:1000
     (integer) 2

     场景四：删除购物车某件商品

     127.0.0.1:6379> hdel cart:user:1000 102
     (integer) 1
     127.0.0.1:6379> hgetall cart:user:1000
     1) "101"
     2) "2"

     3.4 案例实战：SpringBoot+Redis实现高并发购物车

     ```java @Autowired private RedisTemplate redisTemplate;

/**

• 购物车key的前缀 */ public static final String CART_KEY = “cart:user:”;

/**

• 添加购物车 */ @PostMapping(value = “/addCart”) public void addCart(Cart obj) { String key = CART_KEY + obj.getUserId(); Boolean hasKey = redisTemplate.opsForHash().getOperations().hasKey(key); // 存在 if(hasKey){

   this.redisTemplate.opsForHash().put(key, obj.getProductId().toString(), obj.getAmount());

  }else{

   this.redisTemplate.opsForHash().put(key, obj.getProductId().toString(), obj.getAmount());
   this.redisTemplate.expire(key,90, TimeUnit.DAYS);

  } //TODO 发rabbitmq 出去 }

/**

• 修改购物车的数量 */ @PostMapping(value = “/updateCart”) public void updateCart(Cart obj) { String key = CART_KEY + obj.getUserId(); this.redisTemplate.opsForHash().put(key, obj.getProductId().toString(), obj.getAmount()); //TODO 发rabbitmq 出去 }

/* 删除购物车 */ @PostMapping(value = “/delCart”) public void delCart(Long userId, Long productId) { String key = CART_KEY + userId; this.redisTemplate.opsForHash().delete(key, productId.toString()); //TODO 发rabbitmq 出去 }

@PostMapping(value = “/findAll”) public CartPage findAll(Long userId) { String key = CART_KEY + userId; CartPage cartPage = new CartPage(); // 查购物车的总数 long size = this.redisTemplate.opsForHash().size(key); cartPage.setCount((int) size);

// 查询购物车的所有商品
// entries = hgetall命令
Map<String, Integer> map = this.redisTemplate.opsForHash().entries(key);
List<Cart> cartList = new ArrayList<>();
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    Cart cart = new Cart();
    cart.setUserId(userId);
    cart.setProductId(Long.parseLong(entry.getKey()));
    cart.setAmount(entry.getValue());
    cartList.add(cart);
}
cartPage.setCartList(cartList);
return cartPage;

}

```java
@Data
public class Cart {
    private Long userId;
    private Long productId;
    private int amount;
}
@Data
public class CartPage<T> {
    private List<T> cartList;
    private int count;
}

3.5 案例实战：SpringBoot+Redis+Cookies实现高并发的购物车

@RestController
@Slf4j
@RequestMapping(value = "/cookiecart")
public class CookieCartController {
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private IdGenerator idGenerator;
    @Autowired
    private HttpServletRequest request;
    @Autowired
    private HttpServletResponse response;
    public static final String COOKIE_KEY = "cart:cookie:";
    /**
     * 添加购物车
     */
    @PostMapping(value = "/addCart")
    public void addCart(CookieCart obj) {
        String cartId = this.getCookiesCartId();
        String key = COOKIE_KEY + cartId;
        Boolean hasKey = redisTemplate.opsForHash().getOperations().hasKey(key);
        // 存在
        if(hasKey){
            this.redisTemplate.opsForHash().put(key, obj.getProductId().toString(),obj.getAmount());
        }else{
            this.redisTemplate.opsForHash().put(key, obj.getProductId().toString(), obj.getAmount());
            this.redisTemplate.expire(key,90, TimeUnit.DAYS);
        }
    }
    /**
     * 修改购物车
     */
    @PostMapping(value = "/updateCart")
    public void updateCart(CookieCart obj) {
        String cartId = this.getCookiesCartId();
        String key = COOKIE_KEY + cartId;
        this.redisTemplate.opsForHash().put(key, obj.getProductId().toString(), obj.getAmount());
    }
    /**
     * 删除购物车
     */
    @PostMapping(value = "/delCart")
    public void delCart(Long productId) {
        String cartId = this.getCookiesCartId();
        String key = COOKIE_KEY + cartId;
        this.redisTemplate.opsForHash().delete(key, productId.toString());
    }
    /**
     * 查询某个用户的购物车
     */
    @PostMapping(value = "/findAll")
    public CartPage findAll() {
        String cartId = this.getCookiesCartId();
        String key = COOKIE_KEY + cartId;
        CartPage<CookieCart> cartPage = new CartPage();
        // 查询该用户购物车的总数
        long size = this.redisTemplate.opsForHash().size(key);
        cartPage.setCount((int)size);
        // 查询购物车的所有商品
        Map<String,Integer> map = this.redisTemplate.opsForHash().entries(key);
        List<CookieCart> cartList = new ArrayList<>();
        for (Map.Entry<String,Integer> entry:map.entrySet()){
            CookieCart cart = new CookieCart();
            cart.setProductId(Long.parseLong(entry.getKey()));
            cart.setAmount(entry.getValue());
            cartList.add(cart);
        }
        cartPage.setCartList(cartList);
        return cartPage;
    }
    /**
     * 获取cookies
     */
    public  String getCookiesCartId(){
        // 第一步：先检查cookies是否有cartid
        Cookie[] cookies =  request.getCookies();
        if(cookies != null){
            for(Cookie cookie : cookies){
                if(cookie.getName().equals("cartId")){
                    return cookie.getValue();
                }
            }
        }
        // 第二步：cookies没有cartid，直接生成全局id，并设置到cookie里面
        // 生成全局唯一id
        long id = this.idGenerator.incrementId();
        // 设置到cookies
        Cookie cookie = new Cookie("cartId", String.valueOf(id));
        response.addCookie(cookie);
        return id + "";
    }
    /**
     * 合并购物车
     * 把cookie中的购物车合并到登录用户的购物车
     */
    @PostMapping(value = "/mergeCart")
    public void mergeCart(Long userId) {
        // 第一步：提取未登录用户的cookie的购物车数据
        String cartId = this.getCookiesCartId();
        String keycookie = COOKIE_KEY+cartId;
        Map<String,Integer> map = this.redisTemplate.opsForHash().entries(keycookie);
        // 第二步：把cookie中得购物车合并到登录用户的购物车
        String keyuser = "cart:user:" + userId;
        this.redisTemplate.opsForHash().putAll(keyuser, map);
        // 第三步：删除redis未登录的用户cookies的购物车数据
        this.redisTemplate.delete(keycookie);
        // 第四步：删除未登录用户cookies的cartid
        Cookie cookie=new Cookie("cartId", null);
        cookie.setMaxAge(0);
        response.addCookie(cookie);
    }
}

@Data
public class CookieCart {
    private Long productId;
    private int amount;
}

@Service
public class IdGenerator {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    private static final String ID_KEY = "id:generator:cart";
    /**
     * 生成全局唯一id
     */
    public Long incrementId() {
        long n=this.stringRedisTemplate.opsForValue().increment(ID_KEY);
        return n;
    }
}

4、Redis解决分布式系统的session不一致问题

1、session的作用

2、分布式session存在的问题

5、微博实战：用户注册

6、微博实战：用户发微博

三、Redis分布式缓存设计（List专题）

1、list命令实战

2、高并发淘宝聚划算商品列表

2.1 需求分析：淘宝聚划算功能

https://ju.taobao.com/
这张页面的特点： 1. 数据量少，才13页 2. 高并发，请求量大

2.2 高并发的淘宝聚划算实现技术方案

像聚划算这种高并发的功能，绝对不可能用数据库的！ 一般的做法是先把数据库中的数据抽取到Redis里面。采用定时器，来定时缓存。 这张页面的特点，数据量不多，才13页。最大的特点就要支持分页。Redis的 list数据结构天然支持这种高并发的分页查询功能。
具体的技术方案采用list 的lpush 和 lrange来实现。

## 先用定时器把数据刷新到list中
127.0.0.1:6379> lpush jhs p1 p2 p3 p4 p5 p6 p7 p8 p9 p10
(integer) 10
## 用lrange来实现分页
127.0.0.1:6379> lrange jhs 0 5
1) "p10"
2) "p9"
3) "p8"
4) "p7"
5) "p6"
6) "p5"
127.0.0.1:6379> lrange jhs 6 10
1) "p4"
2) "p3"
3) "p2"
4) "p1"

2.3 案例实战：SpringBoot+Redis实现淘宝聚划算功能

步骤1：配置redis
步骤2：采用定时器把特价商品都刷入redis缓存中

@Service
@Slf4j
public class TaskService {
    @Autowired
    private RedisTemplate redisTemplate;
    @PostConstruct
    public void initJHS(){
        log.info("启动定时器..........");
        new Thread(()->runJhs()).start();
    }
    /**
     * 模拟定时器，定时把数据库的特价商品，刷新到redis中
     */
    public void runJhs() {
        while (true){
            // 模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
            List<Product> list = this.products();
            // 采用redis list数据结构的lpush来实现存储
            redisTemplate.delete(Constants.JHS_KEY);
            // lpush命令
            redisTemplate.opsForList().leftPushAll(Constants.JHS_KEY, list);
            try {
                // 间隔一分钟 执行一遍
                Thread.sleep(1000*60);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("runJhs定时刷新..............");
        }
    }
    /**
     * 模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
     */
    public List<Product> products() {
        List<Product> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            Random rand = new Random();
            int id = rand.nextInt(10000);
            Product ob j = new Product((long) id, "product" + i, i, "detail");
            list.add(obj);
        }
        return list;
    }
}

@Data
public class Product {
    private Long id;
    /**
     * 产品名称
     */
    private String name;
    /**
     * 产品价格
     */
    private Integer price;
    /**
     * 产品详情
     */
    private String detail;
}

步骤3：Redis分页查询

/**
 * 分页查询：在高并发的情况下，只能走redis查询，走db的话必定会把db打垮
 */
@GetMapping(value = "/find")
public List<Product> find(int page, int size) {
    List<Product> list = null;
    long start = (page - 1) * size;
    long end = start + size - 1;
    try {
        // 采用redis list数据结构的lrange命令实现分页查询
        list = redisTemplate.opsForList().range(Constants.JHS_KEY, start, end);
        if (CollectionUtils.isEmpty(list)) {
            //TODO 走DB查询
        }
        log.info("查询结果：{}", list);
    } catch (Exception ex) {
        // 这里的异常，一般是redis瘫痪 ，或redis网络timeout
        log.error("exception:", ex);
        //TODO 走DB查询
    }
    return list;
}

2.4 如何防止缓存击穿

1、什么是缓存击穿

在高并发的系统中，大量的请求同时查询一个key时，如果这个key正好失效或删除，就会导致大量的请求都打到数据库上面去。这种现象我们称为缓存击穿 如下图：

当查询QPS=1000的时候，这时定时任务更新redis，先删除再添加就会出现缓存击穿，就会导致大量的请求都打到数据库上面去

2、如何解决缓存击穿的问题？

针对这种定时更新缓存的特定场景，解决缓存击穿一般是采用主从轮询的原理来实现。

• 定时器更新原理
  开辟2块缓存，A 和 B，定时器在更新缓存的时候，先更新B缓存，然后再更新A缓存，记得要按这个顺序
  

• 查询原理
  用户先查询缓存A，如果缓存A查询不到（例如，更新缓存的时候删除了），再查下缓存B
  
  以上2个步骤，由原来的一块缓存，开辟出2块缓存，最终解决了缓存击穿的问题

  3、淘宝聚划算的缓存击穿实现

  ```java @PostConstruct public void initJHSAB(){

  log.info(“启动AB定时器……….”); new Thread(()->runJhsAB()).start(); }

public void runJhsAB() {

while (true){
    // 模拟从数据库读取100件 特价商品，用于加载到聚划算页面
    List<Product> list=this.products();
    // 先更新B
    this.redisTemplate.delete(Constants.JHS_KEY_B);
    this.redisTemplate.opsForList().leftPushAll(Constants.JHS_KEY_B,list);
    // 再更新A
    this.redisTemplate.delete(Constants.JHS_KEY_A);
    this.redisTemplate.opsForList().leftPushAll(Constants.JHS_KEY_A,list);
    try {
        Thread.sleep(1000*60);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info("重新刷新..............");
}

}

```java
@GetMapping(value = "/findAB")
public List<Product> findAB(int page, int size) {
    List<Product> list = null;
    long start = (page - 1) * size;
    long end = start + size - 1;
    try {
        // 采用redis list数据结构的lrange命令实现分页查询。
        list = this.redisTemplate.opsForList().range(Constants.JHS_KEY_A, start, end);
        // 用户先查询缓存A，如果缓存A查询不到（例如，更新缓存的时候删除了），再查下缓存B
        if (CollectionUtils.isEmpty(list)) {
            this.redisTemplate.opsForList().range(Constants.JHS_KEY_B, start, end);
        }
        log.info("{}", list);
    } catch (Exception ex) {
        // 这里的异常，一般是redis瘫痪 ，或 redis网络timeout
        log.error("exception:", ex);
        // TODO 走DB查询
    }
    return list;
}

3、高并发的微信抢红包

3.1 微信抢红包的并发场景分析

3.2 微信抢红包的技术实现原理

3.3 案例实战：SpringBoot+Redis实现微信抢红包

private static final String ID_KEY = "id:generator:redpacket";
private static final String RED_PACKET_KEY = "redpacket";
private static final String RED_PACKET_CONSUME_KEY = "redpacket:consume:";
@Autowired
private RedisTemplate redisTemplate;
/**
 * 抢红包的接口
 */
@GetMapping(value = "/rob")
public int rob(int redid, int userid) {
    // 第一步：验证该用户是否已经抢过了
    Object packet = redisTemplate.opsForHash().get(RED_PACKET_CONSUME_KEY + redid, String.valueOf(userid));
    if(packet == null){
        // 第二部：从list队列，弹出一个红包（解决了获取一个红包与从红包队列中删除红包是一个原子性操作）
        Object obj = redisTemplate.opsForList().leftPop(RED_PACKET_KEY + redid);
        if(obj != null){
            // 抢到红包，存起来
            redisTemplate.opsForHash().put(RED_PACKET_CONSUME_KEY + redid, String.valueOf(userid), obj);
            log.info("用户={}抢到{}", userid, obj);
            // TODO 异步把数据落地到数据库中
            return (Integer) obj;
        }
        // -1 代表抢完
        return -1;
    }
    // -2 代表已抢
    return -2;
}
/**
 * 包红包的接口
 */
@GetMapping(value = "/set")
public long setRedpacket(int total, int count) {
    // 拆解分包
    Integer[] packet = this.spiltRedPacket(total, count);
    // 为每个红包生成全局唯一ID
    Long n = this.incrementId();
    // 采用list存储所有拆分后的小红包
    String key = RED_PACKET_KEY + n;
    redisTemplate.opsForList().leftPush(key, packet);
    // 设置3天有效期
    redisTemplate.expire(key, 3, TimeUnit.DAYS);
    log.info("拆解红包{}={}", key, packet);
    return n;
}
/**
 * 生成全局唯一ID
 */
public Long incrementId(){
    Long n = redisTemplate.opsForValue().increment(ID_KEY);
    return n;
}
/**
 * 拆解分包
 * 1、红包金额要被全部拆解完
 * 2、红包之间的金额不能相差太大
 */
public Integer[] spiltRedPacket(int total, int count){
    int use = 0;
    Integer[] array = new Integer[count];
    Random random = new Random();
    for (int i = 0; i < count; i++) {
        if(i == count-1){
            array[i] = total - use;
        }else {
            // 红包随机金额浮动系数
            int avg = (total - use) * 2 / (count - i);
            array[i] = 1 + random.nextInt(avg - 1);
        }
        use = use + array[i];
    }
    return array;
}