No码农

谷粒商城项目总结

前言

一、基础环境搭建

1、安装Linux虚拟机

2、安装docker

2.1、安装MySQL

2.2、docker 安装 redis

2.3、docker 安装 Es和Kibana

2.4、docker 安装 Nginx

二、SpringClound Alibaba

1、Nacos[注册中心、配置中心]

2、Gataway

2.1、简介

2.2、核心概念

2.3、使用

2.4、配置统一的全局跨域

2.5、Gataway配合Nginx进行请求转发

3、Feign 声明式远程调用

3.1、简介

3.2、使用

3.3、Feign远程调用丢失请求头问题

3.4、Feign异步情况丢失上下文问题

三、Java生态知识点

1、JSR303 数据校验

2、统一异常处理

3、ES

3.1、基本概念：

3.2、分词(IK分词器安装)

3.3、整合SpringBoot(Elasticsearch-Rest-Client)

3.4、商城商品检索代码(可当做参考案例)

4、Java虚拟机监控

4.1、jconsole 与 jvisualvm

4.2、项目设值堆内存大小

5、缓存

1、缓存使用

2、本地缓存

3、整合 redis 作为缓存

4、高并发下缓存失效问题

4.1、缓存穿透

4.2、缓存雪崩

4.3、缓存击穿

4.4、加锁(本地锁)解决缓存击穿问题

4.5、加锁(分布式锁)解决缓存击穿问题

5、Redisson 整合

5.1、原生Redisson整合

5.2、使用

6、缓存数据一致性问题

6.1、双写模式

6.2、失效模式

6.3、延迟双删

6.4、总结

6.5、异步更新缓存（基于Mysql binlog的同步机制 Canal)

7、SpringCache

7.1、整合

7.2、使用细节

6、异步和线程

6.1、初始化线程的 4 种方式

6.2、线程池的七大参数

6.3、线程池运行流程

6.4、开发中为什么使用线程池

6.5、CompletableFuture异步编排

7、MD5&盐值&BCrypt

8、社交登陆

1.1、OAuth2.0

1.2、微博登陆准备工作

1、进入微博开放平台，API使用

2、微博登陆流程图和时序图

3、微博登陆代码

1.3、Session共享问题

1.3.1、session原理

1.3.2、分布式下session共享问题

1.3.3、Session共享问题解决

1.3.4、不同服务，子域session共享问题

1.4、整合SpringSession

9、单点登陆(SSO)

1.1、前置概念

1.2、gitee基础代码演示

1.3、单点登录流程

1.4、谷粒商城项目单点登录代码

10、ThreadLocal-同一个线程共享数据编辑

11、消息中间件(MQ)

11.1、用途

11.2、重要概述

11.3、RabbitMQ概念

11.4、Docker安装RabbitMQ

11.5、RabbitMQ运行机制

11.6、SpringBoot 整合 RabbitMQ

11.7、RabbitMQ消息确认机制-可靠抵达

11.8、RabbitMQ延时队列（实现定时任务）

11.8.1、延时队列场景

11.8.2、Schedule 定时任务的时效性问题

11.8.3、消息的TTL（Time To Live）和死信队列(Dead Letter Exchanges（DLX）)

11.8.4、延时队列实现

11.9、注解方式创建队列和交换机和绑定关系

11.10、如何保证消息可靠性

1、保证消息不丢失

2、保证消息不重复

3、保证消息不积压

12、接口幂等性

12.1、什么是幂等性

12.2、哪些情况需要防止

12.3、什么情况下需要幂等

12.4、幂等解决方案

12.4.1、token 机制

12.4.2、各种锁机制

1、数据库悲观锁

2、数据库悲观锁

3、业务层分布式锁

12.4.3、各种唯一约束

1、数据库唯一约束

2、redis set 防重

12.4.4、防重表

12.5、token机制解决案例

13、本地事务&分布式事务

13.1、本地事务

13.1.1、事务的基本性质

13.1.2、事务的隔离级别

13.1.3、事务的传播行为

13.1.4、SpringBoot 事务

13.2、分布式事务

13.2.1、CAP 定理与 BASE 理论

1、CAP 定理

2、BASE 理论

3、强一致性、弱一致性、最终一致性

13.2.2、分布式事务几种方案

1、2PC 模式

2、柔性事务-TCC 事务补偿型方案

3、柔性事务-最大努力通知型方案

4、柔性事务-可靠消息+最终一致性方案（异步确保型）

13、Seata

13.1、Seata术语

13.2、整体机制

13.3、Seata使用

13.2.1、整合

四、运维知识点

1、Nginx的应用

1.1、正向代理与反向代理概念

1.2、Nginx配置文件

1.3、Nginx+Windows搭建域名访问环境

1.3、Nginx 动静分离

2、内网穿透

2.1、简介

2.2、内网穿透图解

2.3、内网穿透的几个常用软件

2.4、花生壳使用流程

五、整合第三方平台

1、阿里云OSS

2、阿里云短信服务

3、支付宝支付

3.1、加密-对称加密

3.2、加密-非对称加密

3.3、什么是公钥、私钥、加密、签名和验签

3.4、支付宝加密验签流程图

3.5、支付宝配置沙箱环境

六、测试

1、压力测试

1.1、概念

1.2、性能指标

1.3、JMeter 安装和使用

前言

视频地址：01、简介-项目介绍_哔哩哔哩_bilibili
整体的微服务架构图 微服务架构图
微服务划分图
微服务划分图

一、基础环境搭建

1、安装Linux虚拟机

下载&安装 VirtualBox ，系统需要开启 CPU 虚拟化。
下载 & 安装 Vagrant
- Vagrant 官方镜像仓库
- Vagrant 下载
打开 window cmd 窗口，运行命令： vagrant init centos/7 ，即可初始化一个 centos7 系统
运行启动重启命令： vagrant up ，即可启动虚拟机。系统 root 用户的密码是 vagrant
vagrant 其他常用命令
- vagrant ssh：自动使用 vagrant 用户连接虚拟机
- Vagrant 命令行
默认虚拟机的 ip 地址不是固定 ip ，开发不方便。修改 Vagrantfile
- config.vm.network "private_network", ip: "192.168.56.10"
账号默认只允许 ssh 登录方式，为了后来操作方便，文件上传等，我们可以配置允许账

号密码登录。
- Vagrant ssh 进去系统之后
```
vi /etc/ssh/sshd_config
#修改 PasswordAuthentication yes/no
#重启服务 
service sshd restart
```

2、安装docker

docker 安装配置

2.1、安装MySQL

Linux直接安装
下载镜像文件
```
docker pull mysql:5.7
```
创建实例并启动
```
docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7
```
参数说明
-p 3306:3306：将容器的 3306 端口映射到主机的 3306 端口
-v /mydata/mysql/conf:/etc/mysql：将配置文件夹挂载到主机
-v /mydata/mysql/log:/var/log/mysql：将日志文件夹挂载到主机
-v /mydata/mysql/data:/var/lib/mysql/：将配置文件夹挂载到主机
-e MYSQL_ROOT_PASSWORD=root：初始化 root 用户的密码

配置 MySQL

vi /mydata/mysql/conf/my.cnf
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci' init_connect='SET NAMES utf8' character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
#跳过域名解析
skip-name-resolve

通过容器的 mysql 命令行工具连接

docker exec -it mysql mysql -uroot -proot

设置 root 远程访问,默认只能本机访问

grant all privileges on *.* to 'root'@'%' identified by 'root' with grant option;
flush privileges;

2.2、docker 安装 redis

Linux直接安装
下载镜像文件
```
docker pull redis
```

创建实例并启动

mkdir -p /mydata/redis/conf
touch /mydata/redis/conf/redis.conf

docker run -p 6379:6379 --name redis -v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf

使用 redis 镜像执行 redis-cli 命令连接
```
docker exec -it redis redis-cli
```

2.3、docker 安装 Es和Kibana

下载镜像文件

#存储和检索数据
docker pull elasticsearch:7.4.2 
#可视化检索数据
docker pull kibana:7.4.2

运行启动ES容器
```
#创建文件夹 用于挂载容器内部文件
mkdir -p /mydata/elasticsearch/config
#创建文件夹 用于挂载容器内部文件
mkdir -p /mydata/elasticsearch/data
#允许外部ip访问
echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml
#保证权限
chmod -R 777 /mydata/elasticsearch/ 
#启动容器
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2
```
解释：

容器名：--name elasticsearch

暴露端口：-p 9200:9200(Http访问连接端口) -p 9300:9300(ES集群之间的访问端口)

单节点运行：-e "discovery.type=single-node"
设置内存大小：-e ES_JAVA_OPTS="-Xms64m -Xmx512m"

挂载配置文件目录：-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml
挂载数据存储目录：-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data
挂载插件目录：-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins

启动后：访问http://虚拟机ip:9200 端口

特别注意：

-e ES_JAVA_OPTS="-Xms64m -Xmx256m" \ 测试环境下，设置 ES 的初始内存和最大内存，否则导致过大启动不了 ES

运行启动Kibana

#http://192.168.56.10:9200 一定改为自己虚拟机的地址
docker run --name kibana -e ELASTICSEARCH_HOSTS=http://192.168.56.10:9200 -p 5601:5601 \
-d kibana:7.4.2

2.4、docker 安装 Nginx

随便启动一个 nginx 实例，只是为了复制出配置

#启动一个实例
docker run -p 80:80 --name nginx -d nginx:1.10
#将容器内的配置文件拷贝到当前目录 别忘了后面的点
docker container cp nginx:/etc/nginx .
mkdir /mydata/nginx
#修改文件名称，
mv nginx conf 
#把这个 conf 移动到/mydata/nginx 下
mv conf /mydata/nginx

终止删除原容器

#停止容器
docker stop nginx
#删除容器
docker rm 容器id

创建新的 nginx

docker run -p 80:80 --name nginx \
-v /mydata/nginx/html:/usr/share/nginx/html \
-v /mydata/nginx/logs:/var/log/nginx \
-v /mydata/nginx/conf:/etc/nginx \
-d nginx:1.10

给 nginx 的 html 下面放的所有资源可以直接访问；

二、SpringClound Alibaba

1、Nacos[注册中心、配置中心]

Nacos 文档地址
下载 nacos-server
启动 nacos-server

双击 bin 中的 startup.cmd 文件

访问 http://localhost:8848/nacos/

使用默认的 nacos/nacos 进行登录
注册中心(A 服务调用 B 服务，A 服务并不知道 B 服务当前在哪几台服务器有，哪些正常的，哪些服务已经下线。解决这个问题可以引入注册中心)使用，配置配置文件，主启动类上加上@EnableDiscoveryClient即可
```
spring:
  cloud:
    nacos:
      discovery:
        #nacos 地址：端口
        server-addr: 127.0.0.1:8848
```

配置中心(每一个服务最终都有大量的配置，并且每个服务都可能部署在多台机器上。我们经常需要变更配置，我们可以让每个服务在配置中心获取自己的配置。)的使用，配置配置文件

# Nacos同springcloud-config一样，在项目初始化时，要保证先从配置中心进行配置拉取，拉取配置之后，才能保证项目的正常启动。springboot中配置文件的加载是存在优先级顺序的，bootstrap优先级高于application
server:
  port: 3377

spring:
  application:
    name: nacos-config-client
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #Nacos服务注册中心地址
      config:
        server-addr: localhost:8848 #Nacos作为配置中心地址
        file-extension: yaml #指定yaml格式的配置，文件后缀名，必须相同，不能是yml和yaml
        group: TEST_GROUP #指定分组,会读取namespace下分组为 DEV_GROUP 的 ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}文件，如果没有配置namespace，则读取的是public，下分组为 DEV_GROUP 的 ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}文件
        namespace: 4027cd05-15b8-4c4b-ab8c-2cab3d14df06 #指定命名空间，读取的就是该空间下的某个文件


# ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}
# nacos-config-client-dev.yaml
# nacos-config-client-test.yaml   ----> config.info

2、Gataway

2.1、简介

官方文档
网关作为流量的入口，常用功能包括路由转发、权限校验、限流控制等。而 springcloud gateway作为 SpringCloud 官方推出的第二代网关框架，取代了 Zuul 网关。

2.2、核心概念

路由。路由是网关最基础的部分，路由信息有一个 ID、一个目的 URL、一组断言和一组
Filter 组成。如果断言路由为真，则说明请求的 URL 和配置匹配.
断言。Java8 中的断言函数。Spring Cloud Gateway 中的断言函数输入类型是 Spring5.0 框
架中的 ServerWebExchange。Spring Cloud Gateway 中的断言函数允许开发者去定义匹配
来自于 http request 中的任何信息，比如请求头和参数等。
过滤器。一个标准的 Spring webFilter。Spring cloud gateway 中的 filter 分为两种类型的
Filter，分别是 Gateway Filter 和 Global Filter。过滤器 Filter 将会对请求和响应进行修改
处理
一句话：满足某些断言（predicates）就路由到指定的地址（uri），使用指定的过滤器（filter）

2.3、使用

创建网关项目，引入网关


   org.springframework.cloud
   spring-cloud-starter-gateway

编写网关配置文件

spring:
   cloud:
     gateway:
        routes: 
            - id: add_request_parameter_route
              uri: https://example.org
              predicates: - Query=baz
              filters: - AddRequestParameter=foo, bar

注意，各种 Predicates 同时存在于同一个路由时，请求必须同时满足所有的条件才被这个路
由匹配。一个请求满足多个路由的谓词条件时，请求只会被首个成功匹配的路由转发

2.4、配置统一的全局跨域

@Configuration
public class GulimallCorsConfiguration {

    @Bean
    public CorsWebFilter corsConfig(){
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration corsConfiguration = new CorsConfiguration();

        //允许所有请求头、请求方式都进行跨域处理
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.addAllowedOrigin("*");
        //允许携带cookie的请求
        corsConfiguration.setAllowCredentials(true);


        source.registerCorsConfiguration("/**",corsConfiguration);
        return new CorsWebFilter(source);
    }
}

2.5、Gataway配合Nginx进行请求转发

使用Nginx的反向代理，请求统一发送到Nginx中，由Nginx转发到网关(Gataway)，在由网关自己决定转发负载均衡到某个微服务。

Nginx配置文件配置

upstream gulimall{
	#转发至网关，有网关转发到指定的服务
	server 192.168.56.1:80;
}
server {
    listen       80;
    #多个域名映射同一个上游路径
    server_name gulimall.com search.gulimall.com item.gulimall.com auth.gulimall.com cart.gulimall.com order.gulimall.com member.gulimall.com 4448227kv1.imdo.co seckill.gulimall.com;

    #charset koi8-r;
    #access_log  /var/log/nginx/log/host.access.log  main;

    location /payed/ {
        #Nginx转发请求时会丢失头部信息，需要自己设置头部信息
        proxy_set_header Host order.gulimall.com;
        #proxy_pass http://192.168.56.1:10000;
        #路由到指定upstream上,需要在server块之上配置
        proxy_pass http://gulimall;
    }

    #static请求路径转发到Nginx的html目录下，实现动静分离
    location /static/{
	root   /usr/share/nginx/html;
    }

    location / {
	#Nginx转发请求时会丢失头部信息，需要自己设置头部信息
	proxy_set_header Host $host;
	#proxy_pass http://192.168.56.1:10000;
	#路由到指定upstream上,需要在server块之上配置
	proxy_pass http://gulimall;
    }

    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
    #
    #location ~ \.php$ {
    #    proxy_pass   http://127.0.0.1;
    #}

    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    #location ~ \.php$ {
    #    root           html;
    #    fastcgi_pass   127.0.0.1:9000;
    #    fastcgi_index  index.php;
    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
    #    include        fastcgi_params;
    #}

    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny  all;
    #}
}

网关配置（端口80）

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      routes:
        - id: gulimall-product
          uri: lb://gulimall-product
          predicates:
            - Path=/api/product/**,/testHello
          filters:
            - RewritePath=/api/?(?.*),/$\{segment}

        - id: gulimall-coupon
          uri: lb://gulimall-coupon
          predicates:
            - Path=/api/coupon/**,/testHello
          filters:
            - RewritePath=/api/?(?.*),/$\{segment}

        - id: gulimall-member
          uri: lb://gulimall-member
          predicates:
            - Path=/api/member/**
          filters:
            - RewritePath=/api/?(?.*),/$\{segment}

        - id: gulimall-ware
          uri: lb://gulimall-ware
          predicates:
            - Path=/api/ware/**
          filters:
            - RewritePath=/api/?(?.*),/$\{segment}

        - id: gulimall-third-party
          uri: lb://gulimall-third-party
          predicates:
            - Path=/api/thirdparty/**
          filters:
            - RewritePath=/api/thirdparty/?(?.*),/$\{segment}

        #path作用范围大的要写咋最后面
        - id: gulimall-admin
          uri: lb://renren-fast
          predicates:
            #断言，路径相匹配的进行路由
            - Path=/api/**
          filters:
            #重写路径  /api/..  重写成 /...
            # http://localhost:9900/api/renren-fast/list  会映射到 lb://renren-fast:端口号/api/renren-fast/list
            #但会出现404  原因是真实的访问地址是 http://localhost:8080/api/renren-fast/list 要是过滤器进行路由重写
            - RewritePath=/api/?(?.*),/renren-fast/$\{segment}


        #客户端发送请求->nginx转发到网关(会丢失头信息，需要在Nginx进行设置)->网关接收请求通过断言请求头信息，转发到对应服务
        - id: gulimall-product-host
          uri: lb://gulimall-product
          predicates:
            #断言请求头匹配，能够匹配上 gulimall.com的请求头的转发到对应服务
            - Host=gulimall.com,item.gulimall.com

        #客户端发送请求->nginx转发到网关(会丢失头信息，需要在Nginx进行设置)->网关接收请求通过断言请求头信息，转发到对应服务
        - id: gulimall-search-host
          uri: lb://gulimall-search
          predicates:
            #断言请求头匹配，能够匹配上 search.gulimall.com的请求头的转发到对应服务
            - Host=search.gulimall.com

        #客户端发送请求->nginx转发到网关(会丢失头信息，需要在Nginx进行设置)->网关接收请求通过断言请求头信息，转发到对应服务
        - id: gulimall-auth-server
          uri: lb://gulimall-auth-server
          predicates:
            #断言请求头匹配，能够匹配上 search.gulimall.com的请求头的转发到对应服务
            - Host=auth.gulimall.com

        #客户端发送请求->nginx转发到网关(会丢失头信息，需要在Nginx进行设置)->网关接收请求通过断言请求头信息，转发到对应服务
        - id: gulimall-cart
          uri: lb://gulimall-cart
          predicates:
            #断言请求头匹配，能够匹配上 search.gulimall.com的请求头的转发到对应服务
            - Host=cart.gulimall.com

        - id: gulimall-order
          uri: lb://gulimall-order
          predicates:
            - Host=order.gulimall.com

        - id: gulimall-member
          uri: lb://gulimall-member
          predicates:
            - Host=member.gulimall.com

        - id: gulimall-seckill
          uri: lb://gulimall-seckill
          predicates:
            - Host=seckill.gulimall.com

3、Feign 声明式远程调用

3.1、简介

Feign 是一个声明式的 HTTP 客户端，它的目的就是让远程调用更加简单。Feign 提供了 HTTP请求的模板，通过编写简单的接口和插入注解，就可以定义好 HTTP 请求的参数、格式、地址等信息。
Feign 整合了 Ribbon（负载均衡）和 Hystrix(服务熔断)，可以让我们不再需要显式地使用这两个组件。
SpringCloudFeign 在 NetflixFeign 的基础上扩展了对 SpringMVC 注解的支持，在其实现下，我们只需创建一个接口并用注解的方式来配置它，即可完成对服务提供方的接口绑定。简化了SpringCloudRibbon 自行封装服务调用客户端的开发量。

3.2、使用

引入依赖


      org.springframework.cloud
      spring-cloud-starter-openfeign

启动类开启 feign 功能

@EnableFeignClients(basePackages = "com.atguigu.gulimall.pms.feign")

声明远程接口

@FeignClient("gulimall-ware")//指定远程调用的服务名(spring:application:name)：gulimall-ware
public interface WareFeignService {
         @PostMapping("/ware/waresku/skus") //gulimall-ware服务的请求全路径
         public Resp> skuWareInfos(@RequestBody List skuIds);
}

原理

3.3、Feign远程调用丢失请求头问题

产生，远程查询购物车所有选中的购物项解决feign 远程调用解决请求头丢失问题(远程调用其他服务会创建一个新的请求,该请求没有携带任何cookie信息，另外一个服务不知道已经进行了登陆，改拦截后拦截后，设置携带cookie信息，到新的请求中，被远程调用的服务就知道那个用户进行了登陆，能获取到登陆信息)

解决：添加一个feign的拦截器

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * @Description: feign拦截器功能 解决feign 远程调用解决请求头丢失问题(远程调用其他服务会创建一个新的请求,该请求没有携带任何cookie信息，另外一个服务不知道已经进行了登陆，改拦截后拦截后，设置携带cookie信息，到新的请求中，被远程调用的服务就知道那个用户进行了登陆，能获取到登陆信息)
 **/

@Configuration
public class GuliFeignConfig {

    @Bean("requestInterceptor")
    public RequestInterceptor requestInterceptor() {

        RequestInterceptor requestInterceptor = new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate template) {
                //1、使用RequestContextHolder拿到刚进来的请求数据
                ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

                if (requestAttributes != null) {
                    //老请求
                    HttpServletRequest request = requestAttributes.getRequest();

                    if (request != null) {
                        //2、同步请求头的数据（主要是cookie）
                        //把老请求的cookie值放到新请求上来，进行一个同步
                        String cookie = request.getHeader("Cookie");
                        template.header("Cookie", cookie);
                    }
                }
            }
        };

        return requestInterceptor;
    }

}

3.4、Feign异步情况丢失上下文问题

产生(每一个线程都来共享之前的请求数据 Feign异步情况丢失上下文问题异步执行后，不同的线程，获取的上下文不同所以设置为统一的上下文)

解决(设置为统一的上下文)

//TODO :获取当前线程请求头信息(解决Feign异步调用丢失请求头问题)
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

        //开启第一个异步任务
        CompletableFuture addressFuture = CompletableFuture.runAsync(() -> {

            //每一个线程都来共享之前的请求数据 Feign异步情况丢失上下文问题 异步执行后，不同的线程，获取的上下文不同 所以设置为统一的上下文
            RequestContextHolder.setRequestAttributes(requestAttributes);

            //1、远程查询所有的收获地址列表
            List address = memberFeignService.getAddress(memberResponseVo.getId());
            confirmVo.setMemberAddressVos(address);
        }, threadPoolExecutor);

        //开启第二个异步任务
        CompletableFuture cartInfoFuture = CompletableFuture.runAsync(() -> {

            //RequestContextHolder上下文 底层是ThreadLocal共享数据 每一个线程都来共享之前的请求数据 Feign异步情况丢失上下文问题 异步执行后，不同的线程，获取的上下文不同 所以设置为统一的上下文
            RequestContextHolder.setRequestAttributes(requestAttributes);

            //2、远程查询购物车所有选中的购物项 解决feign 远程调用解决请求头丢失问题(远程调用其他服务会创建一个新的请求,该请求没有携带任何cookie信息，另外一个服务不知道已经进行了登陆，改拦截后拦截后，设置携带cookie信息，到新的请求中，被远程调用的服务就知道那个用户进行了登陆，能获取到登陆信息)  具体代码见：GuliFeignConfig
            List currentCartItems = cartFeignService.getCurrentCartItems();
            confirmVo.setItems(currentCartItems);
            //feign在远程调用之前要构造请求，调用很多的拦截器
        }, threadPoolExecutor).thenRunAsync(() -> {
            List items = confirmVo.getItems();
            //获取全部商品的id
            List skuIds = items.stream()
                    .map((itemVo -> itemVo.getSkuId()))
                    .collect(Collectors.toList());

            //远程查询商品库存信息
            R skuHasStock = wmsFeignService.getSkuHasStock(skuIds);
            List skuStockVos = skuHasStock.getData("data", new TypeReference>() {});

            if (skuStockVos != null && skuStockVos.size() > 0) {
                //将skuStockVos集合转换为map
                Map skuHasStockMap = skuStockVos.stream().collect(Collectors.toMap(SkuStockVo::getSkuId, SkuStockVo::getHasStock));
                confirmVo.setStocks(skuHasStockMap);
            }
        },threadPoolExecutor);

三、Java生态知识点

1、JSR303 数据校验

用于前端传递参数，后端进行数据校验，自定义校验规则等。

普通的校验用法

实体类(Bean)标记：javax.validation.constraints包下的注解，并定义自己的message提示。

public class BrandEntity implements Serializable {
	private static final long serialVersionUID = 1L;
	/**
	 * 品牌名
     * 给Bean添加校验注解:javax.validation.constraints包下的，并定义自己的message提示
	 */
	@NotBlank(message = "品牌名不能为空")
	private String name;
	/**
	 * 品牌logo地址
	 */
	@NotEmpty
	@URL(message = "品牌logo必须是一个URL")
	private String logo;

	/**
	 * 显示状态[0-不显示；1-显示]
	 */
	@NotNull(message = "显示状态不能为空")
	private Integer showStatus;
	/**
	 * 检索首字母
	 */
	@NotEmpty
	@Pattern(regexp = "^[a-zA-Z]$",message = "首字母必须是a-z或者A-Z")
	private String firstLetter;
	/**
	 * 排序
	 */
	@NotNull
	@Min(value = 0,message = "排序必须是大于等于0的数字")
	private Integer sort;

}

开启校验功能@Valid。效果：校验错误以后会有默认的响应；

/**
  * bindingResult 绑定了不合校验规则的参数
  * 给校验的bean后紧跟一个BindingResult，就可以获取到校验的结果
  */
@RequestMapping("/save")
public R save(@Valid() @RequestBody BrandEntity brand, BindingResult bindingResult){
	if (bindingResult.hasErrors()){
		List allErrors = bindingResult.getAllErrors();
		Map map = new HashMap<>();
		allErrors.forEach(item -> {
			map.put(item.getObjectName(),item.getDefaultMessage());
		});
		return R.error(400,"参数不合法").put("data",map);
	}else {
		brandService.save(brand);
		return R.ok();
	}
	  brandService.save(brand);
		return R.ok();
}

分组校验（多场景的复杂校验）

分组接口标识

/**
 * 字段验证分组，更细分组
 * @author pengjun
 */
public interface UpdateValidGroup {
}


/**
 * 字段验证分组，保存分组
 * @author pengjun
 */
public interface SaveValidGroup {
}



/**
 * 字段验证分组，更细分组
 * @author pengjun
 */
public interface UpdateStatusValidGroup {
}

实体类

public class BrandEntity implements Serializable {
		/**
	 * 品牌id
	 */
	@NotNull(message = "更新时，需要传递品牌id",groups = {UpdateValidGroup.class}) //更新时，需要传递品牌id
	@Null(message = "保存时无需传递品牌id",groups = {SaveValidGroup.class}) //指定分组，在保存分组时，无需传递品牌id
	@TableId
	private Long brandId;
	/**
	 * 品牌名
	 */
	@NotBlank(message = "品牌名不能为空",groups = {UpdateValidGroup.class, SaveValidGroup.class}) //指定分组，在保存更新时，都需要需传递品牌名称
	private String name;
	/**
	 * 品牌logo地址
	 */
	@NotEmpty
	@URL(message = "品牌logo必须是一个URL",groups = {UpdateValidGroup.class, SaveValidGroup.class})//指定分组，在保存更新时，都需要符合URL
	private String logo;
	/**
	 * 介绍
	 */
	private String descript;
	/**
	 * 显示状态[0-不显示；1-显示]
	 */
	@NotNull(message = "显示状态不能为空",groups = {SaveValidGroup.class, UpdateStatusValidGroup.class})
	private Integer showStatus;
	/**
	 * 检索首字母
	 */
	@NotEmpty //未指定分组的，在指定了 @Validated(value = {SaveValid.class}) 指定分组验证时，不会进行验证
	@Pattern(regexp = "^[a-zA-Z]$",message = "首字母必须是a-z或者A-Z",groups = {SaveValidGroup.class})
	private String firstLetter;
	/**
	 * 排序
	 */
	@NotNull
	@Min(value = 0,message = "排序必须是大于等于0的数字")
	private Integer sort;

}

开启 @Validated(value = {}) (@Valid()无法应用于分组)


//指定不同的分组标识 会验证不同的规则
@RequestMapping("/save")
public R save(/*@Valid(无法应用于分组)*/@Validated(value = {SaveValidGroup.class})/*指定分组时验证,如果字段验证未指定分组，验证不生效*/ @RequestBody BrandEntity brand, BindingResult bindingResult){
	if (bindingResult.hasErrors()){
		List allErrors = bindingResult.getAllErrors();
		Map map = new HashMap<>();
		allErrors.forEach(item -> {
			map.put(item.getObjectName(),item.getDefaultMessage());
		});
		return R.error(400,"参数不合法").put("data",map);
	}else {
		brandService.save(brand);
		return R.ok();
	}
	  brandService.save(brand);
		return R.ok();
}



//指定不同的分组标识 会验证不同的规则
@RequestMapping("/update")
public R update(@Validated(value = {UpdateValidGroup.class, UpdateStatusValidGroup.class}) @RequestBody BrandEntity brand){......}

自定义检验拦截器

导入依赖


	javax.validation
	validation-api
	2.0.1.Final

编写一个自定义的校验注解
ValidationMessages.properties

com.pj.common.valid.ListValue.message=必须提交指定的值

@Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(
        validatedBy = {ListValueConstraintValidator.class} //指定校验拦截器，可以指定多个，不同类型的属性，都可以指定不同的拦截器，如果没有配置，则需要在初始化的时候进行校验拦截
)
public @interface ListValue {
    String message() default "{com.pj.common.valid.ListValue.message}"; //指定默认提示信息，需要配置一个ValidationMessages.properties配置文件

    Class[] groups() default {}; //分组

    Class[] payload() default {};

    int[] vals() default {};
}

编写一个自定义的校验器 ConstraintValidator

/**
 * 自定义检验拦截器
 * @author pengjun
 */
public class ListValueConstraintValidator implements ConstraintValidator{
    private Set set = new HashSet<>();
    @Override
    public void initialize(ListValue constraintAnnotation) {
        //拿到指定的值，放入set集合中
        int[] vals = constraintAnnotation.vals();
        for (int val : vals) {
            set.add(val);
        }
    }

    /**
     * 进行拦截校验
     * @param integer 属性的传入过来的值
     * @param constraintValidatorContext
     * @return
     */
    @Override
    public boolean isValid(Integer integer, ConstraintValidatorContext constraintValidatorContext) {
        return set.contains(integer);
    }
}

关联自定义的校验器和自定义的校验注解()

//@Constraint(validatedBy = {ListValueConstraintValidator.class} //指定校验拦截器，可以指定多个，不同类型的属性，都可以指定不同的拦截器，如果没有配置，则需要在初始化的时候进行校验拦截)

@Data
public class BrandEntity implements Serializable {
	/**
	 * 显示状态[0-不显示；1-显示]
	 */
	@NotNull(message = "显示状态不能为空",groups = {SaveValidGroup.class, UpdateStatusValidGroup.class})
	@ListValue(vals = {0,1},message = "显示状态只能为0和1",groups = {SaveValidGroup.class, UpdateStatusValidGroup.class})
	private Integer showStatus;

}

2、统一异常处理

用于服务器全局异常处理,统一返回异常提示信息。

/**
 * 公共处理异常类
 *
 * @author 
 */
//@ControllerAdvice
//@ResponseBody
@Slf4j
@RestControllerAdvice //ControllerAdvice 和 ResponseBody的合体
public class GulimallExceptionAdvice {

    //指定拦截的异常类，子类也会将被拦截
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    public R handlerVException(MethodArgumentNotValidException exception) {
        BindingResult bindingResult = exception.getBindingResult();
        List fieldErrors = bindingResult.getFieldErrors();
        Map map = new HashMap<>();
        fieldErrors.forEach(item -> map.put(item.getField(), item.getDefaultMessage()));
        return R.error(BizCodeEnum.VALID_EXCEPTION.getCode(), BizCodeEnum.VALID_EXCEPTION.getMsg()).put("data", map);
    }

    @ExceptionHandler(value = Throwable.class)
    public R handlerException(Throwable throwable) {
        log.error("错误:",throwable);
        return R.error(BizCodeEnum.UNKNOW_EXCEPTION.getCode(), BizCodeEnum.UNKNOW_EXCEPTION.getMsg());
    }
}

3、ES

Elasticsearch官网地址

开发中文文档

3.1、基本概念：

Index（索引）
相当于 MySQL 中的 Database
Type（类型）
在 Index （索引）中，可以定义一个或多个类型。

类似于 MySQL 中的 Table ；每一种类型的数据放在一起
Document（文档）
保存在某个索引（Index）下，某种类型（Type ）的一个数据（ Document ），文档是 JSON格式的， Document 就像是 MySQL 中的某个 Table 里面的内容；
关系图如下：
倒排索引机制

3.2、分词(IK分词器安装)

es会安装默认的分词规则，给不同的数据进行分词整合。如若不满足分词的结果，需自行配置分词器。

安装 ik 分词器
IK分词器对应es版本

下载对应版本后，上传至虚拟机的 plugins目录下(也可以直接下载)，解压(如果没有保存没有命令，请自行下载)。
```
wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.4.2/elasticsearch-analysis-ik-7.4.2.zip
```

进入容器内部，查看是否安装完成

#进入 es 容器内部 plugins 目录
docker exec -it 容器 id /bin/bash
#进入 /usr/share/elasticesearch/bin 目录，列出系统的分词器
elasticsearch-plugin list

测试分词器(在Kibana 中发送请求测试)

#使用默认
POST _analyze
{ 
    "text": "我是中国人"
}

#使用分词器
POST _analyze
{ 
    "analyzer": "ik_smart", 
    "text": "我是中国人"
}


POST _analyze
{ 
    "analyzer": "ik_max_word", 
    "text": "我是中国人"
}

自定义分词内容(Nginx转发)
- 按照"http://虚拟机ip/es/fenci.txe"，利用 Nginx发布静态资源,按照请求路径，创建对应的文件夹以及文件，放在 Nginx的 html 下，重启Nginx。
```
mkdir es
vi fenci.txt
中国
中国人
```
- 配置ik分词器配置
```
#修改/usr/share/elasticsearch/plugins/ik/config/中的 IKAnalyzer.cfg.xml
cd /usr/share/elasticsearch/plugins/ik/config 
vi IKAnalyzer.cfg.xml



IK Analyzer 扩展配置





http://192.168.56.10/es/fenci.txt
```
- 配置完成后，重启es，在进行测试。

3.3、整合SpringBoot(Elasticsearch-Rest-Client)

Elasticsearch-Rest-Client ：官方 RestClient ，封装了 ES 操作， API 层次分明，上手简单。官方文档

导入依赖


    org.elasticsearch.client
    elasticsearch-rest-high-level-client
    
    7.17.10

配置ES信息

@Configuration
public class ElasticSearchConfig {

    //RequestOptions类包含请求的部分，这些部分应该在同一应用程序中的多个请求之间共享。您可以创建一个singleton实例，并在所有请求之间共享它
    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
        //权限设置
        // builder.addHeader("Authorization", "Bearer " + TOKEN);
        // builder.setHttpAsyncResponseConsumerFactory(
        //         new HttpAsyncResponseConsumerFactory
        //                 .HeapBufferedResponseConsumerFactory(30 * 1024 * 1024 * 1024));
        COMMON_OPTIONS = builder.build();
    }

    /**
     * 配置连接es客户端
     * @return
     */
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestClientBuilder builder = RestClient.
                builder(new HttpHost("192.168.56.10",9200,"http"));
//                ,new HttpHost("192.168.56.10",9200,"http")); 如果有集群可以配置多个
        RestHighLevelClient client =  new RestHighLevelClient(builder);
        return client;
    }
}

代码操作ES(API文档)

保存和更新文档

    /**
     * 保存和更新 文档
     * 具体API文档地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-document-index.html
     */
    @Test
    public void saveEsIndex() throws IOException {
        //指定索引(库名) 也可以指定 type(表，弃用了) 和 文档id(一行行数据的id)
        IndexRequest indexRequest = new IndexRequest("users");
        indexRequest.id("1");

        //构造存储的数据
        //indexRequest.source("name","zhangsan","age",16,"gender","F");

        //构造成map进行存储
//        Map map = new HashMap<>();
//        map.put("name","zs");
//        map.put("age",15);
//        map.put("gender","F");
//        indexRequest.source(map);

        //构造成对象转为json后进行存储
        User user = new User();
        user.setName("张三");
        user.setAge(18);
        user.setGender("男");
        String s = JSON.toJSONString(user);
        //指定存储类型 为JSON 不指定会报错
        indexRequest.source(s, XContentType.JSON);
        //设置请求超时时间，还可以设置其他的，自己从官网查看
        indexRequest .timeout(TimeValue.timeValueSeconds(1));
        //发送请求个es存储数据
        IndexResponse index = restHighLevelClient.index(indexRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        System.out.println(index);
    }


    @Data
    class User {
        private String name;
        private Integer age;
        private String gender;
    }

检索数据(API文档)

    /**
     * #查出所有年龄分布，并且这些年龄段中 M 的平均薪资和 F 的平均薪资以及这个年龄段的总体平均薪资
     */
    @Test
    public void searchIndex() throws IOException {
        //1. 创建检索请求
        SearchRequest searchRequest = new SearchRequest();

        //1.1）指定索引
        searchRequest.indices("bank");

        //1.2）构造检索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//        QueryBuilders.matchAllQuery(); 查询所有
//        sourceBuilder.query(QueryBuilders.matchQuery("address", "Mill"));
        sourceBuilder.query(QueryBuilders.matchAllQuery());

        //1.2.1)按照年龄分布进行聚合
        TermsAggregationBuilder ageAgg = AggregationBuilders.terms("ageAgg").field("age").size(10);

        //在ageAgg分组下构建子聚合 求这个年龄段内的男女情况
        TermsAggregationBuilder genderAgg = AggregationBuilders.terms("genderAgg").field("gender.keyword");
        ageAgg.subAggregation(genderAgg);

        //在ageAgg分组下构建子聚合  求这个年龄段的平均工资
        AvgAggregationBuilder balanceAvg2 = AggregationBuilders.avg("balanceAvg2").field("balance");
        ageAgg.subAggregation(balanceAvg2);

        sourceBuilder.aggregation(ageAgg);


//        构造builder
     /*
     //构造多个聚合
     sourceBuilder
                .aggregation(AggregationBuilders
                        .composite("buckets", Arrays.asList(
                                new TermsValuesSourceBuilder("genderAgg").field("gender.keyword"),
                                new TermsValuesSourceBuilder("balanceAvg2").field("balance"))));*/
/*
        TermsAggregationBuilder genderAgg = AggregationBuilders.terms("genderAgg").field("gender.keyword");
        aggregation.aggregation(genderAgg);

        AvgAggregationBuilder balanceAvg2 = AggregationBuilders.avg("balanceAvg2");
        aggregation.aggregation(balanceAvg2);
*/


        //1.2.2)计算查询的数据平均年龄
        AvgAggregationBuilder ageAvg = AggregationBuilders.avg("ageAvg").field("age");
        sourceBuilder.aggregation(ageAvg);

        //1.2.3)计算查询的数据的平均薪资
        AvgAggregationBuilder balanceAvg = AggregationBuilders.avg("balanceAvg").field("balance");
        sourceBuilder.aggregation(balanceAvg);

        System.out.println("检索条件：" + sourceBuilder);
        searchRequest.source(sourceBuilder);

        //检索结果
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        System.out.println("检索结果：" + searchResponse);

        //获取最外层查询结果，包括查询的数据，查询的索引、类型、命中率等
        SearchHits hits = searchResponse.getHits();
        //获取查询数据
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit searchHit : searchHits) {
            //获取到每一条查询的数据，输出为json串
            String sourceAsString = searchHit.getSourceAsString();
            //json串转为对象
            Account account = JSON.parseObject(sourceAsString, Account.class);
            System.out.println(account);
        }

        //4. 获取聚合信息
        Aggregations aggregations = searchResponse.getAggregations();

        //获取聚合名称为：ageAgg 的聚合结果
        Terms ageAgg1 = aggregations.get("ageAgg");
        //遍历聚合结果，获取每个年龄段下的的人数
        for (Terms.Bucket bucket : ageAgg1.getBuckets()) {
            String keyAsString = bucket.getKeyAsString();
            System.out.println("年龄：" + keyAsString + " ==> " + bucket.getDocCount());

            //获取子聚合的值
            Aggregations aggregations2 = bucket.getAggregations();
            Terms genderAgg2 = aggregations2.get("genderAgg");
            for (Terms.Bucket genderBucket : genderAgg2.getBuckets()) {
                long docCount = genderBucket.getDocCount();
                System.out.println(keyAsString + "该年龄的性别为：" + genderBucket.getKeyAsString() + "的人数为：" + docCount);
            }
            //获取子聚合的值
            Avg balanceAvgAggregation = aggregations2.get("balanceAvg2");
            System.out.println(keyAsString +"改年龄的平均工资：" + balanceAvgAggregation.getValue());
        }
        //获取所有人的平均年龄
        Avg ageAvg1 = aggregations.get("ageAvg");
        System.out.println("平均年龄：" + ageAvg1.getValue());

        //获取所有人的平均工资
        Avg balanceAvg1 = aggregations.get("balanceAvg");
        System.out.println("平均薪资：" + balanceAvg1.getValue());
    }

Es-数组的扁平化处理(nested嵌入式解决文档链接 )

//插入数据
PUT my-index-000001/_doc/1
{
  "group" : "fans",
  "user" : [ 
    {
      "first" : "John",
      "last" :  "Smith"
    },
    {
      "first" : "Alice",
      "last" :  "White"
    }
  ]
}


//检索数据
GET my-index-000001/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "user.first": "Alice" }},
        { "match": { "user.last":  "Smith" }}
      ]
    }
  }
}

//删除索引
DELETE my-index-000001

//设置索引映射 嵌入式处理
PUT my-index-000001
{
  "mappings": {
    "properties": {
      "user": {
        "type": "nested" 
      }
    }
  }
}

//插入数据
PUT my-index-000001/_doc/1
{
  "group" : "fans",
  "user" : [
    {
      "first" : "John",
      "last" :  "Smith"
    },
    {
      "first" : "Alice",
      "last" :  "White"
    }
  ]
}

//重新检索
GET my-index-000001/_search
{
  "query": {
    "nested": {
      "path": "user",
      "query": {
        "bool": {
          "must": [
            { "match": { "user.first": "Alice" }},
            { "match": { "user.last":  "Smith" }} 
          ]
        }
      }
    }
  }
}


//获取索引类型映射
GET my-index-000001/_mapping

3.4、商城商品检索代码(可当做参考案例)

#ES 检索dtl
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "skuTitle": "HUAWEI"
          }
        }
      ],
      "filter": [
        {
          "term": {
            "catalogId": "225"
          }
        },
        {
          "terms": {
            "brandId": [
              "9",
              "12"
            ]
          }
        },
        {
          "nested": {
            "path": "attrs",
            "query": {
              "terms": {
                "attrs.attrId": [
                  "15",
                  "16"
                ]
              }
            }
          }
        },
        {
          "nested": {
            "path": "attrs",
            "query": {
              "terms": {
                "attrs.attrValue": [
                  "骁龙855"
                ]
              }
            }
          }
        },
        {
          "term": {
            "hasStock": "true"
          }
        },
        {
          "range": {
            "skuPrice": {
              "gte": 0,
              "lte": 5000
            }
          }
        }
      ]
    }
  },
  "sort": [
    {
      "skuPrice": {
        "order": "desc"
      }
    }
  ],
  "from": 0,
  "size": 1,
  "highlight": {
    "fields": {
      "skuTitle": {}
    },
    "pre_tags": "",
    "post_tags": ""
  },
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brandId",
        "size": 100
      },
      "aggs": {
        "brand_name_agg": {
          "terms": {
            "field": "brandName",
            "size": 10
          }
        },
        "brand_image_agg": {
          "terms": {
            "field": "brandImg",
            "size": 10
          }
        }
      }
    },
    "catalog_agg": {
      "terms": {
        "field": "catalogId",
        "size": 10
      },
      "aggs": {
        "catalog_name_agg": {
          "terms": {
            "field": "catalogName",
            "size": 10
          }
        }
      }
    },
    "attr_agg": {
      "nested": {
        "path": "attrs"
      },
      "aggs": {
        "attr_id_agg": {
          "terms": {
            "field": "attrs.attrId",
            "size": 10
          },
          "aggs": {
            "attr_name_agg": {
              "terms": {
                "field": "attrs.attrName",
                "size": 10
              }
            },
            "attr_value_agg": {
              "terms": {
                "field": "attrs.attrValue",
                "size": 10
              }
            }
          }
        }
      }
    }
  }
}


/**=====================================================
 * 商品检索服务dto
 * 排序的条件：?keyword="abc"&catalog3Id=123&sort=skuPrice_desc&hasStock=0&skuPrice=1_500&brandId=1&brandId=2&attrs=1_5寸&attrs=2_8GB&pageNum=5
 *                                         sort=skuPrice_asc 按照价格排序
 *                                         sort=saleCount_desc 按照销量排序
 *                                         sort=saleCount_asc
 *                                         sort=hasScore_desc 按照热度分排序
 *                                         sort=hasScore_asc
 * @author pengjun
 */
@Data
public class SearchProductDto {
    /**
     * 标题查找
     */
    private String keyword;
    /**
     * 三级分类id查找
     */
    private Long catalog3Id;
    /**
     * 排序规则
     */
    private String sort;
    /**
     * 是否只显示有库存的 0无 1有
     */
    private Integer hasStock;
    /**
     * 价格区间 skuPrice=1_500/_500/500_
     *        1_500:1-500之间的价格
     *        _500:小于500的价格
     *        500_:大于500的价格
     */
    private String skuPrice;
    /**
     * 品牌。可以选择多个品牌 &brandId=1&brandId=2
     */
    private List brandId;
    /**
     * 多个属性 id_属性值  如 &attrs=1_5寸:8寸&attrs=2_8GB:16G
     *                     属性id为1的，5寸、8寸的商品
     *                     属性id为2的，8G和16G的商品
     */
    private List attrs;
    /**
     * 页码
     */
    private Integer pageNum = 1;
    /**
     * 请求参数
     */
    private String uri;
}


    //=================检索代码=========
    @Autowired
    private RestHighLevelClient restHighLevelClient;
    /**
     *
     * @param searchProductDto
     * @return
     */
    @Override
    public SearchResult searchProduct(SearchProductDto searchProductDto) {
        SearchRequest searchRequest = builderSearchCondition(searchProductDto);
        SearchResponse search;
        SearchResult searchResult = null;
        try {
            search = restHighLevelClient.search(searchRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
            searchResult = builderSearchResult(search, searchProductDto);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return searchResult;
    }


    /**
     * 构造检索条件 模糊匹配，过滤（按照属性、分类、品牌，价格区间，库存），完成排序、分页、高亮,聚合分析功能
     *
     * @param searchProductDto
     * @return
     */
    private SearchRequest builderSearchCondition(SearchProductDto searchProductDto) {

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //1. 构建bool-query
        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
        //1.1 bool-must 根据副标题，模糊匹配
        String keyword = searchProductDto.getKeyword();
        if (StringUtils.isNotBlank(keyword)) {
            boolQueryBuilder.must(QueryBuilders.matchQuery("skuTitle", keyword));
        }

        //1.2 bool-fiter
        //1.2.1 catelogId 根据分类id检索
        Long catalog3Id = searchProductDto.getCatalog3Id();
        if (catalog3Id != null) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("catalogId", catalog3Id));
        }

        //1.2.2 brandId 根据品牌id查找
        List brandId = searchProductDto.getBrandId();
        if (brandId != null && !brandId.isEmpty()) {
            boolQueryBuilder.filter(QueryBuilders.termsQuery("brandId", brandId));
        }

        //1.2.3 attrs
        //attrs=1_5寸:8寸&2_16G:8G
        List attrs = searchProductDto.getAttrs();
        if (attrs != null && !attrs.isEmpty()) {
            for (String attr : attrs) {
                BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
                String[] s = attr.split("_");
                //分类id
                String attrId = s[0];
                //这个属性检索用的值
                String[] attrValues = s[1].split(":");
                //一个分类id有多个对应不同的值
                boolQuery.must(QueryBuilders.termQuery("attrs.attrId", attrId));
                boolQuery.must(QueryBuilders.termsQuery("attrs.attrValue", attrValues));
                //构建扁平化处理的查询条件数据
                boolQueryBuilder.filter(QueryBuilders.nestedQuery("attrs", boolQuery, ScoreMode.None));
            }
        }
        Integer hasStock = searchProductDto.getHasStock();
        if (hasStock != null) {
            //1.2.4 hasStock
            boolQueryBuilder.filter(QueryBuilders.termQuery("hasStock", searchProductDto.getHasStock() == 1));
        }


        //1.2.5 skuPrice
        //skuPrice形式为：1_500或_500或500_
        String skuPrice = searchProductDto.getSkuPrice();
        if (StringUtils.isNotBlank(skuPrice)) {
            String[] s = skuPrice.split("_");
            //1_500
            if (s.length == 2) {
                String startPrice = s[0];
                String endPrice = s[1];
                boolQueryBuilder.filter(QueryBuilders.rangeQuery("skuPrice").gte(startPrice).lte(endPrice));
            } else if (s.length == 1) {
                String price = s[0];
                //_500
                if (skuPrice.startsWith("_")) {
                    boolQueryBuilder.filter(QueryBuilders.rangeQuery("skuPrice").lte(price));
                } else if (skuPrice.endsWith("_")) {
                    //500_
                    boolQueryBuilder.filter(QueryBuilders.rangeQuery("skuPrice").gte(price));
                }
            }
        }

        //封装所有的查询条件
        searchSourceBuilder.query(boolQueryBuilder);

        //构造分页
        /**
         * 从第几条开始：(页码 - 1 * size)
         *  第一页 5 条数据 0,1,2,3,4
         *  第二页 5 条数据 5,6,7,8,9
         */
        searchSourceBuilder.from((searchProductDto.getPageNum() - 1) * ElasticSearchIndex.PRODUCT_PAGESIZE);
        searchSourceBuilder.size(ElasticSearchIndex.PRODUCT_PAGESIZE);

        //构造高亮
        if (StringUtils.isNotBlank(keyword)) {
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.field("skuTitle");
            highlightBuilder.preTags("");
            highlightBuilder.postTags("");
            searchSourceBuilder.highlighter(highlightBuilder);
        }

        //排序  形式为sort=hotScore_asc/desc
        String sort = searchProductDto.getSort();
        if (StringUtils.isNotBlank(sort)) {
            String[] s = sort.split("_");
            SortOrder sortOrder = s[1].equalsIgnoreCase("asc") ? SortOrder.ASC : SortOrder.DESC;
            searchSourceBuilder.sort(s[0], sortOrder);
        }
        /**
         * 聚合分析
         */
        //1. 按照品牌进行聚合
        TermsAggregationBuilder brand_agg = AggregationBuilders.terms("brand_agg").field("brandId");
        //1.1 品牌的子聚合- 按照品牌id聚合后，在按照品牌名字聚合，一个id对应一个名称
        TermsAggregationBuilder brand_name_agg = AggregationBuilders.terms("brand_name_agg").field("brandName").size(1);
        brand_agg.subAggregation(brand_name_agg);
        //1.2 品牌的子聚合- 按照品牌id聚合后，在按照品牌图片聚合，一个id对应一个图片
        TermsAggregationBuilder brand_image_agg = AggregationBuilders.terms("brand_image_agg").field("brandImg").size(1);
        brand_agg.subAggregation(brand_image_agg);
        searchSourceBuilder.aggregation(brand_agg);

        //2. 按照分类信息进行聚合
        TermsAggregationBuilder catalog_agg = AggregationBuilders.terms("catalog_agg").field("catalogId").size(20);
        //2.1 分类信息子聚合-按照分类名称聚合，一个id对应一个分类名称
        TermsAggregationBuilder catalog_name_agg = AggregationBuilders.terms("catalog_name_agg").field("catalogName").size(1);
        catalog_agg.subAggregation(catalog_name_agg);
        searchSourceBuilder.aggregation(catalog_agg);

        //3. 按照属性信息进行聚合
        //3.1 进行数据扁平化处理
        NestedAggregationBuilder attr_agg = AggregationBuilders.nested("attr_agg", "attrs");
        //3.2 在扁平化处理之后，在对属性id进行聚合
        TermsAggregationBuilder attr_id_agg = AggregationBuilders.terms("attr_id_agg").field("attrs.attrId").size(50);
        //3.3 在id聚合下 按照名字聚合，一个id对应一个属性名
        TermsAggregationBuilder attr_name_agg = AggregationBuilders.terms("attr_name_agg").field("attrs.attrName").size(1);
        attr_id_agg.subAggregation(attr_name_agg);
        //3.3 在id聚合下 按照属性值聚合，一个id对应多个属性名
        TermsAggregationBuilder attr_value_agg = AggregationBuilders.terms("attr_value_agg").field("attrs.attrValue").size(50);
        attr_id_agg.subAggregation(attr_value_agg);

        attr_agg.subAggregation(attr_id_agg);
        searchSourceBuilder.aggregation(attr_agg);

        System.out.println(searchSourceBuilder.toString());

        SearchRequest searchRequest = new SearchRequest(new String[]{ElasticSearchIndex.PRODUCT_INDEX}, searchSourceBuilder);
        return searchRequest;
    }


    //=================检索数据解析=========
    /**
     * 构建检索之后的数据封装成的对应的数据返回
     * @param search
     * @param searchProductDto
     * @return
     */
    private SearchResult builderSearchResult(SearchResponse search, SearchProductDto searchProductDto) {
        SearchResult searchResult = new SearchResult();
        SearchHits hits = search.getHits();
        List skuEsModels = new ArrayList<>();
        //1、返回的所有查询到的商品
        SearchHit[] datas = hits.getHits();
        if (datas != null && datas.length > 0) {
            for (SearchHit data : datas) {
                //存储的时候就是按照 SkuEsModel 对象存储，可直接转化为对象
                String sourceAsString = data.getSourceAsString();
                SkuEsModel skuEsModel = JSON.parseObject(sourceAsString, SkuEsModel.class);
                //带上keyword才有高亮
                if (StringUtils.isNotBlank(searchProductDto.getKeyword())) {
                    //获取高亮数据
                    Map highlightFields = data.getHighlightFields();
                    if (highlightFields != null && highlightFields.size() > 0) {
                        //获取高亮 skuTitle
                        HighlightField skuTitle = highlightFields.get("skuTitle");
                        //获取高亮之后的结果
                        String highlightSkuTitle = skuTitle.getFragments()[0].string();
                        skuEsModel.setSkuTitle(highlightSkuTitle);
                    }
                }
                skuEsModels.add(skuEsModel);
            }
        }
        searchResult.setProduct(skuEsModels);
        //获取聚合信息
        Aggregations aggregations = search.getAggregations();
        //2、当前商品涉及到的所有属性信息
        List attrVos = new ArrayList<>();
        ParsedNested attr_agg = aggregations.get("attr_agg");
        //获取扁平化处理的聚合信息下的 通过属性id聚合的结果
        ParsedLongTerms attr_id_agg = attr_agg.getAggregations().get("attr_id_agg");
        //遍历通过属性id聚合的结果
        for (Terms.Bucket bucket : attr_id_agg.getBuckets()) {
            SearchResult.AttrVo attrVo = new SearchResult.AttrVo();
            //1、得到属性的id
            long attrId = bucket.getKeyAsNumber().longValue();
            attrVo.setAttrId(attrId);

            //2、获取通过属性id聚合下的通过属性名字聚合的结果，一个id只会对应一个名称，可以直接.get(0) 得到属性的名字
            ParsedStringTerms attr_name_agg = bucket.getAggregations().get("attr_name_agg");
            String attrName = attr_name_agg.getBuckets().get(0).getKeyAsString();
            attrVo.setAttrName(attrName);

            //3、获取通过属性id聚合下的通过属性值聚合的结果，一个id只会对应多个属性值，提取所有的属性值 得到属性的所有值
            ParsedStringTerms attr_value_agg = bucket.getAggregations().get("attr_value_agg");
            List attrValues = attr_value_agg.getBuckets().stream().map(item -> item.getKeyAsString()).collect(Collectors.toList());
            attrVo.setAttrValue(attrValues);

            attrVos.add(attrVo);
        }
        searchResult.setAttrs(attrVos);

        List brandVos = new ArrayList<>();
        //3、当前商品涉及到的所有品牌信息
        //获取品牌的聚合，遍历聚合信息
        ParsedLongTerms brand_agg = aggregations.get("brand_agg");
        for (Terms.Bucket bucket : brand_agg.getBuckets()) {
            SearchResult.BrandVo brandVo = new SearchResult.BrandVo();
            //获取品牌的id
            long brandId = bucket.getKeyAsNumber().longValue();
            brandVo.setBrandId(brandId);

            //获取品牌id聚合下的子聚合，品牌名称
            ParsedStringTerms brand_name_agg = bucket.getAggregations().get("brand_name_agg");
            String brandName = brand_name_agg.getBuckets().get(0).getKeyAsString();
            brandVo.setBrandName(brandName);

            //获取品牌id聚合下的子聚合，默认图片
            ParsedStringTerms brand_image_agg = bucket.getAggregations().get("brand_image_agg");
            String brandImage = brand_image_agg.getBuckets().get(0).getKeyAsString();
            brandVo.setBrandImg(brandImage);
            brandVos.add(brandVo);
        }
        searchResult.setBrands(brandVos);

        //4、当前商品涉及到的所有分类信息
        List catalogVos = new ArrayList<>();
        //获取分类的聚合，遍历聚合信息
        ParsedLongTerms catalog_agg = aggregations.get("catalog_agg");
        for (Terms.Bucket bucket : catalog_agg.getBuckets()) {
            SearchResult.CatalogVo catalogVo = new SearchResult.CatalogVo();
            //获取分类id
            long catalogId = bucket.getKeyAsNumber().longValue();
            catalogVo.setCatalogId(catalogId);
            //获取分类id聚合下的子聚合，分类的名称
            ParsedStringTerms catalog_name_agg = bucket.getAggregations().get("catalog_name_agg");
            String catalogName = catalog_name_agg.getBuckets().get(0).getKeyAsString();
            catalogVo.setCatalogName(catalogName);
            catalogVos.add(catalogVo);
        }
        searchResult.setCatalogs(catalogVos);

        //5、分页信息-页码
        searchResult.setPageNum(searchProductDto.getPageNum());
        //获取分页信息
        TotalHits totalHits = hits.getTotalHits();
        //获取总记录数
        Long total = totalHits.value;
        //5、1分页信息、总记录数
        searchResult.setTotal(total);
        //5、2分页信息-总页码-计算 总记录/size 有余数 总记录/size+1  否则 总记录/size
        int totalPages = (int) (total % ElasticSearchIndex.PRODUCT_PAGESIZE == 0 ? total / ElasticSearchIndex.PRODUCT_PAGESIZE : total / ElasticSearchIndex.PRODUCT_PAGESIZE + 1);
        searchResult.setTotalPages(totalPages);
        //5.3 设置页码
        List pageNavs = new ArrayList<>();
        for (int i = 1; i <= totalPages; i++) {
            pageNavs.add(i);
        }
        searchResult.setPageNavs(pageNavs);

        //6、面包屑导航数据
        if (searchProductDto.getAttrs() != null && searchProductDto.getAttrs().size() > 0) {
            List navVos = searchProductDto.getAttrs().stream().map(attr -> {
                SearchResult.NavVo navVo = new SearchResult.NavVo();
                String[] s = attr.split("_");
                navVo.setNavValue(s[1]);
                SearchResult.AttrVo attrVo = attrVos.stream().filter(item -> item.getAttrId().equals(Long.valueOf(s[0]))).findFirst().orElse(null);
                if (attrVo != null){
                    navVo.setNavName(attrVo.getAttrName());
                }else {
                    navVo.setNavName("");
                }
                //2、取消了这个面包屑以后，我们要跳转到哪个地方，将请求的地址url里面的当前的品牌条件置空，剩余的url就是需要取消之后去的地方
                //拿到所有的查询条件，去掉当前
                String encode = null;
                try {
                    encode= URLEncoder.encode(attr, "UTF-8");//将空格转成 +
                    encode.replace("+","%20");  //浏览器对空格的编码和Java不一样，差异化处理
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                String uri = searchProductDto.getUri();
                String replace;
                if (uri.contains("&attrs")){
                    replace = searchProductDto.getUri().replace("&attrs=" + encode, "");
                }else {
                    replace = searchProductDto.getUri().replace("attrs=" + encode, "");
                }
                navVo.setLink("http://search.gulimall.com/list.html?" + replace);
                searchResult.getAttrsId().add(Long.valueOf(s[0]));
                return navVo;
            }).collect(Collectors.toList());
            searchResult.setNavs(navVos);
        }

        if (searchProductDto.getBrandId() != null && searchProductDto.getBrandId().size() > 0){
            List navs = searchResult.getNavs();
            SearchResult.NavVo navVo = new SearchResult.NavVo();
            navVo.setNavName("品牌:");
            List brandIds = searchProductDto.getBrandId();
            StringBuffer stringBuffer = new StringBuffer();

            for (Long brandId : brandIds) {
                SearchResult.BrandVo brandVo1 = brandVos.stream().filter(brandVo -> brandVo.getBrandId().equals(brandId)).findFirst().orElse(null);
                if (brandVo1 != null){
                    stringBuffer.append(brandVo1.getBrandName()+";");
                    String encode = null;
                    try {
                        encode= URLEncoder.encode(brandId+"", "UTF-8");//将空格转成 +
                        encode.replace("+","%20");  //浏览器对空格的编码和Java不一样，差异化处理
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    }
                    navVo.setNavValue(stringBuffer.toString());
                    String uri = searchProductDto.getUri();
                    String replace;
                    if (uri.contains("&brandId")){
                        replace = searchProductDto.getUri().replace("&brandId=" + encode, "");
                    }else {
                        replace = searchProductDto.getUri().replace("brandId=" + encode, "");
                    }
                    navVo.setLink("http://search.gulimall.com/list.html?" + replace);
                    navs.add(navVo);
                }
            }
        }
        return searchResult;
    }

4、Java虚拟机监控

4.1、jconsole 与 jvisualvm

Jdk 的两个小工具 jconsole、jvisualvm（升级版的 jconsole）;通过命令行启动，可监控本地和远程应用。远程应用需要配置。
jconsole 能干什么(不推荐)
- 打开控制台输入：jconsole 命令(安装Java8环境后)
- 监控内存，堆内存，线程，类.....
jvisualvm 能干什么(推荐)
- 打开控制台输入：jconsole 命令(安装Java8环境后)，也可以直接在Java安装目录下双击打开程序。
- 监控内存泄露，跟踪垃圾回收，执行时内存、 cpu 分析，线程分析...
  - 运行：正在运行的线程
  - 休眠：sleep的线程
  - 等待：wait的线程
  - 驻留：线程池里面的空闲线程
  - 监视：阻塞的线程，正在等待锁
- 安装插件方便查看 gc情况
结合Jmeter使用，压力测试，测试某个服务器响应速度或者接口或网关等情况，使用 jvisualvm 监控内存、CPU占用等情况，查看当前的压力测试吞吐量等信息。

4.2、项目设值堆内存大小

-Xms1024m -Xmx1024m -Xmn512m
-Xms 堆内存的初始大小，默认为物理内存的1/64
-Xmx 堆内存的最大大小，默认为物理内存的1/4
-Xmn 堆内新生代的大小
设置后，jvisualvm 查看效果

5、缓存

1、缓存使用

哪些数据适合放入缓存？
- 即时性、数据一致性要求不高的
- 访问量大且更新频率不高的数据（读多，写少）
- 举例：电商类应用，商品分类，商品列表等适合缓存并加一个失效时间(根据数据更新频率来定)，后台如果发布一个商品，买家需要 5 分钟才能看到新的商品一般还是可以接受的。
读模式缓存使用流程
```
data = cache.load(id);//从缓存加载数据
If(data == null){
data = db.load(id);//从数据库加载数据
cache.put(id,data);//保存到 cache 中
}
return data;
```
注意：在开发中，凡是放入缓存中的数据我们都应该指定过期时间，使其可以在系统即使没有主动更新数据也能自动触发数据加载进缓存的流程。避免业务崩溃导致的数据永久不一致问题

2、本地缓存

本地缓存在分布式下的问题
- 1、本地缓存只能获取自己部署的服务下的缓存，不能获取其他服务器内存存储的缓存，因为本地缓存存储的是本地服务中的内存。
- 2、数据一致性的问题：假设数据需要进行更新了。负载到第一个服务器，更新了第一服务器的本地缓存，其余两个节点未更新，下次负载到第二个服务器，导致数据不一致。
分布式缓存

3、整合 redis 作为缓存

引入 redis-starter


    org.springframework.boot
    spring-boot-starter-data-redis

 
    
     配置文件配置  redis 
     spring:
  redis:
    host: 192.168.56.10
    port: 6379
#    password: **** #未设置密码可不配置 
    
  
    
    
      使用 RedisTemplate 操作 redis 
      @Autowired
StringRedisTemplate stringRedisTemplate;
    @Test
    public void testStringRedisTemplate(){
        ValueOperations ops = stringRedisTemplate.opsForValue();
        ops.set("hello","world_"+ UUID.randomUUID().toString());
        String hello = ops.get("hello");
        System.out.println(hello);
    }

 
   
   
     注意：lettuce操作redis的客户端，产生堆外内存溢出OutOfDirectMemoryError。SpringBoot2,0以后默认使用 Lettuce作为操作 redis的客户端。它使用 netty进行网络通。 
    
    lettuce的bug导致netty堆外内存溢出，可设置：-Dio.netty.maxDirectMemory 
    
 解决方案：不能直接使用-Dio.netty.maxDirectMemory去调大堆外内存   
    
 1)、升级lettuce客户端。      2）、切换使用jedis 
    
    
    Lettuce、 jedis都是操作 redis的底层客户端。 Spring再次封装 redis Template 
    
   
    
   
  4、高并发下缓存失效问题 
  4.1、缓存穿透 
   
   缓存穿透：指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。 
   风险：利用不存在的数据进行恶意攻击，数据库瞬时压力增大，最终导致崩溃。 
   解决：将查询的null数据缓存到起来，并加入短暂过期时间。 
   
  4.2、缓存雪崩 
   
   缓存雪崩：指在我们设置缓存时key采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。 
   解决：原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。 
   
  4.3、缓存击穿 
   
   缓存穿透：对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。如果这个key在大量请求同时进来前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。 
   解决：加锁大量并发只让一个去查，其他人等待，查到以后释放锁，其他人获取到锁，先查缓存，就会有数据，不用去db。 
   
  4.4、加锁(本地锁)解决缓存击穿问题 
   
   加本地锁(synchronized，JUC（Lock)) 
     
     synchronized 加锁：锁住this，SpringBoot所有的组件在容器中都是单例的，可以锁住。     /**
     * spring是单例模式，所有项目启动就是一个对象，当前类的service都能用，本地缓存（如果有多个商品的微服务，而且占用的是本地内存，缓存就无法共享）
     */
    private Map cache = new HashMap<>();

    @Autowired
    private StringRedisTemplate redisTemplate;
    /**
     * 本地锁
     *
     * @return
     */
    public Map> catalogLevel23WithLock() {
        synchronized (this) {
            return catalogLevel23DB();
        }
    }


    private Map> catalogLevel23DB() {
        //先从redis缓存找，找到直接返回，否则查询数据库
        String catalogLevel23String = redisTemplate.opsForValue().get("catalogLevel23");
        if (StringUtils.isNotBlank(catalogLevel23String)) {
            Map> result = JSON.parseObject(catalogLevel23String, new TypeReference>>() {
            });
            return result;
        }
        System.out.println("查询数据库--23-");
        //先从本地缓存找，找到直接返回，否则查询数据库
        Map> catalogLevel23 = (Map>) cache.get("catalogLevel23");

        if (catalogLevel23 != null) {
            return catalogLevel23;
        }

        List categoryEntities = this.list();
        //筛选出1级分类
        List categoryLevel1s = categoryEntities.stream().filter(category -> category.getParentCid() == 0).collect(Collectors.toList());
        //筛选出2级、3级分类
        List categoryLevel23s = categoryEntities.stream().filter(category -> category.getParentCid() != 0).collect(Collectors.toList());

        Map> result = categoryLevel1s.stream().collect(Collectors.toMap(categoryLevel1 -> categoryLevel1.getCatId().toString(), categoryLevel1 -> {
            //筛选出当前父分类的所有子分类
            List categoryLevel2s = categoryLevel23s.stream().filter(categoryLevel23 -> categoryLevel23.getParentCid().equals(categoryLevel1.getCatId())).collect(Collectors.toList());

            List catelog2Vos = categoryLevel2s.stream().map(categoryLevel2 -> {
                //构造2级分类
                Catelog2Vo catelog2Vo = new Catelog2Vo(categoryLevel1.getCatId().toString(), null, categoryLevel2.getCatId().toString(), categoryLevel2.getName());
                //从2及分类中查出3及分类，构造出3级分类
                List category3Vos = categoryLevel23s.stream().filter(categoryLevel23 -> categoryLevel23.getParentCid().equals(categoryLevel2.getCatId())).map(categoryLevel3 -> {
                    Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo(categoryLevel2.getCatId().toString(), categoryLevel3.getCatId().toString(), categoryLevel3.getName());
                    return category3Vo;
                }).collect(Collectors.toList());
                catelog2Vo.setCatalog3List(category3Vos);
                return catelog2Vo;
            }).collect(Collectors.toList());
            return catelog2Vos;
        }));
        //cache.put("catalogLevel23",result);
        //缓存的保存也需要加到锁上，如果未加到锁方法中可能出现，还未保存到缓存中的的时候其他线程抢占到线程，就进入了查询数据库的操作，导致多次查询数据库
        String s = JSON.toJSONString(result);
        redisTemplate.opsForValue().set("catalogLevel23", s);
        return result;
    }
  
     使用本地锁出现的问题：假设有多个商品服务的服务，this锁只能锁住当前的服务没其他的服务还是有对应的锁，可能会多次查询数据库，需要使用分布式锁，就可以只访问一次数据库。 
     
   锁-时序问题(缓存保存时间问题) 
     
     设置缓存时，也需要和业务代码是原子性操作，需要加上锁内，如果未加到锁方法中可能出现，还未保存到缓存中的的时候其他线程抢占到线程，就进入了查询数据库的操作，导致多次查询数据库。
 
     
   分布式下如何加锁
 本地锁只能锁住，当前服务下的进程，不能锁住其他服务的进程，会导致多次数据库查询，每个服务查完一次后，还是会走缓存结果，性能方面影响不大，要处理这个问题，就需要分布式锁解决。
 
   IDEA 模拟多服务器部署(可以多复制上几个)，请求发送给网关，由网关负载均衡的跑到各个服务(4个服务的服务名一样spring.application.name)。
        #网关配置
        - id: gulimall-product-host
          uri: lb://gulimall-product
          predicates:
            #断言请求头匹配，能够匹配上 gulimall.com的请求头的转发到对应服务
            - Host=gulimall.com,item.gulimall.com
 
  
   
  4.5、加锁(分布式锁)解决缓存击穿问题 
   
   基本原理(redis 命令 set lock 111 NX   当lock键存在时，返回nil，当lock键不存在时，返回OK，两个核心：设置锁值时，保证设置时间和设置值保持原子性；解锁时，保证删除的是当前线程的锁和删除锁两个的原子性(LUA脚本解决))
 
   阶段一： 
     
     问题：业务代码报错或者执行完毕后，服务器突然断电，还未删除完毕，其他服务永远无法占用到该锁，一直循环； 
     解决办法：使用 try-finally 和 设置过期时间(阶段二解决)
 
     
   阶段二： 
     
     问题：在设置锁自动过期时间时，还未设置上时，突然断电，导致为设置上过期时间就退出了，其他服务永远无法占用到该锁，一直循环； 
     解决办法：设置值和设置时间，是原子性操作，要么完成要么不完成(阶段三解决)
 
     
   阶段三： 
     
     问题：线程1执行业务1的过程超过了lock锁的时间，lock锁就会自动删除，导致其他服务线程2抢占到锁，执行业务1，执行业务逻辑，线程1执行完逻辑后，进行锁的删除操作，结果删除了线程2设置的锁(误删除锁)，导致很多线程又可以同时访问业务，可能会多次查询数据库，出现问题（没锁住）。 
     解决办法：只能删除自己的锁，设置一个值为uuid，判断值相同才可以删除，否则不能删除(阶段四解决)
 
     
    假设5： 
     
     问题：锁过期时间为10秒，业务逻辑执行了9.5秒，获取lock锁的时间0.3秒，值已经获取到了，在进入 if判读 时，花了0.2秒，此时redis lock锁过期，已经更新成了别的线程的lock值，但此时已经进入了if，此时还是删除掉了别人的锁，导致很多线程又可以同时访问业务，可能会多次查询数据库，出现问题（没锁住）。 
     解决办法：获取值和删除锁需要原子操作，lua脚本和redis命令一起操作。(最终版解决)

 
     
   最终形态： 
     
     存在的问题，如果业务执行过长，锁无法自动续期。 
     解决：可以设置锁过期时间长一点；可以使用Redisson框架解决。     /**
     * redis分布式锁
     * 从数据库查找2、3级分类数据
     *
     * @return
     */
    public Map> catalogLevel23RedisLock() {
        /**
         * 加锁：this，springboot所有的组件在容器中都是单例的，可以锁住
         * 使用本地锁出现的问题：假设有多个商品服务的微服务，this锁只能锁住当前的微服务没其他的微服务还是有对应的锁，需要使用分布式锁
         */
        //加锁 setIfAbsent：如果存在当前的lock键，就返回false，不存在返回true
        //Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "0");
        //原子命令：设置值和设置时间，是原子性操作，要么完成要么不完成
        String uuid = UUID.randomUUID().toString();
        //出现假设4的问题
//        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "0",30,  TimeUnit.SECONDS);
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 30, TimeUnit.SECONDS);
        if (lock) {
            //抢占锁成功
            /**
             * 出现的问题:
             *  假设1:catalogLevel23DB抛出异常，导致锁永远无法删除，其他服务永远无法占用到该锁，一直循环，解决办法：try-finally
             *  假设2：catalogLevel23DB执行完毕后，服务器突然断电，还未删除完毕，其他服务永远无法占用到该锁，一直循环；解决办法：可以设置过期时间
             *  假设3：在设置锁自动过期时间时，还未设置上时，突然断电，导致为设置上过期时间就退出了，其他服务永远无法占用到该锁，一直循环；解决办法：设置值和设置时间，是原子性操作，要么完成要么不完成
             *  假设4：线程1执行业务1的过程超过了lock锁的时间，lock锁就会自动删除，导致其他服务线程2抢占到锁，执行业务1，执行业务逻辑，线程1执行完逻辑后，进行锁的删除操作，结果删除了线程2设置的锁(误删除锁)，导致很多线程又可以同时访问业务，可能会多次查询数据库，出现问题（没锁住）。解决办法：只能删除自己的锁，设置一个值为uuid，判断值相同才可以删除，否则不能删除
             *  假设5：锁过期时间为10秒，业务逻辑执行了9.5秒，获取lock锁的时间0.3秒，值已经获取到了，在进入 if判读 时，花了0.2秒，此时redis lock锁过期，已经更新成了别的线程的lock值，但此时已经进入了if，此时还是删除掉了别人的锁，导致很多线程又可以同时访问业务，可能会多次查询数据库，出现问题（没锁住）。解决办法：获取值和删除锁需要原子操作，lua脚本和redis命令一起操作。
             *
             */
            //设置锁自动过期时间 出现假设2、3的问题
            //redisTemplate.expire("lock",30, TimeUnit.SECONDS);
            //出现假设1的问题
            Map> map;
            try {
                System.out.println("获取redis锁成功=======");
                map = catalogLevel23DB(); //redis锁自动续期，暂时没做，在删除之前，锁的过期时间就删除了，需要在业务层面继续续锁，或者把锁的过期时间加长
            } finally {
                //出现假设4的问题
                //redisTemplate.delete("lock");
                /*
                String lockValue = redisTemplate.opsForValue().get("lock");
                //值相同才可以删除：出现假设5的问题
                if (uuid.equals(lockValue)){
                    redisTemplate.delete("lock");
                }*/
                //lua脚本
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                //执行脚本 返回值为 Long类型，KEYS[1] 对应 lock  ARGV[1] 对应uuid的值，如果redis存lock的值和uuid相同，则进行删除，保证了原子性
                Long lock1 = redisTemplate.execute(new DefaultRedisScript(script, Long.class), Arrays.asList("lock"), uuid);
            }
            return map;
        } else {
            System.out.println("获取redis锁失败成功=======进行重试");
            //抢占锁失败
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //自旋的方式获取锁
            return catalogLevel23RedisLock();
        }
    }
 

 
     
   
  5、Redisson 整合 
          官方文档 
  5.1、原生Redisson整合 
   
   导入依赖         
            org.redisson
            redisson
            3.12.0
        
  
   配置 RedissonClient /**
 * Redisson的配置类
 * @author pengjun
 */
@Configuration
public class MyRedissonConfig {

    /**
     * 所有对Redisson的使用都是通过RedissonClient
     * @return
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient(){
        Config config = new Config();

        //设置集群模式
//        config.useClusterServers()
//                .addNodeAddress("127.0.0.1:7004", "127.0.0.1:7001");
        //设置单个节点模式
        //Redis url should start with redis:// or rediss:// (for SSL connection)  配置路径必须配置redis: 开头
//        config.useSingleServer().setAddress("192.168.56.10:6379").setPassword();
        config.useSingleServer().setAddress("redis://192.168.56.10:6379");
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }

}
  
   测试打印客户端     @Autowired
    RedissonClient redissonClient;

    @Test
    public void redisson(){
        System.out.println(redissonClient);
    }
  
   
  5.2、使用 
   
   lock和unlock    
    @Autowired
    private RedissonClient redissonClient;
     /**
     * 测试简单请求
     * @return
     */
    @ResponseBody
    @GetMapping({"testHello"})
    public String testHello(){
        //RLock 集成了Lock api都是一样的
        RLock lock = redissonClient.getLock("my-lock");
        //redis存储的是 my-lock : uuid:线程id , 看门狗：过期时间是自动续期的(如果业务执行过长，过期时间会自动增加，默认30s)
        //加锁的业务只要运行完成，就不会给当前锁续期，即使不手动释放锁，锁默认也在30s以后自动删除
        //lock.lock();//阻塞住，只能得到锁才能往下走，其他的都只能等待，我们自己写的redis分布式锁，则是自旋的方式获取锁 阻塞式等待。默认加的锁都是30s
        //指定自动解锁时间，10s后自定删除锁，不会自动续期，自动解锁时间一定要大于业务员执行时间，会其他线程抢占到锁，当前线程删除锁时，抛出异常，删除的是别人的锁
        lock.lock(10, TimeUnit.SECONDS);
        /**
         *  1）、锁的自动续期，如果业务超长，运行期间自动锁上新的30s。不用担心业务时间长，锁自动过期被删掉
         *  2）、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s内自动过期，不会产生死锁问题
         *  3)、myLock.lock(10,TimeUnit.SECONDS);   //10秒钟自动解锁,自动解锁时间一定要大于业务执行时间
         *      问题：在锁时间到了以后，不会自动续期
         */
        //最佳实战： lock.lock(30, TimeUnit.SECONDS); 省掉了自动续期，30s的业务执行不完，也就是业务有问题
        /**
         * 1、如果我们传递了锁的时间，就发送redis执行脚本，进行站锁，默认超时就是我们指定的时间
         * 2、如果我们未指定锁的超时时间，就是使用 30 * 1000 【lockWatchdogTimeout看门狗的默认时间】
         *  只要占锁成功,就会启动一个定时任务【重新给锁设置过期时间,新的过期时间就是看门狗的默认时间】,每隔10秒都会自动的再次续期，续成30秒
         *  定时任务 internalLockLeaseTime【看门狗的默认时间】 / 3 ，10s中执行一次， 10s后自动续期，续期到看门狗时间
         */
        try {
            System.out.println("获取锁成功,执行业务需求--"+Thread.currentThread().getName() + Thread.currentThread().getId());
            //模拟业务超长，发送两次请求，一个只能等待，执行完成后，另一个才能获取锁
            Thread.sleep(30000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //假设：有两个商品服务，一个请求 10000端口，一个请求10001端口，请求10000端口时，突然宕机，还未释放锁，10001端口的线程也能获取到锁，redisson会自己解锁。
            lock.unlock();
            System.out.println("解锁锁成功"+Thread.currentThread().getName() + Thread.currentThread().getId());
        }
        return "hello";
    }
  
   读写锁     @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private StringRedisTemplate redisTemplate;
    /**
     * 读写锁：保证一定能读到最新数据，修改期间，写锁是一个排他锁(互斥锁、独享锁)，读锁是一个共享锁
     * 写锁没释放读就必须等待，读取的是最新的数据
     *  http://localhost:10000/write  http://localhost:10000/read
     *  先发送写锁请求，在发送读锁请求，读锁请求需要等待写锁请求写完之后，读锁才可以读取数据，处于阻塞状态
     *  读锁可以共享，不会阻塞
     *
     *  读 + 读 ：相当于无锁，只会在redis中记录好，所有当前的读锁，他们都是会同时加锁成功 （模拟：写发送写请求，在四个浏览器窗口发读请求，都一起获取到了锁）
     *  读 + 写 ：有读锁，写也需要等待 (模拟：发送读请求，在发送写请求，处理读业务20s，才能写入成功)
     *  写 + 读 ：等待写锁释放，才可以读取
     *  写 + 写 ：阻塞方式，只能一个个写
     *  只要有写的存在，必须等待
     */
    /**
     * 写锁
     * @return
     */
    @ResponseBody
    @GetMapping({"write"})
    public String write(){
        String s = UUID.randomUUID().toString();

        //获取读写锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");

        //获取写锁
        RLock wLock = readWriteLock.writeLock();
        try {
            System.out.println("加写锁成功===========");
            //上写锁  写锁没释放，读锁就不能读
            wLock.lock();
            redisTemplate.opsForValue().set("write",s);
            //模拟业务执行20s
            Thread.sleep(20000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            wLock.unlock();
            System.out.println("解写锁成功===========");
        }
        return s;
    }

    /**
     * 读锁
     * @return
     */
    @ResponseBody
    @GetMapping({"read"})
    public String read(){
        //获取读写锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");

        //juc的读写锁
//        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
//        ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();

        //获取写锁
        RLock rLock = readWriteLock.readLock();
        String s = "";
        try {
            System.out.println("加读锁成功===========");
            //上写锁  写锁没释放，读锁就不能读
            rLock.lock();
            s = redisTemplate.opsForValue().get("write");
            //模拟业务执行20s
            Thread.sleep(20000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rLock.unlock();
            System.out.println("解读锁成功===========");
        }
        return s;
    }
  
   信号量锁     /**
     *       CountDownLatch :减少计数
     *          CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
     *          其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
     *          当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。
     *
     *       CyclicBarrier:循环栅栏
     *         CyclicBarrier的字面意思是可循环（Cyclic）使用的屏障（Barrier）。
     *         它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
     *         线程进入屏障通过CyclicBarrier的await()方法。
     *
     *       Semaphore信号灯
     *         在信号量上我们定义两种操作：
     *             acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
     *             release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
     *             信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
     *     https://blog.csdn.net/weixin_43947102/article/details/123417002
     */
    /**
     * 信号量
     * 模拟停车位：3个停车位，只能停3辆车，在来了车，就需要等待，其他的开走。
     *  三次调用 停车请求，第四调用时，则需等待阻塞，等待开出停车位请求完成，才可以获取到停车位
     * 可以做分布式的限流
     */
    @ResponseBody
    @GetMapping({"park"})
    public String park() throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
        RSemaphore park = redissonClient.getSemaphore("park");
        /*
        juc信号量
        Semaphore semaphore = new Semaphore(3);
        semaphore.acquire();
        semaphore.release();*/
        //获取信号量，如果能获取到，则往下执行，获取不到则需要等待
        //park.acquire();
        //尝试获取一个信号量，如果能够获取到就返回ture，获取不到也不会等待，返回false
        boolean b = park.tryAcquire();
        if (b){
            //获取到了信号量，处理业务需求
        }else {
            return "error"+ b;
        }
        return "ok"+ b;
    }
    /**
     * 开出停车位
     */
    @ResponseBody
    @GetMapping({"go"})
    public String go(){
        RSemaphore park = redissonClient.getSemaphore("park");
        //释放信号量
        park.release();
        return "ok";
    }
  
   闭锁     /**
     * 模拟:5个班级，人全部走完了，门卫才可以关门
     *  先访问 lockDoor请求，直接等待，需要访问 gogogo/{id}请求5次之后，lockDoor请求才会继续往下执行
     */
    @ResponseBody
    @GetMapping({"lockDoor"})
    public String lockDoor() throws InterruptedException, BrokenBarrierException {
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        //JUC:CountDownLatch countDownLatch = new CountDownLatch(5);
 /*       CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () ->{
            System.out.println("七龙珠汇合");
        });
        cyclicBarrier.await();*/
        door.trySetCount(5);
        //等待，只有等待5个班级的人走光了才会继续往下执行
        door.await();
        return "ok";
    }

    /**
     * 班级走
     */
    @ResponseBody
    @GetMapping({"gogogo/{id}"})
    public String gogogo(@PathVariable("id") Integer id) {
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        //班级走一个，减一个，减到位0，lockDoo()才会继续往下走
        door.countDown();
        return "班级"+id+"走";
    }
  
   
  6、缓存数据一致性问题 
  6.1、双写模式 
   
   更新缓存数据的同时也更新缓存。 
   出现的问题: 假设两个线程都对同一条数据进行了更新操作，线程1更新完成后，还未写入缓存，线程2此时，进行了更新和写入缓存，线程1此时恢复，更新了缓存，导致数据还是不一致。产生了脏数据，这是暂时性的脏数据问题，但是在数据稳定，缓存过期以后，又能得到最新的正确数据，能保证最终一致性。
 
   解决办法： 
     
     进行加锁操作，更新数据库和更新缓存都在同一把锁上 
     系统允不允许短暂的数据不一致问题存在 
     
   
  6.2、失效模式 
   
   更新缓存数据的同时删除缓存，由下次查询的时候插入缓存。 
   出现的问题
 
   
  6.3、延迟双删 
   
   先删除缓存 
   再写数据库 
   休眠500毫秒 
   再次删除缓存 
   
  6.4、总结 
   
   无论是双写模式还是失效模式，都会导致缓存的不一致问题。即多个实例同时更新会出事。怎么办？ 
     
     如果是用户纬度数据（订单数据、用户数据），这种并发几率非常小，不用考虑这个问题，缓存数据加上过期时间，每隔一段时间触发读的主动更新即可。 
     如果是菜单，商品介绍等基础数据，也可以去使用canal订阅binlog的方式。 
     缓存数据+过期时间也足够解决大部分业务对于缓存的要求。 
     通过加锁保证并发读写，写写的时候按顺序排好队。读读无所谓。所以适合使用读写锁。（业务不关心脏数据，允许临时脏数据可忽略）。 
     
   总结： 
     
     我们能放入缓存的数据本就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间，保证每天拿到当前最新数据即可。 
     我们不应该过度设计，增加系统的复杂性。 
     遇到实时性、一致性要求高的数据，就应该查数据库，即使慢点。. 
     
   
  6.5、异步更新缓存（基于Mysql binlog的同步机制 Canal) 
  Canal基本使用
 
  7、SpringCache
  标题 
  7.1、整合 
   
   导入依赖         
        
            org.springframework.session
            spring-session-data-redis
        

        
            org.springframework.boot
            spring-boot-starter-cache
        
  
   自动配置 
     
     CacheAutoConfiguration 会导入 RedisCacheConfiguration，它自动配置好了缓存管理器 RedisCacheManager，缓存管理器会判断是否RedisCacheConfiguration配置，有了就用门自定义的，没有用默认的。 
     启动类上标记 @EnableCaching 开启spring cache 缓存功能 
     配置文件使用redis作为缓存 spring:
  cache:
    type: redis
    redis:
      time-to-live: 360000 #${random.int} #key的过期时间，单位ms
      #key-prefix: CACHE_ #key的所有前缀,如果指定了前缀就用我们指定的前缀，如果没有就默认使用，注解上配置的 key 属性的值作为缓存的名字,以value的值作为分组
      #use-key-prefix: true #是否开启前缀，开启了就会添加上述前缀CACHE_缓存名，不开启就只有 缓存名:value
      cache-null-values: true #是否缓存空置，防止缓存穿透
    #指定缓存的名称，存储缓存时可以从指定的缓存名拿
#    cache-names:
  
     
   缓存注解使用(直接标记在方法上即可) 
     
     @Cacheable: Triggers cache population,触发将数据保存到缓存的操作 
     @CacheEvict; Triggers cache eviction,:触发将数据从缓存删除的操作。失效模式 
     @CachePut: Updates the cache without interfering with the method execution,不影响方法执行更新缓存。双写模式 
     @Caching: Regroups multiple cache operations to be applied on a method,组合以上多个操作 
     @CacheConfig: Shares some common cache- related settings at class-level;在类级别共享缓存的相同配置 
     
   
  7.2、使用细节 
  //===============================用法========================
//@Cacheable(value = {"category"}) //value 指定在那个区 可以指定多个区内 自定义使用字符串作为key
//@Cacheable(value = {"category"},key = "'myCategory'") //自定义使用字符串作为key，必须加单引号，不加单引号会当做表达式解析
//@Cacheable(value = {"category"},key = "#root.method.name",sync = true) //获取当前方法名作为key sync 加本地锁的缓存
public List queryCategoryLevel1(){}



//@CacheEvict(value = "category" ,key = "'queryCategoryLevel1'") //Redis和MySQL数据同步问题，失效模式：删除key为 queryCategoryLevel 的缓存
// @CacheEvict(value = "category",allEntries = true) //更新了分类数据，将所有category分组下的缓存全部删除 最好开启默认前缀
//@CachePut(value = "category",key = "'catalogLevel23'") //Redis和MySQL数据同步问题，双写模式：更新后，如果当前更新了，方法返回了的对象(可以再次去查找新的分类数据)，在把该对象缓存起来
//@CachePut(value = "category",key = "'queryCategoryLevel1'")
@Caching(
         //组合多个springcatch注解，evict：标记多个更新删除缓存后，删除多个key
         evict = {
             @CacheEvict(value = "category",key = "'catalogLevel23'"),
             @CacheEvict(value = "category",key = "'queryCategoryLevel1'")
         }
    )
public void updateCascade(CategoryEntity category){}


//============================ 缓存的配置=======================
/**
 * 缓存的配置(包括key和value的格式化，读取配置文件信息)
 * @author pengjun
 */
@Configuration
@EnableCaching //开启spring cache 缓存功能
//@EnableConfigurationProperties(CacheProperties.class)
public class MyRedisCacheConfiguration {

//    @Autowired
//    CacheProperties cacheProperties;


    /**
     * 1、缓存的配置文件中的bean没有注入到容器中
     *  @ConfigurationProperties(prefix = "spring.cache")
     *  public class CacheProperties
     * 2、要让他注入到容器中
     *  @EnableConfigurationProperties(CacheProperties.class)
     * @return
     */
    @Bean
    public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
        //获取系统默认的缓存配置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();

        // config.serializeKeysWith都是返回一个new的新的RedisCacheConfiguration，需要使用config = 去接收反回来的新对象，配置才可以全设置上
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        //获取缓存的配置文件信息，设置当前的缓存配置应用上配置文件的配置
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();

        //读取配置文件中的配置信息，如果不配置，配置文件配置的信息就会失效
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }
        return config;
    }
} 
   
     每一个需要缓存的数据我们都来指定要放到那个分区的缓存。【相当于缓存分区(按照业务类型分，也可以放到多个分组中)】
  
    代表当前方法的结果需要缓存： 如果缓存中有，方法不用调用；如果缓存中没有，就调用方法。先从缓存中获取，缓存中有直接返回，缓存中没有，调用目标方法(查找数据库)，在把执行的目标方法返回值存储到缓存中。
  
    默认行为 
     
      Key的默人自动生成：缓存的名字::SimpleKey{}(自动生成的key值)。
  
       缓存的value的值，默认使用Jdk序列化机制，将序列化的数据存到redis。
  
       默认ttl时间 为 -1 ，永不过期。
  
     
    自定义 
     
      指定生成的缓存的使用的Key：key属性指定，可以接收一个SpEL表达式。
  
      定缓存的数据的存活时间 ：配置文件中修改配置属性(spring.cache.redis.time-to-live: 360000 #${random.int} #key的过期时间，单位ms)。
  
      将数据保存为Json格式：需要自定义 缓存管理器。
  
     
    Spring-Cache的不足：CacheManager (RedisCacheManager) -> Cache(RedisCache) 
     
      读模式： 
       
        解决：加随机过期时间， SpringCache 配置文件 time-to-live: 360000 #${random.int}。
  
        缓存雪崩：大量的key同时过期。
  
        解决：加锁，默认是无锁的，sync = true 就是加锁状态，是本地锁，但不影响(多服务也就多查几次),不是分布式锁。没指定sync = true， RedisCache 就不会调用同步的 synchronized 的方法指定了sync = true 会调用 RedisCache 的 public synchronized  T get(Object key, Callable valueLoader)。
  
        缓存击穿：大量并发进来同时查询一个数据，此时该数据整好达到过期时间，请求直接达到数据库。
  
        解决：缓存空数据；springCache 配置文件 cache-null-values: true
  
        缓存穿透：查询一个数据库和Redis都不存在的数据，每次请求都进入数据库查询
  
       
      写模式：（缓存与数据库一致，SpringCache没有管） 
       
         读写加锁：读多，写少的情况加锁。缓存的数据本就不应该是实时性、一致性要求超高的，遇到实时性、一致性要求高的数据，就应该查数据库。
  
        引入Canal，感知到MySQL的更新去更新数据库(使用Canal订阅Binlog的方式)。
  
        读多写多，直接去数据库查询就行。
  
        读多写少读数据直接用SpringCache,写数据可以加读写锁，读多写多直接查数据库
  
       
      总结： 
       
         常规数据(读多写少，及时性，一致性要求不高的数据)，可以使用SpringCatch。
  
        写模式：只要设置缓存时间即可。
  
        特殊数据(及时性、一致性要求搞，又要求缓存的数据)特殊设计。
  
       
     
    自定义缓存管理器原理：CacheAutoConfiguration -> RedisCacheConfiguration ->自动配置了 RedisCacheManager -> 初始化所有的缓存设置的名称(指定缓存的名称，存储缓存时可以从指定的缓存名拿 cache-names: ) -> 每个缓存决定使用什么配置 -> 如果RedisCacheConfiguration 有就用自己的配置，没有就用默认配置->想改缓存的配置，只需要给容器中放一个 RedisCacheConfiguration 即可->就会应用到当前 RedisCacheManager 管理的所有缓存分区中。
  
   
  6、异步和线程 
  6.1、初始化线程的 4 种方式 
   
   继承 Thread public class Thread01 extends Thread {
    @Override
    public void run() {
        System.out.println("Thread01"+Thread.currentThread().getId() + "执行了");
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
      System.out.println("main......start.....");
      Thread thread = new Thread01();
      thread.start();
      System.out.println("main......end.....");
}
  
  
   .实现 Runnable 接口 public class Runnable01 implements Runnable{
    @Override
    public void run() {
        System.out.println("Runnable01"+Thread.currentThread().getId() + "执行了");
    }
}


public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main......start.....");
    Runnable01 runnable01 = new Runnable01();
    new Thread(runnable01).start();
    System.out.println("main......end.....");
}
  
  
   实现 Callable 接口 + FutureTask （可以拿到返回结果，可以处理异常） public class Callable01 implements Callable {
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable01"+Thread.currentThread().getId() + "执行了");
        return 2;
    }
}


public static void main(String[] args) throws ExecutionException, InterruptedException {
     System.out.println("main......start.....");
     FutureTask futureTask = new FutureTask<>(new Callable01());
     new Thread(futureTask).start();
     System.out.println(futureTask.get());//获取结果 会暂停当前线程 获取到线程结果后继续往下执行
     System.out.println("main......end.....");
}
  
  
   线程池     public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");
        executor.execute(new Runnable01());
        Future submit = executor.submit(new Callable01());
        //阻塞状态，没获取到结果，就会阻塞主线程
        Integer integer = submit.get();
        System.out.println("main......start....." + integer);
}
  
  
   区别和场景 
     
     方式 1 和方式 2：主进程无法获取线程的运算结果。不适合当前场景，可以导致服务器资源耗尽。 
     方式 3：主进程可以获取线程的运算结果，但是不利于控制服务器中的线程资源。可以导致服务器资源耗尽。 
     通过线程池性能稳定，也可以获取执行结果，并捕获异常。但是，在业务复杂情况下，一
 个异步调用可能会依赖于另一个异步调用的执行结果。 
     
   
  6.2、线程池的七大参数 
      /**
     * 线程池开启线程
     * 详细查看此文章：https://blog.csdn.net/weixin_43947102/article/details/123417002
     */
    public void threadPool() {
        //固定的线程数 core = max
        Executors.newFixedThreadPool(10);
        //缓存线程池 core =0 ；max = Integer.MAX_VALUE
        Executors.newCachedThreadPool();
        //定时线程池 core = 10 ；max = Integer.MAX_VALUE
        Executors.newScheduledThreadPool(10);
        //一个线程数 core = max = 1
        Executors.newSingleThreadExecutor();

  /*
    自定义线程池的七个参数：
       public  ThreadPoolExecutor(int corePoolSize,// 线程池中的常驻核心线程数 除非设置了 allowCoreThreadTimeOut
                              int maximumPoolSize, //线程池中能够容纳同时执行的最大线程数，此值必须大于等于1
                              long keepAliveTime,// 多余的控线线程的存活时间 当前线程池中数量超过corePoolSize时，当空闲时间达到KeepAliveTime时，多余线程会被销毁直到只剩下corePooleSize个线程为止
                              TimeUnit unit, //KeepAliveTime的单位
                              BlockingQueue workQueue,// 阻塞队列，用来存储等待执行的任务，如果当前对线程的需求超过了 corePoolSize大小，就会放在这里等待空闲线程执行。
                              ThreadFactory threadFactory, //表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可，比如指定线程名等
                              RejectedExecutionHandler handler)//拒绝策略，表示当队列名满了，并且工作线程大于等于线程池的最大线程数时，如何来拒绝请求执行的runnable的策略
    }
    */
    } 
   
    corePoolSize：池中一直保持的线程的数量，即使线程空闲。除非设置了allowCoreThreadTimeOut
  
    maximumPoolSize：pool池中允许的最大的线程数
  
    keepAliveTime：当线程数大于核心线程数的时候，线程在最大多长时间没有接到新任务就会终止释放，最终线程池维持在 corePoolSize 大小
  
    unit：时间单位
  
    workQueue：阻塞队列，用来存储等待执行的任务，如果当前对线程的需求超过了 corePoolSize大小，就会放在这里等待空闲线程执行。
  
    threadFactory：创建线程的工厂，比如指定线程名等
  
    handler：拒绝策略，如果线程满了，线程池就会使用拒绝策略。
  
   
  6.3、线程池运行流程 
   
   线程池创建，准备好 core 数量的核心线程，准备接受任。务 
   新的任务进来，用 core 准备好的空闲线程执行。 
     
     core 满了，就将再进来的任务放入阻塞队列中。空闲的 core 就会自己去阻塞队
 列获取任务执行。 
     阻塞队列满了，就直接开新线程执行，最大只能开到 max 指定的数量。 
     max 都执行好了。Max-core 数量空闲的线程会在 keepAliveTime 指定的时间后自
 动销毁。最终保持到 core 大小。 
     如果线程数开到了 max 的数量，还有新任务进来，就会使用 reject 指定的拒绝策
 略进行处理。 
     
   所有的线程创建都是由指定的 factory 创建的。 
   案例分析： 
     
      
       一个线程池  core 7 ；  max 20  ， queue ： 50 ， 100  并发进来怎么分配的：先有 7  个能直接得到执行，接下来  50  个进入队列排队，在多开  13  个继续执行。现在  70 个被安排上了。剩下  30  个默认拒绝策略。 
      
  
     
   
  6.4、开发中为什么使用线程池 
   
   降低资源的消耗：通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗 
   提高响应速度：因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行。 
    提高线程的可管理性：线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配 
   
  6.5、CompletableFuture异步编排 
   
   业务场景：查询商品详情页的逻辑比较复杂，有些数据还需要远程调用，必然需要花费更多的时间。假如商品详情页的每个查询，需要如下标注的时间才能完成，那么，用户需要 5.5s 后才能看到商品详情页的内容。很显然是不能接受的。如果有多个线程同时完成这 6 步操作，也许只需要 1.5s即可完成响应。
 
   创建异步对象 
     
     CompletableFuture 提供了四个静态方法来创建一个异步操作。
 
     runXxxx 都是没有返回结果的，supplyXxx 都是可以获取返回结果的 
     executor参数：可以传入自定义的线程池，否则就用默认的线程池； 
     
   计算完成时回调方法         public static ExecutorService executor = Executors.newFixedThreadPool(10);
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");
        /**
         * 没有返回值的异步回调
         */
         CompletableFuture future0 = CompletableFuture.runAsync(() -> {
             System.out.println("当前线程：" + Thread.currentThread().getId());
             int i = 10 / 2;
             System.out.println("运行结果：" + i);
         }, executor);

        /**
         * 有返回值的，且抛出异常后的方法的处理
         */
         CompletableFuture future = CompletableFuture.supplyAsync(() -> {
             System.out.println("当前线程：" + Thread.currentThread().getId());
             int i = 10 / 0;
             System.out.println("运行结果：" + i);
             return i;
         }, executor).whenComplete((res,exception) -> {
             //res 返回结果 没异常返回null exception：异常信息 有异常无法回结果
             //虽然能得到异常信息，但是没法修改返回数据
             System.out.println("异步任务成功完成了...结果是：" + res + "异常是：" + exception);
         }).exceptionally(throwable -> {
             //可以感知异常，同时返回默认值，抛出异常返回默认值
             return 10;
         });
        //获取结果，也会阻塞主线程
        System.out.println(future.get()); //10
        System.out.println("main......end.....");
}
  
   handle 方法         public static ExecutorService executor = Executors.newFixedThreadPool(10);
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");
        /**
         * 统一处理结果和异常信息
         */
         CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
             System.out.println("当前线程：" + Thread.currentThread().getId());
             int i = 10 / 2;
             System.out.println("运行结果：" + i);
             return i;
         }, executor).handle((result,thr) -> {
             //直接处理异常和结果，不需要上面那样分开处理
             if (result != null) {
                 return result * 2;
             }
             if (thr != null) {
                 System.out.println("异步任务成功完成了...结果是：" + result + "异常是：" + thr);
                 return 0;
             }
             return 0;
         });
         //获取结果，也会阻塞主线程
        System.out.println(future2.get()); //抛出异常返回0 否则返回10
        System.out.println("main......end.....");
}
  
   线程串行化方法 
     
     thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。 
     thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。 
     thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行thenRun 的后续操作。 
     带有 Async 默认是异步执行的。同之前。 
     以上都要前置任务成功完成。 
     Function T：上一个任务返回结果的类型，U：当前任务的返回
 值类型。
           /**
         * 线程串行化：一步一步执行  run、accept、apply 就这三种，记住
         * 1、thenRunAsync：不能获取上一步的执行结果,无返回值，继续调用其他业务
         * 2、thenAcceptAsync：能接受上一步结果，但是无返回值
         * 3、thenApplyAsync：能接受上一步结果，有返回值
         *
         */
        CompletableFuture future3 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务2启动了..." + res);
            return "Hello" + res;
        }, executor);
        System.out.println("main......end....." + future3.get());
  
     
   两任务组合 - 都要完成(两个任务必须都完成，触发该任务) 
     
     thenCombine：组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值 
     thenAcceptBoth：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值。 
     runAfterBoth：组合两个 future，不需要获取 future 的结果，只需两个 future 处理完任务后，处理该任务。         /**
         * 两个线程都完成了任务后在完成另外一个任务
         */
        CompletableFuture