一、初级篇

1. docker的使用

1.1 安装mysql

• 每个容器，相当于在linux内开辟一个小型的linux，通过docker exec -it mysql bin/bash进入容器，可看到与linux系统相同的目录结构。

• -v命令将mysql容器内 常用目录 挂在到 linux目录 上
  

• vim修改/mydata/mysql/conf/my.conf下的mysql配置文件:

[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

1.2 docker安装redis

同理，我们使用docker安装redis：

mkdir -p /mydata/redis/conf

touch /mydata/redis/conf/redis.conf

touch命令有两个功能：

①是用于把已存在文件的时间标签更新为系统当前的时间（默认方式），它们的数据将原封不动地保留下来；
②是用来创建新的空文件。

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

默认是不持久化的。在配置文件中输入appendonly yes，就可以 AOF 持久化了。

vim /mydata/redis/conf/redis.conf

进入redis客户端:

docker exec -it redis redis-cli

2. 人人开源 搭建后台管理系统

2.1 配置

renren-fast + renren-fast-vue 组成了一套前后端分离的后台管理系统

① renren-fast

• 直接拷贝到 kedamall 工程里
• 使用renren-fast/db/mysql.sql，建表
• 修改项目中的application.yml

url: jdbc:mysql://云服务器地址/kedamall-admin?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
username: root
password: root

• 测试：http://localhost:8080/renren-fast/

② renren-fast-vue： 用vscode打开

2.2. 逆向工程

为每个微服务生成最基本的CRUD代码

renren-generator

• 修改application.yml（以逆向 表kedamall_pms为例）

url: jdbc:mysql://腾讯云外网地址/kedamall-pms?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
username: root
password: root

• 修改generator.properties

# 主目录
mainPath=com.example
#包名
package=com.example.kedamall
#模块名
moduleName=product
#作者
author=作者
#email
email=邮箱

#表前缀(类名不会包含表前缀) # 我们的pms数据库中的表的前缀都pms
# 如果写了表前缀，每一张表对于的javaBean就不会添加前缀了
tablePrefix=pms_

• 运行RenrenApplication，访问http://localhost:801/来逆向生成代码

2.3 跨域资源共享

由vue发送http请求给后端 kedamall 项目的网关localhost:88，但需要解决跨域的问题

① 替换static\config\index.js文件中的window.SITE_CONFIG[‘baseUrl’]，统一向网关发送请求：

window.SITE_CONFIG['baseUrl'] = 'http://localhost:88/api';

并将renren-fast注册到nacos注册中心中（我们需要通过网关来完成路径的映射）

application:
    name: renren-fast
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.137.14:8848

      config:
        name: renren-fast
        server-addr: 192.168.137.8848
        namespace: ee409c3f-3206-4a3b-ba65-7376922a886d

并配置网关路由，前台的所有请求都是经由http://localhost:88/api来转发的，在kedamall-gateway中添加路由规则：

- id: admin_route
		  ## lb://renren-fast——表示负载均衡到某一服务（只需写服务名）
          uri: lb://renren-fast
          ## 断言：
          predicates:
          	  ## 是指定的路径就路由过来
            - Path=/api/**

② 此时现在的验证码请求路径：

http://localhost:88/api/captcha.jpg?uuid=69c79f02-d15b-478a-8465-a07fd09001e6

原始的验证码请求路径：

http://localhost:8001/renren-fast/captcha.jpg?uuid=69c79f02-d15b-478a-8465-a07fd09001e6

因此需要对请求路径进行重写一去掉/api前缀

spring:
  cloud:
    gateway:
      routes:
      - id: admin_route
          uri: lb://renren-fast
          predicates:
            - Path=/api/**
          filters:
            # 路径重写
            - RewritePath=/api/(?<segment>/?.*), /renren-fast/$\{segment}

③ 解决跨域问题

什么是跨域？

• CORS——跨域资源共享
• 同源策略

解决方法：在网关中定义“KedamallCorsConfiguration类，用来做过滤——允许所有的请求跨域，即通过设置第2步，告诉浏览器可以跨域

@Configuration
public class KedamallCorsConfiguration {

	// SpringBoot 提供的一个filter
    @Bean
    public CorsWebFilter corsWebFilter(){
        UrlBasedCorsConfigurationSource source=new UrlBasedCorsConfigurationSource();
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.setAllowCredentials(true);
        
        source.registerCorsConfiguration("/**",corsConfiguration);
        return new CorsWebFilter(source);
    }
}

2.4 阿里云对象存储（OSS）

分布式服务下，我们采用文件存储服务器（采用阿里云的）进行文件存储；具体的，我们把商品的图片等信息存到阿里云OSS中。

2.5 JSR303后端校验

JSR303——Java 规范提案No.303，都在javax.validation.constraints包中；

步骤①：给Bean加校验注解，例如：

• @NotNull
• @NotEmpty——该注解修饰的字段不能为null或""
• @NotBlank——该注解不能为null，并且至少包含一个非空白字符。

也可自定义错误消息：

@NotBlank(message = "品牌名必须非空")
private String name;

步骤②：在请求方法处使用校验注解@Valid，开启校验：

    @RequestMapping("/save")
    public R save(@Valid @RequestBody BrandEntity brand){
		brandService.save(brand);

        return R.ok();
    }

步骤③：给校验的Bean后，紧跟一个BindingResult，就可以获取到校验的结果。拿到校验的结果，就可以自定义的封装。

 	@RequestMapping("/save")
    public R save(@Valid @RequestBody BrandEntity brand, BindingResult result){
        if( result.hasErrors()){
            Map<String,String> map=new HashMap<>();
            //1.获取错误的校验结果
            result.getFieldErrors().forEach((item)->{
                //获取发生错误时的message
                String message = item.getDefaultMessage();
                //获取发生错误的字段
                String field = item.getField();
                map.put(field,message);
            });
            return R.error(400,"提交的数据不合法").put("data",map);
        }
        
		brandService.save(brand);
        return R.ok();
    }

步骤④：统一异常处理。使用 SpringMVC 提供的 RestControllerAdvice=@ControllerAdvice+@ResponseBody，通过basePackages能够说明处理哪些路径下的异常。

@Slf4j
@RestControllerAdvice(basePackages = "com.example.kedamall.product.controller")
public class KedamallExceptionAdvice {
    @ExceptionHandler(value = Exception.class)
    public R handleValidException(MethodArgumentNotValidException exception){
        Map<String,String> map=new HashMap<>();
        BindingResult bindingResult = exception.getBindingResult();
        bindingResult.getFieldErrors().forEach(fieldError -> {
            String message = fieldError.getDefaultMessage();
            String field = fieldError.getField();
            map.put(field,message);
        });

        log.error("数据校验出现问题{},异常类型{}",exception.getMessage(),exception.getClass());
        return R.error(BizCodeEnum.VALID_EXCEPTION.getCode(),BizCodeEnum.VALID_EXCEPTION.getMsg()).put("data",map);
    }

2.6 设计错误状态码

正规开发过程中，错误状态码有着严格的定义规则，该在项目中我们的错误状态码定义如下：
错误码和错误信息定义类

1. 错误码定义规则为 5位数字
2. 前两位表示业务场景，最后三位表示错误码。例如：100001。10——通用，001——系统未知异常
3. 维护错误码后需要维护错误描述，将他们定义为枚举形式

错误码列表：

package com.example.common.exception;

public enum BizCodeEnum {
    UNKNOW_EXEPTION(10000,"系统未知异常"),
    VALID_EXCEPTION( 10001,"参数格式校验失败"),
    SMS_CODE_EXCEPTION( 10002,"请求频率太高，请稍后再试"),
    USER_EXIST_EXCEPTION( 15001,"用户存在异常"),
    PHONE_EXIST_EXCEPTION( 15002,"手机号存在异常"),
    LOGIN_ACCOUNT_OR_PASSWORD_ERROR_EXCEPTION( 15003,"帐号或密码错误"),
    NO_STOCK_EXCEPTION( 21000,"商品库存不足"),
    PRODUCT_UP_EXCEPTION(11000,"商品上架异常");

    private int code;
    private String msg;


    BizCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

二、高级篇

1. ELASTICSEARCH

1.1 概述

ElasticSearch是一个搜索和分析引擎：

• 全文检索功能比MySQL强大
• 性能更好，因为ES将数据存到内存，且天然支持分布式，不必担心内存不够的问题

只保存检索页面需要展示的信息——sku的基本信息；
spu 在 ElasticSearch 中的存储模型的抉择：

• 如果每个sku都存储 同一个spu的规格参数（attrs），会有冗余存储
• 将 规格参数 单独建立索引会出现检索时出现大量数据传输的问题，会阻塞网络

因我们选用第一种存储模型——以空间换时间

1.2 商品上架

步骤①：向ES添加商品属性映射

PUT product
{
    "mappings":{
        "properties": {
            "skuId":{
                "type": "long"
            },
            "spuId":{
                "type": "keyword"
            },
            "skuTitle": {
                "type": "text",
                "analyzer": "ik_smart"
            },
            "skuPrice": {
                "type": "keyword"
            },
            "skuImg":{
                "type": "keyword",
                "index": false,
                "doc_values": false
            },
            "saleCount":{
                "type":"long"
            },
            "hasStock": {
                "type": "boolean"
            },
            "hotScore": {
                "type": "long"
            },
            "brandId": {
                "type": "long"
            },
            "catalogId": {
                "type": "long"
            },
            "brandName": {
                "type": "keyword",
                "index": false,
                "doc_values": false
            },
            "brandImg":{
                "type": "keyword",
                 "index": false,
                "doc_values": false
            },
            "catalogName": {
                "type": "keyword",
                "index": false,
                "doc_values": false
            },
            "attrs": {
                "type": "nested",
                "properties": {
                    "attrId": {
                        "type": "long"
                    },
                    "attrName": {
                        "type": "keyword",
                        "index": false,
                        "doc_values": false
                    },
                    "attrValue": {
                        "type": "keyword"
                    }
                }
            }
        }
    }
}

步骤②：商品上架接口实现
商品上架需要在 ES 中保存 spu 信息并更新 spu 的状态信息，由于SpuInfoEntity与索引的数据模型并不对应，所以我们要建立专门的 TO 进行数据传输

package com.example.common.to.es;

import lombok.Data;
import java.math.BigDecimal;
import java.util.List;
@Data
public class SkuEsModel {
    private Long skuId;
    private Long spuId;
    private String skuTitle;
    private BigDecimal skuPrice;
    private String skuImg;
    private Long saleCount;
    private boolean hasStock;
    private Long hotScore;
    private Long brandId;
    private Long catalogId;
    private String brandName;
    private String brandImg;
    private String catalogName;
    private List<Attr> attrs;

    @Data
    public static class Attr{
        private Long attrId;
        private String attrName;
        private String attrValue;
    }
}

每个spu对应的各个sku的规格参数相同，因此我们将查询规格参数提前，只查询一次

Product微服务下：

	@PostMapping("/{spuId}/up")
    public R spuUp(@PathVariable(value = "spuId") Long spuId){
        spuInfoService.upSpuForSearch(spuId);
        return R.ok();
    }

	public void upSpuForSearch(Long spuId) {
        //1、查出当前spuId对应的所有sku信息,品牌的名字
        List<SkuInfoEntity> skuInfoEntities=skuInfoService.getSkusBySpuId(spuId);
        //4、查出当前sku的所有可以被用来检索的规格属性
        List<ProductAttrValueEntity> productAttrValueEntities = productAttrValueService.list(new QueryWrapper<ProductAttrValueEntity>().eq("spu_id", spuId));
        List<Long> attrIds = productAttrValueEntities.stream().map(attr -> {
            return attr.getAttrId();
        }).collect(Collectors.toList());
        List<Long> searchIds=attrService.selectSearchAttrIds(attrIds);
        Set<Long> ids = new HashSet<>(searchIds);
        List<SkuEsModel.Attr> searchAttrs = productAttrValueEntities.stream().filter(entity -> {
            return ids.contains(entity.getAttrId());
        }).map(entity -> {
            SkuEsModel.Attr attr = new SkuEsModel.Attr();
            BeanUtils.copyProperties(entity, attr);
            return attr;
        }).collect(Collectors.toList());

        //1、发送远程调用，库存系统查询是否有库存
        Map<Long, Boolean> stockMap = null;
        try {
            List<Long> longList = skuInfoEntities.stream().map(SkuInfoEntity::getSkuId).collect(Collectors.toList());
            List<SkuHasStockVo> skuHasStocks = wareFeignService.getSkuHasStocks(longList);
            stockMap = skuHasStocks.stream().collect(Collectors.toMap(SkuHasStockVo::getSkuId, SkuHasStockVo::getHasStock));
        }catch (Exception e){
            log.error("远程调用库存服务失败,原因{}",e);
        }

        //2、封装每个sku的信息
        Map<Long, Boolean> finalStockMap = stockMap;
        List<SkuEsModel> skuEsModels = skuInfoEntities.stream().map(sku -> {
            SkuEsModel skuEsModel = new SkuEsModel();
            BeanUtils.copyProperties(sku, skuEsModel);
            skuEsModel.setSkuPrice(sku.getPrice());
            skuEsModel.setSkuImg(sku.getSkuDefaultImg());
            //TODO 2、热度评分。0
            skuEsModel.setHotScore(0L);
            //TODO 3、查询品牌和分类的名字信息
            BrandEntity brandEntity = brandService.getById(sku.getBrandId());
            skuEsModel.setBrandName(brandEntity.getName());
            skuEsModel.setBrandImg(brandEntity.getLogo());
            CategoryEntity categoryEntity = categoryService.getById(sku.getCatalogId());
            skuEsModel.setCatalogName(categoryEntity.getName());
            //设置可搜索属性
            skuEsModel.setAttrs(searchAttrs);
            //设置是否有库存
            skuEsModel.setHasStock(finalStockMap==null?false:finalStockMap.get(sku.getSkuId()));
            return skuEsModel;
        }).collect(Collectors.toList());

        //TODO 5、将数据发给 ES 进行保存：kedamall-search
        R r = searchFeignService.productStatusUp(skuEsModels);
        if (r.getCode()==0){
            this.baseMapper.upSpuStatus(spuId, ProductConstant.ProductStatusEnum.SPU_UP.getCode());
        }else {
            log.error("商品远程ES保存失败");
        }
    }

Search微服务下：

	//上架商品
    @PostMapping("/product")
    public R productStatusUp(@RequestBody List<SkuEsModel> skuEsModels){
        boolean b = false;
        try {
            b = productSaveService.productStatusUp(skuEsModels);
        } catch (IOException e) {
            log.error("ElasticSaveController商品上架错误：{}",e);
            return R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(),
                    BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg());
        }
        if(!b){
            return R.ok();
        } else return R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(),
                BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg());
    }

	@Autowired
    RestHighLevelClient restHighLevelClient;

    @Override
    public boolean productStatusUp(List<SkuEsModel> skuEsModels) throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        for (SkuEsModel model : skuEsModels) {
            IndexRequest indexRequest = new IndexRequest("product");
            indexRequest.id(model.getSkuId().toString());
            String s = JSON.toJSONString(model);
            indexRequest.source(s, XContentType.JSON);
            bulkRequest.add(indexRequest);
        }
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, KedamallElasticSearchConfig.COMMON_OPTIONS);
        //TODO 如果批量出错
        boolean b = bulk.hasFailures();
        if(b){
            log.error("商品上架错误");
        }
        return b;
    }

1.3 商品检索

① 检索条件：

• 全文检索：skuTitle→ keyword

• 排序：skuPrice（价格）

• 过滤：hasStock、skuPrice区间、brandId、catalog3Id、attrs

• 聚合：attrs

完整查询参数： keyword=华为&sort=saleCount_desc/asc&hasStock=0/1&skuPrice=400_1900&brandId=1&catalog3Id=1&attrs=1_3G:4G:5G&attrs=2_骁龙845&attrs=4_高清屏

② 封装页面传递过来的检索条件

/**
 * 封装页面所有可能传递过来的查询条件
 */
@Data
public class SearchParam {
    private String keyword;

    //品牌id,可以多选
    private List<Long> brandId;

    //三级分类id
    private Long catalog3Id;

    //排序条件：sort=price/salecount/hotscore_desc/asc
    private String sort;

    //是否显示有货
    private Integer hasStock;

    //价格区间查询
    private String skuPrice;

    //按照属性进行筛选
    private List<String> attrs;

    //页码
    private Integer pageNum = 1;

    //原生的所有查询条件
    private String _queryString;

}

③ 创建Vo作为返回给页面的数据

/**
 * 查询结果返回
 */
@Data
public class SearchResult {
    //查询到的所有商品信息
    private List<SkuEsModel> product;

    //当前页码
    private Integer pageNum;

    //总记录数
    private Long total;

    //总页码
    private Integer totalPages;
	//页码遍历结果集(分页)
    private List<Integer> pageNavs;

    //当前查询到的结果，所有涉及到的品牌
    private List<BrandVo> brands;

    //当前查询到的结果，所有涉及到的所有属性
    private List<AttrVo> attrs;

    //当前查询到的结果，所有涉及到的所有分类
    private List<CatalogVo> catalogs;

    //===========================以上是返回给页面的所有信息============================//

    /* 面包屑导航数据 */
    private List<NavVo> navs;

    @Data
    public static class NavVo {
        private String navName;
        private String navValue;
        private String link;
    }

    @Data
    @AllArgsConstructor
    public static class BrandVo {

        private Long brandId;

        private String brandName;

        private String brandImg;
    }

    @Data
    @AllArgsConstructor
    public static class AttrVo {

        private Long attrId;

        private String attrName;

        private List<String> attrValue;
    }

    @Data
    @AllArgsConstructor
    public static class CatalogVo {

        private Long catalogId;

        private String catalogName;
    }
}

④ Controller

	/**
     * 自动将页面提交过来的所有请求查询参数自动封装成指定的对象
     */
    @GetMapping("/list.html")
    public String listPage(SearchParam param, Model model){
        //1、根据传递来的页面参数，去 ES中检索商品
        SearchResult result = mallSearchService.search(param);
        model.addAttribute("result",result);
        return "list";
    }

⑤ Service

@Override
public SearchResult search(SearchParam param) {
    // 1、动态构建出查询需要的 DSL语句
    SearchResult result = null;

    //1、准备检索请求
    SearchRequest searchRequest = buildSearchRequest(param);
    try {
        // 2、执行检索请求
        SearchResponse response = client.search(searchRequest, kedamallElasticsearchConfig.COMMON_OPTIONS);

        // 3、分析响应数据封装成我们需要的格式
        result = buildSearchResult(response, param);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}

	/**
     * 准备检索请求
     * #模糊匹配、过滤（按照属性、分类、品牌、价格区间、库存）、排序、分页、高亮、聚合分析
     */
    private SearchRequest buildSearchRequest(SearchParam param) {

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); //构建DSL语句
        /**
         * 模糊匹配 过滤（按照属性、分类、品牌、价格区间、库存）
         */
        // 1、构建bool - query
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        
        // 1.1 must - 模糊匹配
        if (!StringUtils.isEmpty(param.getKeyword())) {
            boolQuery.must(QueryBuilders.matchQuery("skuTitle", param.getKeyword()));
        }
        
        // 1.2 bool - filter 按照三级分类id来查询
        if (param.getCatalog3Id() != null) {
            boolQuery.filter(QueryBuilders.termQuery("catalogId", param.getCatalog3Id()));
        }
        // 1.3 bool - filter 按照品牌id来查询
        if (param.getBrandId() != null && param.getBrandId().size() > 0) {
            boolQuery.filter(QueryBuilders.termsQuery("brandId", param.getBrandId()));
        }
        // 1.4 bool - filter 按照所有指定的属性来进行查询 *******不理解这个attr=1_5寸:8寸这样的设计
        if (param.getAttrs() != null && param.getAttrs().size() > 0) {
            for (String attr : param.getAttrs()) {
                // attr=1_5寸:8寸&attrs=2_16G:8G
                BoolQueryBuilder nestedboolQuery = QueryBuilders.boolQuery();
                String[] s = attr.split("_");
                String attrId = s[0];// 检索的属性id
                String[] attrValues = s[1].split(":");
                nestedboolQuery.must(QueryBuilders.termQuery("attrs.attrId", attrId));
                nestedboolQuery.must(QueryBuilders.termsQuery("attrs.attrValue", attrValues));
                // 每一个必须都生成一个nested查询
                NestedQueryBuilder nestedQuery = QueryBuilders.nestedQuery("attrs", nestedboolQuery, ScoreMode.None);
                boolQuery.filter(nestedQuery);
            }
        }
        // 1.5 bool - filter 按照库存是否存在
        boolQuery.filter(QueryBuilders.termQuery("hasStock", param.getHasStock() == 1 ? true : false));
        // 1.6 bool - filter 按照价格区间
        /**
         * 1_500/_500/500_
         */
        if (!StringUtils.isEmpty(param.getSkuPrice())) {
            RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("skuPrice");
            String[] s = param.getSkuPrice().split("_");
            if (s.length == 2) {
                // 区间
                rangeQuery.gte(s[0]).lte(s[1]);
            } else if (s.length == 1) {
                if (param.getSkuPrice().startsWith("_")) {
                    rangeQuery.lte(s[0]);
                }
                if (param.getSkuPrice().endsWith("_")) {
                    rangeQuery.gte(s[0]);
                }
            }
            boolQuery.filter(rangeQuery);
        }
        //把以前所有条件都拿来进行封装
        sourceBuilder.query(boolQuery);

        /**
         * 排序、分页、高亮
         */
        //2.1、排序
        if (!StringUtils.isEmpty(param.getSort())) {
            String sort = param.getSort();
            //sort=hotScore_asc/desc
            String[] s = sort.split("_");
            SortOrder order = s[1].equalsIgnoreCase("asc") ? SortOrder.ASC : SortOrder.DESC;
            sourceBuilder.sort(s[0], order);
        }
        //2.2 分页 pageSize:5
        // pageNum:1 from 0 size:5 [0,1,2,3,4]
        // pageNum:2 from 5 size:5
        // from (pageNum - 1)*size
        sourceBuilder.from((param.getPageNum() - 1) * EsConstant.PRODUCT_PAGESIZE);
        sourceBuilder.size(EsConstant.PRODUCT_PAGESIZE);
        //2.3、高亮
        if (!StringUtils.isEmpty(param.getKeyword())) {
            HighlightBuilder builder = new HighlightBuilder();
            builder.field("skuTitle");
            builder.preTags("<b style='color:red'>");
            builder.postTags("</b>");
            sourceBuilder.highlighter(builder);
        }
        /**
         * 聚合分析
         */
        //1、品牌聚合
        TermsAggregationBuilder brand_agg = AggregationBuilders.terms("brand_agg");
        brand_agg.field("brandId").size(50);
        //品牌聚合的子聚合
        brand_agg.subAggregation(AggregationBuilders.terms("brand_name_agg").field("brandName").size(2));
        brand_agg.subAggregation(AggregationBuilders.terms("brand_img_agg").field("brandImg").size(2));
        // TODO 1、聚合brand
        sourceBuilder.aggregation(brand_agg);
        //2、分类聚合
        TermsAggregationBuilder catalog_agg = AggregationBuilders.terms("catalog_agg").field("catalogId").size(20);
        catalog_agg.subAggregation(AggregationBuilders.terms("catalog_name_agg").field("catalogName").size(1));
        // TODO 2、聚合catalog
        sourceBuilder.aggregation(catalog_agg);
        //3、属性聚合 attr_agg
        NestedAggregationBuilder attr_agg = AggregationBuilders.nested("attr_agg", "attrs");
        // 聚合出当前所有的attrId
        TermsAggregationBuilder attr_id_agg = AggregationBuilders.terms("attr_id_agg").field("attrs.attrId");
        //聚合分析出当前attr_id对应的名字
        attr_id_agg.subAggregation(AggregationBuilders.terms("attr_name_agg").field("attrs.attrName").size(1));
        // 聚合分析出当前attr_id对应的可能的属性值attractValue
        attr_id_agg.subAggregation(AggregationBuilders.terms("attr_value_agg").field("attrs.attrValue").size(50));
        attr_agg.subAggregation(attr_id_agg);
        // TODO 3、聚合attr
        sourceBuilder.aggregation(attr_agg);


        String s = sourceBuilder.toString();
        System.out.println("构建的DSL:" + s);
        SearchRequest searchRequest = new SearchRequest(new String[]{EsConstant.PRODUCT_INDEX}, sourceBuilder);
        return searchRequest;
    }

/**
 * 构建结果数据
 */
private SearchResult buildSearchResult(SearchResponse response, SearchParam param) {

    SearchResult result = new SearchResult();
    SearchHits hits = response.getHits();
    List<SkuEsModel> esModels = new ArrayList<>();
    if (hits.getHits() != null && hits.getHits().length > 0) {
        for (SearchHit hit : hits.getHits()) {
            String sourceAsString = hit.getSourceAsString();
            SkuEsModel skuEsModel = JSON.parseObject(sourceAsString, SkuEsModel.class);
            if (!StringUtils.isEmpty(param.getKeyword())) {
                HighlightField skuTitle = hit.getHighlightFields().get("skuTitle");
                String string = skuTitle.getFragments()[0].string();
                skuEsModel.setSkuTitle(string);
            }
            esModels.add(skuEsModel);
        }
    }
    //1、返回所有查询到的商品
    result.setProducts(esModels);
    //2、当前所有商品设计到的所有属性信息
    List<SearchResult.AttrVo> attrVos = new ArrayList<>();
    ParsedNested attr_agg = response.getAggregations().get("attr_agg");
    ParsedLongTerms attr_id_agg = attr_agg.getAggregations().get("attr_id_agg");
    for (Terms.Bucket bucket : attr_id_agg.getBuckets()) {
        SearchResult.AttrVo attrVo = new SearchResult.AttrVo();
        // 1、得到属性的id
        Long attrId = bucket.getKeyAsNumber().longValue();
        // 2、得到属性的名字
        String attrName = ((ParsedStringTerms) bucket.getAggregations().get("attr_name_agg")).getBuckets().get(0).getKeyAsString();
        // 3、得到属性的所有值
        List<String> attrValue = ((ParsedStringTerms) bucket.getAggregations().get("attr_value_agg")).getBuckets().stream().map(item -> {
            String keyAsString = item.getKeyAsString();
            return keyAsString;
        }).collect(Collectors.toList());
        attrVo.setAttrId(attrId);
        attrVo.setAttrName(attrName);
        attrVo.setAttrValue(attrValue);
        attrVos.add(attrVo);
    }
    result.setAttrs(attrVos);
    //3、当前所有商品的分类信息
    ParsedLongTerms Catalog_agg = response.getAggregations().get("catalog_agg");
    List<SearchResult.CatalogVo> catalogVos = new ArrayList<>();
    List<? extends Terms.Bucket> buckets = Catalog_agg.getBuckets();
    for (Terms.Bucket bucket : buckets) {
        SearchResult.CatalogVo catalogVo = new SearchResult.CatalogVo();
        // 得到分类id
        String keyAsString = bucket.getKeyAsString();
        catalogVo.setCatalogId(Long.parseLong(keyAsString));
        // 得到分类名
        ParsedStringTerms catalog_name_agg = bucket.getAggregations().get("catalog_name_agg");
        String catalog_name = catalog_name_agg.getBuckets().get(0).getKeyAsString();
        catalogVo.setCatalogName(catalog_name);
        catalogVos.add(catalogVo);
    }
    result.setCatalogs(catalogVos);

    //4、当前所有商品的品牌信息
    List<SearchResult.BrandVo> brandVos = new ArrayList<>();
    ParsedLongTerms brand_agg = response.getAggregations().get("brand_agg");
    for (Terms.Bucket bucket : brand_agg.getBuckets()) {
        SearchResult.BrandVo brandVo = new SearchResult.BrandVo();
        // 1、得到品牌的id
        long brandId = bucket.getKeyAsNumber().longValue();
        // 2、得到品牌的图片
        String brandImg = ((ParsedStringTerms) bucket.getAggregations().get("brand_img_agg")).getBuckets().get(0).getKeyAsString();
        // 3、得到品牌的姓名
        String brandname = ((ParsedStringTerms) bucket.getAggregations().get("brand_name_agg")).getBuckets().get(0).getKeyAsString();
        brandVo.setBrandName(brandname);
        brandVo.setBrandId(brandId);
        brandVo.setBrandImg(brandImg);
        brandVos.add(brandVo);
    }
    result.setBrands(brandVos);
    //5、分页信息 - 总记录数
    long total = hits.getTotalHits().value;
    result.setTotal(total);
    //6、分页信息 - 页码
    result.setPageNum(param.getPageNum());
    //7、分页信息 - 总页码
    int totalPages = (int) total % EsConstant.PRODUCT_PAGESIZE == 0 ? (int) total / EsConstant.PRODUCT_PAGESIZE : ((int) total / EsConstant.PRODUCT_PAGESIZE + 1);
    result.setTotalPages(totalPages);

    List<Integer> pageNavs = new ArrayList<>();
    for(int i = 1; i <= totalPages; i++) {
        pageNavs.add(i);
    }
    result.setPageNavs(pageNavs);
    return result;
}

2. 搭建域名访问环境

2.1 正向代理、反向代理

• 反向代理——访问科大商城的时候，我们有后台服务集群（内网部署，而不暴露给外界，避免引起攻击），于是我们在后台服务集群前置一个服务器（反向代理，具有公网 IP，nginx）。当访问 nginx 的时候，nginx 会转给服务集群。反向代理
  反向代理隐藏了真实的服务端；当我们请求 Nginx 的时候，就像拨打10086一样，背后可能有成千上万台服务器为我们服务，但具体是哪一台，你不知道，也不需要知道，你只需要知道反向代理服务器是谁就好了，Nginx 就是我们的反向代理服务器，反向代理服务器会帮我们把请求转发到真实的服务器那里去。
• 正向代理——比如要访问 youtube,但是不能直接访问，只能先找个tizi软件，通过tizi软件才能访问youtube。这个tizi软件就叫做正向代理。

2.2 遇到的问题

问题：自己的腾讯云服务器ping不通学校宿舍的电脑

解决：frp 和 nginx 搭建一个内网穿透服务器（穿透校园网）

3. 性能压测与优化

3.1 jvisualvm

用于检测 java 应用资源占用和垃圾回收的情况，cmd 输入 jvisualvm 打开，用于监控内存泄漏、跟踪垃圾回收、执行时内存、cpu分析、线程分析…

① 可查看线程状态：

• 运行：正在运行的
• 休眠：sleep
• 等待：wait
• 驻留：线程池中的空闲线程
• 监视：阻塞的线程（正在等待锁）

3.2 Jmeter

下载后bin目录 jmeter.bat 打开

① 中间件越多，性能损失越大，大多都损失在了网络交互

② 性能测试主要关注如下指标：

• 吞吐量：每秒钟 系统能够处理的请求数，越大表示系统越能支持高并发；
• 响应时间：服务处理一个请求的耗时，越短说明接口性能越好；
• 错误率：一批请求中结果出错的请求所占比例；

3.3 Nginx动静分离

由于动态资源和静态资源目前都处于服务端，所以为了减轻服务器压力，我们将js、css、img 等静态资源放置在 Nginx 端，以减轻服务器压力。

在 nginx 的 html 文件夹创建 staic 文件夹，并将 index/css 等静态资源全部上传到该文件夹中

步骤①：修改index.html的静态资源路径，使其全部带有static前缀src="/static/index/img/img_09.png"

步骤②：修改nginx的配置文件/mydata/nginx/conf/conf.d/kedamall.conf，若遇到有/static为前缀的请求，转发至 html 文件夹

4. 缓存与分布式锁

4.1 缓存

① 为了系统性能的提升，我们一般都会将部分数据放入缓存中，加速访问

哪些数据适合放入缓存？

• 即时性、数据一致性要求不高的
• 访问量大且更新频率不高的数据（读多、写少）

② 本地缓存面临问题
当有多个服务存在时，每个服务的缓存仅能够为本服务使用，这样每个服务都要查询一次数据库，并且当数据更新时只会更新单个服务的缓存数据，就会造成数据不一致的问题；

解决：所有的服务都到同一个 redis 进行获取数据，就可以避免这个问题

③ 高并发下缓存失效问题

• 缓存穿透
  指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，我们没有将这次查询的 null 写入缓存。这将导致这个不存在的数据每次请求都要到数据库查询，也就失去了缓存的意义。
  风险： 利用不存在的数据进行攻击，数据库瞬时压力增大，最终导致崩溃
  解决： null 结果缓存，并加入短暂过期时间

• 缓存雪崩
  指在我们在缓冲中放了很多数据，并设置了相同的过期时间。这就导致缓存在某一时刻，数据大面积失效，这时大并发的请求将被全部转发到数据库，数据库瞬时压力过重，导致雪崩。
  解决： 原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

• 缓存击穿
  对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“高频热点”的数据。如果这个key在大量请求同时进来前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。
  解决： 加锁。大量并发时，只放一个去查数据库，其他人等待，查到以后释放锁，其他人获取到锁，先查缓存，就会有数据，就不用去数据库。

注：内存泄漏及解决办法：进行压力测试时后期后出现堆外内存溢出OutOfDirectMemoryError

• 产生原因：

  1. Spring Boot 2.0以后默认使用 Lettuce 操作 Redis 客户端

  2. Lettuce 的 bug 导致 Netty 堆外内存溢出

• 解决方案：

  1. 升级lettuce客户端
  2. 切换使用jedis

④ 本地锁（解决缓存击穿）

⑤ 分布式锁的演进（解决缓存击穿）

• 当前实例this作为锁，虽然在每个商品服务中是单实例的，只能锁住某个商品服务它自己。这会造成最多有商品服务个数的线程去查数据库。
• 若要在分布式下锁住所有的服务，只放一个进来，就需要用到分布式锁（缺点是影响性能）

原理：所有服务都去一个公共的地方抢锁

演进一：

	public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "111");
        //获取到锁，执行业务
        if (lock) {
            Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
            //删除锁，如果在此之前报错或宕机会造成死锁
            stringRedisTemplate.delete("lock");
            return categoriesDb;
        }else {
            //加锁失败，自旋的方式
            return getCatalogJsonDbWithRedisLock();
        }
    }

演进二：设置过期时间

	public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
        Boolean lock = redisTemplate.opsForValue().setIfAbsent()
        if (lock) {
            // 加锁成功..执行业务
            // 设置过期时间
            redisTemplate.expire("lock",30,TimeUnit.SECONDS);
            Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDB();
            redisTemplate.delete("lock"); // 删除锁
            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠100ms重试
            return getCatelogJsonFromDbWithRedisLock();
        }
    }

演进三：防止锁过期——占锁时指定UUID；但正好判断通过，锁又恰好过期，误删别人的锁

	public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
        String uuid = UUID.randomUUID().toString();
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
     	//为当前锁设置唯一的uuid，只有当uuid相同时才会进行删除锁的操作
        Boolean lock = ops.setIfAbsent("lock", uuid,5, TimeUnit.SECONDS);
        if (lock) {
            Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
            //网络交互很费时！！！！
            String lockValue = ops.get("lock");
            if (lockValue.equals(uuid)) {
                //我删我自己的锁
                stringRedisTemplate.delete("lock");
            }
            return categoriesDb;
        }else {
            return getCatalogJsonDbWithRedisLock();
        }
    }

问题： 如果判断是当前值，正要删除锁的时候，锁已经过期，别人已经设置到了新的值（加了新锁）。那么我们删除的是别人的锁

解决： 删除锁必须保证原子性。使用 redis + Lua 脚本完成

演进四-最终形态

	public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
        String uuid = UUID.randomUUID().toString();
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        Boolean lock = ops.setIfAbsent("lock", uuid,5, TimeUnit.SECONDS);
        if (lock) {
        	//业务执行时间超长，则必须考虑锁的自动续期
            Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
            String lockValue = ops.get("lock");
            String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
                    "    return redis.call(\"del\",KEYS[1])\n" +
                    "else\n" +
                    "    return 0\n" +
                    "end";
            stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), lockValue);
            return categoriesDb;
        }else {
            return getCatalogJsonDbWithRedisLock();
        }
    }

4.2 分布式锁——Redisson

官网文档上详细说明了：不推荐使用 setnx来实现分布式锁，应该参考 The Redlock algorithm 的实现

在Java 语言环境下使用 Redisson

Redisson - Lock 锁测试 & Redisson - Lock 看门狗原理 & Redisson 如何解决死锁

lock.lock()是阻塞式等待。与之相对的是自旋式等待，即return的时候自己把自己再调一遍。

@RequestMapping("/hello")
@ResponseBody
public String hello(){
    // 1、获取一把可重入锁，只要锁得名字一样，就是同一把锁
    RLock lock = redission.getLock("my-lock");

    // 2、加锁
    lock.lock(); // 阻塞式等待，默认加的锁都是30s时间
    // 1、锁的自动续期，如果业务超长，运行期间自动给锁续上新的30s，不用担心业务时间长而导致锁自动过期后被删掉
    // 2、加锁的业务只要运行完成，就不会给当前锁续期
    //不会出现死锁问题：即使不手动解锁，锁默认会在30s以后自动删除
	
	// 3、加锁
    lock.lock(10, TimeUnit.SECONDS); //10s 后自动删除
    //问题：lock.lock(10, TimeUnit.SECONDS) 在锁时间到了后，不会自动续期
    
    //原理
    // 1、如果我们传递了锁的超时时间，就发送给 redis 执行脚本，进行占锁，默认超时就是我们指定的时间
    // 2、如果我们未指定锁的超时时间，就是用 LockWatchchdogTimeout = 30 * 1000，即看门狗的默认时间
    	// 2.1、只要占锁成功，就会启动一个定时任务 TimeTask，【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10s就自动续期
    	// 2.2、每 internalLockLeaseTime【看门狗时间】/3 = 10s 调用一次（每10s续期一次）

    //推荐使用： lock.lock(10, TimeUnit.SECONDS)
    // 明确给出超时时间，省掉整个续期操作，手动解锁
    try {
        System.out.println("加锁成功，执行业务..." + Thread.currentThread().getId());
        Thread.sleep(3000);
    } catch (Exception e) {} 
      finally {
        // 解锁 将设解锁代码没有运行，reidsson会不会出现死锁 
        lock.unlock();
    }
    return "hello";
}

Reidsson - 读写锁

	/**
     * 保证一定能读取到最新数据
     * 修改期间，写锁是一个排他锁（互斥锁，独享锁），读锁是一个共享锁
     * 写锁没释放读锁就必须等待
     * 只要有写的存在，都必须等待
     */
    @RequestMapping("/write")
    @ResponseBody
    public String writeValue() {
        RReadWriteLock lock = redission.getReadWriteLock("rw_lock");
        RLock rLock = lock.writeLock();
        try {
            // 修改数据加写锁，读数据加读锁
            rLock.lock();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rLock.unlock();
        }
        return s;
    }

    @RequestMapping("/read")
    @ResponseBody
    public String readValue() {
        RReadWriteLock lock = redission.getReadWriteLock("rw_lock");
        RLock rLock = lock.readLock();
        
        try {
        	rLock.lock();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rLock.unlock(); 
        }
        return "";
    }

Redisson - 闭锁测试

/**
 * 放假锁门
 * 1班没人了
 * 5个班级走完，我们可以锁们了
 * @return
 */
@GetMapping("/lockDoor")
@ResponseBody
public String lockDoor() throws InterruptedException {
    RCountDownLatch door = redission.getCountDownLatch("door");
    door.trySetCount(5);
    door.await();//等待闭锁都完成

    return "所有班级的人都走了，放假了！....";
}
@GetMapping("/gogogo/{id}")
@ResponseBody
public String gogogo(@PathVariable("id") Long id) {
    RCountDownLatch door = redission.getCountDownLatch("door");
    door.countDown();// 计数器减一

    return id + "班的人走了.....";
}

Redisson - 信号量

/**
 * 车库停车
 * 3车位
 * @return
 */
@GetMapping("/park")
@ResponseBody
public String park() throws InterruptedException {
    RSemaphore park = redission.getSemaphore("park");

	//获取一个信号，获取一个值，占用一个车位
	//也是一个阻塞方法
    boolean b = park.tryAcquire();

    return "ok=" + b;
}

@GetMapping("/go")
@ResponseBody
public String go() {
    RSemaphore park = redission.getSemaphore("park");
    park.release(); //释放一个车位

    return "ok";
}

解决缓存击穿的 Redisson 版本

	public Map<String, List<Catelog2VO>> getCatalogJsonFromDBWithRedissonLock() {
		//锁的名字一样，得到的锁就是一样的
		//锁的粒度，越细越快
        RLock lock = redisson.getLock("catalogJson-lock");

        lock.lock();
        Map<String, List<Catelog2Vo>> dataFromDB;
        try {
            dataFromDB = getDataFromDB();
        } finally {
            lock.unlock();
        }
        return dataFromDB;
    }

4.3 缓存数据一致性

双写模式

失效模式

主动更新：删掉缓存，下次查的时候就会再去查数据库

最终解决方案

4.4 Spring Cache

简介

• Spring 从3.1开始定义了 org.springframework.cache.Cache 和 org.sprngframework.cache.CacheManager 接口睐统一不同的缓存技术
• 并支持使用 JCache（JSR-107）注解简化我们的开发
• Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合 Cache 接口下 Spring 提供了各种 XXXCache的实现，如 RedisCache、EhCache,ConcrrentMapCache等等，
• 每次调用需要缓存功能实现方法的时候，Spring 会检查检查指定参数的马努表犯法是否已经被调用过，如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户，下次直接调用从缓存中获取
• 使用 Sprng 缓存抽象时我们需要关注的点有以下两点
  • 1、确定方法需要被缓存以及他们的的缓存策略
  • 2、从缓存中读取之前缓存存储的数据

原理：
CacheAutoConfiguration导入RedisCacheConfiguration，RedisCacheConfiguration自动配置了RedisCacheManager（用于初始化缓存，每个缓存决定使用什么配置）；如果RedisCacheConfiguration存在自定义配置则使用之，否则使用默认配置

修改缓存配置方法：
在容器中添加一个RedisCacheConfiguration

注解的使用、缓存穿透问题的解决

	/**
     * 1、每一个需要缓存的数据我们都需要指定放到那个名字的缓存
     * 【缓存分区的划分【按照业务类型划分】】
     * 
     * 2、@Cacheable({"category"})
     *      代表当前方法的结果需要缓存，如果缓存中有，方法不调用
     *      如果缓存中没有，则会调用方法并将方法结果放入缓存。
     * 
     * 3、默认行为:
     *      1、如果缓存中有，方法不用调用
     *      2、key默自动生成，缓存的名字:SimpleKey[](自动生成的key值)
     *      3、缓存中value的值，默认使用jdk序列化，将序列化后的数据存到redis
     *      3、默认的过期时间，-1
     *
     * 4、自定义操作
     *      1、指定缓存使用的key      key属性指定，接收一个SpEl
     *      2、指定缓存数据的存活时间  配置文件中修改ttl
     *      3、将数据保存为json格式
     * 
     Spring-Cache的不足：
 	 *      1、读模式：
 	 *          缓存穿透:查询一个null数据，解决 缓存空数据：配置文件Spring-cache-null-values=true
	 *          缓存击穿:大量并发进来同时查询一个正好过期的数据，解决:加锁 ？ 默认是无加锁，故无法解决（可通过设置sync = true，加一个本地锁）
	 *          缓存雪崩:大量的 key同时过期，解决：加上随机时间，配置文件Spring-cache-redis-time-to-live
	 * 
	 *       2、写模式：（缓存与数据库库不一致）
	 *          1、读写加锁
	 *          2、引入canal，感知到 MySQL的更新去更新数据库
	 *          3、读多写多，直接去数据库查询就行
	 *
	 *    总结：
	 *      常规数据（读多写少，即时性，一致性要求不高的数据）完全可以使用
	 *      SpringCache 写模式（ 只要缓存数据有过期时间就足够了）
	 */
    //读模式下使用缓存
    @Cacheable(value = {"category"},key = "#root.method.name",sync = true)
    @Override
    public List<CategoryEntity> getLevel1Categorys() {
        // parent_cid为 0则是一级目录
        List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
        return categoryEntities;
    }

@CacheEvict实现缓存失效模式

	/**
     * 级联更新所有的关联数据
     * @CacheEvict 失效模式
     * 1、同时进行多种缓存操作 @Caching
     * 2、指定删除某个分区下的所有数据 @CacheEvict(value = {"category"},allEntries = true)
     * 3、存储同一类型的数据，都可以指定成同一分区，分区名默认就是缓存的前缀
     *
     * @param category
     */

	//写模式下使用缓存
	//修改了某处菜单，需要删除两个地方的缓存
    @Caching(evict = {
            @CacheEvict(value = {"category"},key = "'getLevel1Categorys'"),
            @CacheEvict(value = {"category"},key = "'getCatelogJson'")
    })
	//  @CacheEvict(value = {"category"},allEntries = true)
	//  value——区域
    @Transactional
    @Override
    public void updateCascate(CategoryEntity category) {
        // 更新自己表对象
        this.updateById(category);
        // 更新关联表对象
        categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());
    }

自定义配置

@EnableConfigurationProperties(CacheProperties.class)
@EnableCaching
@Configuration
public class MyCacheConfig {

    /**
     * 配置文件中的东西没有用上
     * 1、原来的配置吻技安绑定的配置类是这样子的
     *      @ConfigurationProperties(prefix = "Spring.cache")
     * 2、要让他生效
     *      @EnableConfigurationProperties(CacheProperties.class)
     * @param cacheProperties
     * @return
     */
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // 设置key的序列化
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        // 设置value序列化 ->JackSon
        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;
    }

}

Spring:
  cache:
    type: redis
    redis:
      time-to-live: 3600000           # 过期时间
      key-prefix: CACHE_              # 如果指定了前缀，就使用指定的前缀，如果没有就默认使用缓存的名字作为前缀
      use-key-prefix: true            # 是否使用写入redis前缀
      cache-null-values: true         # 是否允许缓存空值，解决缓存穿透问题

5. 异步 & 线程池

5.1 线程回顾

5.1.1 初始化线程的 4 种方式

① 继承 Thread

② 实现 Runnable

③ 实现 Callable 接口 + FutureTask（可以拿到返回结果，可以处理异常）

④ 线程池

方式一 和 方式二：主进程无法获取线程的运算结果，不适合当前场景

方式三：主进程可以获取当前线程的运算结果，但是不利于控制服务器种的线程资源，可以导致服务器资源耗尽

方式四：通过如下两种方式初始化线程池

Executors.newFixedThreadPool(3);
//或
new ThreadPollExecutor(corePoolSize,maximumPoolSize,keepAliveTime,TimeUnit,unit,workQueue,threadFactory,handler);

5.1.2 线程池的 7 大参数

运行流程：

1、线程池创建，准备好 core 数量 的核心线程，准备接受任务

2、新的任务进来，用 core 准备好的空闲线程执行

• core 满了，就将再进来的任务放入阻塞队列中，空闲的 core 就会自己去阻塞队列获取任务执行
• 阻塞队列也满了，就直接开新线程去执行，最大只能开到 max 指定的数量
• max 都执行好了，Max-core 数量空闲的线程会在 keepAliveTime 指定的时间后自动销毁，终保持到 core 大小
• 如果线程数开到了 max 数量，还有新的任务进来，就会使用 reject 指定的拒绝策略进行处理

3、所有的线程创建都是由指定的 factory 创建的

5.1.4 开发中为什么使用线程池

• 通过重复利用已创建好的线程，降低线程的创建和销毁带来的性能损耗
• 当线程池中的线程没有超过线程池的最大上限时，若有线程处于空闲状态，则当任务来时无需创建新的线程就能执行
• 线程池会根据当前系统的特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销，无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

5.2 CompletableFuture 异步编排

业务场景：
查询商品详情页逻辑较复杂，有些数据需要远程调用，必然需要花费更多的时间：

• 获取Sku基本信息
• 获取Sku图片信息
• 获取Sku销售属性
• 获取Sku促销（秒杀）信息
  …

5.2.1 创建异步对象

java.util.concurrent.CompletableFuture提供了四个静态方法来创建一个异步操作：

public static CompletableFuture<Void> runAsync(Runnable runnable)

public static CompletableFuture<Void> runAsync(Runnable runnable,
                                                   Executor executor)

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor)

• runXxx 都是没有返回结果的，supplyXxxx都是可以获取返回结果的
• 可以传入自定义的线程池，否则就是用默认的线程池
• 根据方法的返回类型来判断是否该方法是否有返回类型

大🌰：

	public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
        }, executor);

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            return i;
        }, executor);
        //获取返回值
        Integer integer = future.get();
    }

5.2.2 计算完成时回调方法

当CompletableFuture的计算结果完成，或者抛出异常的时候，可以执行特定的 Action：

	public CompletableFuture<T> whenComplete(
        BiConsumer<? super T, ? super Throwable> action)

    public CompletableFuture<T> whenCompleteAsync(
        BiConsumer<? super T, ? super Throwable> action) 

    public CompletableFuture<T> whenCompleteAsync(
        BiConsumer<? super T, ? super Throwable> action, Executor executor) 
       
    public CompletableFuture<T> exceptionally(
        Function<Throwable, ? extends T> fn)

whenComplete可以处理正常和异常的计算结果，exceptionally处理异常情况

whenComplete和 whenCompleteAsync的区别

• whenComplete：是执行当前任务的线程继续执行whencomplete的任务
• whenCompleteAsync：是执行把whenCompleteAsync这个任务继续提交给线程池来进行执行

方法不以 Async 结尾，意味着 Action 使用相同的线程执行，而 Async 可能会使用其他线程执行（如何是使用相同的线程池，也可能会被同一个线程选中执行）

大🌰：

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    int i = 10 / 0;
    System.out.println("运行结果：" + i);
    return i;
}, executor).whenComplete((res,exception) ->{
    // 虽然能得到异常信息，但是没法修改返回的数据
    System.out.println("异步任务成功完成了...结果是：" +res + "异常是：" + exception);
}).exceptionally(throwable -> {
    // 可以感知到异常，同时返回默认值
    return 10;
});

5.2.3 handle 方法

public <U> CompletionStage<U> handle(BiFunction<? super T,
		 Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, 
		 Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, 
		 Throwable, ? extends U> fn,Execut

和complete一样，可以对结果做最后的处理（可处理异常），可改变返回值

大🌰：

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    return i;
}, executor).handle((res,thr) ->{
    if (res != null ) {
        return res * 2;
    }
    if (thr != null) {
        return 0;
    }
    return 0;
});

5.2.4 线程串行方法

	public <U> CompletableFuture<U> thenApply(
        Function<? super T,? extends U> fn) 

    public <U> CompletableFuture<U> thenApplyAsync(
        Function<? super T,? extends U> fn) 

    public <U> CompletableFuture<U> thenApplyAsync(
        Function<? super T,? extends U> fn, Executor executor) 



    public CompletableFuture<Void> thenAccept(Consumer<? super T> action) 

    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) 

    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,
    											Executor executor)



    public CompletableFuture<Void> thenRun(Runnable action) 

    public CompletableFuture<Void> thenRunAsync(Runnable action) 

    public CompletableFuture<Void> thenRunAsync(Runnable action,
                                                Executor executor) 

• thenApply() ：获取上一步任务的返回值，处理后返回新的返回值让别人感知；

• thenAccept()：接受上一步的执行结果，无返回值；

• thenRun()：只要上面任务执行完成，就开始执行thenRun的后续操作（不能拿到上一步的执行结果）

	CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务2启动了..." + res);
            return "Hello " + res;
        }, executor);
        String s = future.get();

5.2.5 两任务组合

注：CompletableFuture实现了CompletionStage接口

public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn,Executor executor);

public <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action,Executor executor);

public CompletionStage<Void> runAfterBoth(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor)

thenCombine：组合两个future，获取两个future的返回结果，再返回当前任务的返回值

thenAccpetBoth：组合两个future，获取两个future任务的返回结果，然后处理任务，但没有返回值

runAfterBoth：组合两个future，无法获取future的结果，只需要两个future处理完成任务后，再次处理该任务

8.2.7 多任务组合

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

allOf：等待所有任务完成

anyOf：只要有一个任务完成

8.3 异步任务获取 Item

@Override
    public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
        SkuItemVo skuItemVo = new SkuItemVo();

        CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
            //1.sku基本信息获取
            SkuInfoEntity skuInfoEntity = getById(skuId);
            skuItemVo.setInfo(skuInfoEntity);
            return skuInfoEntity;
        }, threadPool);

        CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync(res -> {
            //3.spu的所有销售属性组合
            List<SkuItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrsBySpuId(res.getSpuId());
            skuItemVo.setSaleAttr(saleAttrVos);
        }, threadPool);

        CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync(res -> {
            //4.spu介绍的获取
            SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId());
            skuItemVo.setDesc(spuInfoDescEntity);
        }, threadPool);

        CompletableFuture<Void> baseAttrFuture = infoFuture.thenAcceptAsync(res -> {
            //5.sku规格参数信息的获取
            List<SpuItemAttrGroupVo> groupAttrs = attrGroupService.
                    getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
            skuItemVo.setGroupAttrs(groupAttrs);
        }, threadPool);

        //2.sku图片信息获取
        CompletableFuture<Void> imagesFuture = CompletableFuture.runAsync(() -> {
            List<SkuImagesEntity> imagesEntities = skuImagesService.getImagesById(skuId);
            skuItemVo.setImages(imagesEntities);
        }, threadPool);

        //查询当前sku是否参与秒杀优惠？？
        CompletableFuture<Void> seckillFuture = CompletableFuture.runAsync(() -> {
            R r = seckillFeignService.getSkuSeckillInfo(skuId);
            if (r.getCode() == 0) {
                SeckillInfoVo data = r.getData(new TypeReference<SeckillInfoVo>() {
                });
                skuItemVo.setSeckillInfoVo(data);
            }
        }, threadPool);
        
        //等待所有任务都完成：
       CompletableFuture.allOf(saleAttrFuture,
               descFuture,
               baseAttrFuture,
               imagesFuture,
               seckillFuture).get();
        return skuItemVo;
    }

6. 认证服务

6.1 阿里云短信服务发送验证码

① 在kedamall-third-party中编写发送短信组件,其中host、path、appcode可在properties配置文件中使用前缀spring.cloud.alicloud.sms进行配置

package com.example.kedamall.thridparty.component;
@Component
@Data
@ConfigurationProperties("spring.cloud.alicloud.sms")
public class SmsComponent {

    private String host;
    private String path;
    private String skin;
    private String sign;
    private String appcode;

    public void sendSmsCode(String phone, String code){
        String urlSend = host + path + "?sign=" + sign + "&skin=" + skin+ "&param=" + code+ "&phone=" + phone; // 【5】拼接请求链接
        try {
            URL url = new URL(urlSend);
            HttpURLConnection httpURLCon = (HttpURLConnection) url.openConnection();
            httpURLCon.setRequestProperty("Authorization", "APPCODE " + appcode);// 格式Authorization:APPCODE
            // (中间是英文空格)
            int httpCode = httpURLCon.getResponseCode();
            if (httpCode == 200) {
                String json = read(httpURLCon.getInputStream());
                System.out.println("正常请求计费(其他均不计费)");
                System.out.println("获取返回的json:");
                System.out.print(json);
            } else {
                Map<String, List<String>> map = httpURLCon.getHeaderFields();
                String error = map.get("X-Ca-Error-Message").get(0);
                if (httpCode == 400 && error.equals("Invalid AppCode `not exists`")) {
                    System.out.println("AppCode错误 ");
                } else if (httpCode == 400 && error.equals("Invalid Url")) {
                    System.out.println("请求的 Method、Path 或者环境错误");
                } else if (httpCode == 400 && error.equals("Invalid Param Location")) {
                    System.out.println("参数错误");
                } else if (httpCode == 403 && error.equals("Unauthorized")) {
                    System.out.println("服务未被授权（或URL和Path不正确）");
                } else if (httpCode == 403 && error.equals("Quota Exhausted")) {
                    System.out.println("套餐包次数用完 ");
                } else {
                    System.out.println("参数名错误 或 其他错误");
                    System.out.println(error);
                }
            }

        } catch (MalformedURLException e) {
            System.out.println("URL格式错误");
        } catch (UnknownHostException e) {
            System.out.println("URL地址错误");
        } catch (Exception e) {
            // 打开注释查看详细报错异常信息
            // e.printStackTrace();
        }
    }
    private static String read(InputStream is) throws IOException {
        StringBuffer sb = new StringBuffer();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String line = null;
        while ((line = br.readLine()) != null) {
            line = new String(line.getBytes(), "utf-8");
            sb.append(line);
        }
        br.close();
        return sb.toString();
    }
}

② 接口防刷：为了防止恶意攻击，我们不能随意让接口被调用。

• 在 Redis 中以phone-code将电话号码和验证码进行存储并将当前时间与code一起存储
• 如果调用时以当前 phone 取出的 value 不为空且当前时间在存储时间的 60s 以内，说明 60s 内该号码已经调用过，返回错误信息
• 60s 以后再次调用，需要删除之前存储的 phone-code
• code 存在一个过期时间，我们设置为 10min，10min 内验证该验证码有效

/**
 * 发送短信验证码
 * @param phone 手机号
 * @return
 */
@GetMapping("/sms/sendCode")
@ResponseBody
public R sendCode(@RequestParam("phone") String phone) {
    // TODO 1、接口防刷
    // 先从redis中拿取
    String redisCode = redisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + phone);
    if(!StringUtils.isEmpty(redisCode)) {
        // 拆分
        long l = Long.parseLong(redisCode.split("_")[1]);
        // 当前系统事件减去之前验证码存入的事件 小于60000毫秒=60秒
        if (System.currentTimeMillis() -l < 60000) {
            // 60秒内不能再发
            R.error(BizCodeEnume.SMS_CODE_EXCEPTION.getCode(),BizCodeEnume.SMS_CODE_EXCEPTION.getMsg());
        }
    }
    // 2、验证码的再次效验
    // 数据存入，redis：key-phone，value：code sms:code:131xxxxx - >45678
    String code = UUID.randomUUID().toString().substring(0,5).toUpperCase();
    // 拼接验证码
    String substring = code+"_" + System.currentTimeMillis();
    // redis缓存验证码 防止同一个phone在60秒内发出多次验证吗
    redisTemplate.opsForValue().set(AuthServerConstant.SMS_CODE_CACHE_PREFIX + phone,substring, 10, TimeUnit.MINUTES);

    // 调用第三方服务发送验证码
    thirdPartFeignService.sendCode(phone,code);
    return R.ok();
}

6.2 用户注册

6.2.1 编写 vo 接收页面提交

• 使用到了 JSR303校验

/**
 * 注册数据封装 Vo
 */
@Data
public class UserRegistVo {
    @NotEmpty(message = "用户名必须提交")
    @Length(min = 6,max = 18,message = "用户名必须是6-18位字符")
    private String userName;

    @NotEmpty(message = "密码必须填写")
    @Length(min = 6,max = 18,message = "密码必须是6-18位字符")
    private String password;

    @NotEmpty(message = "手机号码必须提交")
    @Pattern(regexp = "^[1]([3-9])[0-9]{9}$",message = "手机格式不正确")
    private String phone;

    @NotEmpty(message = "验证码必须填写")
    private String code;
}

6.2.2 RedirectAttributes & 用户注册Controller & MD5与盐值加密

① RedirectAttributes是用于重定向之后还能带参数跳转的的工具类，它有两种带参的方式：

• 第一种：
  redirectAttributes.addAttributie("prama",value);这种方法相当于在重定向链接地址追加传递的参数，例如:

redirectAttributes.addAttributie("prama1",value1);
redirectAttributes.addAttributie("prama2",value2);

return:"redirect:/path/list"

同于 return:"redirect:/path/list?prama1=value1&prama2=value2" ，注意这种方法直接将传递的参数暴露在链接地址上，非常的不安全，慎用。

• 第二种：
  redirectAttributes.addFlashAttributie("prama",value);这种方法是隐藏了参数，链接地址上不直接暴露，但是只能在重定向的“页面”获取参数值。
  其原理就是放到session中，session在跳到页面后马上移除对象。如果是重定向一个controller中是获取不到该prama属性值的。除非在controller中用@RequestPrama(value = "prama")String prama注解，采用传参的方式。
  例如：

redirectAttributes.addFlashAttributie("prama1",value1);
redirectAttributes.addFlashAttributie("prama2",value2);

return:"redirect：/path/list.jsp" 

② 用户注册Controller

/**
 * @param vo 数据传输对象
 * @param result 用于验证参数
 * @param redirectAttributes 数据重定向
 * @return
 */
@PostMapping("/regist")
public String regist(@Valid UserRegistVo vo, BindingResult result,
                     RedirectAttributes redirectAttributes) {
    // 校验是否通过
    if (result.hasErrors()) {
        // 拿到错误信息转换成 Map
        Map<String, String> errors = result.getFieldErrors().stream().collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
        //用一次的属性
        redirectAttributes.addFlashAttribute("errors",errors);
        // 校验出错，转发到注册页
        return "redirect:http://auth.kedamall.com/reg.html";
    }

    // 将传递过来的验证码与 存在redis中的验证码进行比较
    String code = vo.getCode();
    String s = redisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
    if (!StringUtils.isEmpty(s)) {
        // 验证码和redis中的一致
        if(code.equals(s.split("_")[0])) {
            // 删除验证码：令牌机制
            redisTemplate.delete(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
            // 调用远程服务，真正注册
            R r = memberFeignService.regist(vo);
            if (r.getCode() == 0) {
                // 远程调用注册服务成功
                return "redirect:http://auth.kedamall.com/login.html";
            } else {
                Map<String, String> errors = new HashMap<>();
                errors.put("msg",r.getData(new TypeReference<String>(){}));
                redirectAttributes.addFlashAttribute("errors", errors);
                return "redirect:http://auth.kedamall.com/reg.html";
            }
        } else {
            Map<String, String> errors = new HashMap<>();
            errors.put("code", "验证码错误");
            redirectAttributes.addFlashAttribute("code", "验证码错误");
            // 校验出错，转发到注册页
            return "redirect:http://auth.kedamall.com/reg.html";
        }
    } else {
        Map<String, String> errors = new HashMap<>();
        errors.put("code", "验证码错误");
        redirectAttributes.addFlashAttribute("code", "验证码错误");
        // 校验出错，转发到注册页
        return "redirect:http://auth.kedamall.com/reg.html";
    }
}

③ MD5和盐值加密

kedamall-member下的远程服务：

	@Override
    public void regist(MemberRegistVo vo) {
        MemberEntity memberEntity = new MemberEntity();

        //设置默认等级
        MemberLevelEntity level = memberLevelDao.getDefaultLevel();
        memberEntity.setLevelId(level.getId());

        //检查phone、name唯一性
        checkPhoneUnique(vo.getPhone());
        checkUserNameUnique(vo.getUserName());

        //密码要进行加密存储
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String encode = passwordEncoder.encode(vo.getPassword());
        memberEntity.setPassword(encode);

        //设置UserName
        memberEntity.setUsername(vo.getUserName());
        memberEntity.setNickname(vo.getUserName());

        //其他默认信息的设置
        
        MemberDao memberDao = this.baseMapper;
        memberDao.insert(memberEntity);
    }

6.3 OAuth2.0社交登录

• OAuth（开放授权）是一个开放标准，允许用户授权第三方网站访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方网站或分享他们的数据的内容

• OAuth2.0：对于用户相关的 OpenAPI（例如获取用户信息，动态同步，照片，日志，分享等），为了保存用户数据的安全和隐私，第三方网站访问用户数据前都需要显示向用户授权
  

	@GetMapping("/oauth2.0/weibo/success")
    public String weibo(@RequestParam("code") String code, HttpSession session) throws Exception {
        //1.根据code换取Access Token
        Map<String, String> map = new HashMap<>();
        map.put("client_id","36929622814");
        map.put("client_secret","9032be03d4747f");
        map.put("grant_type","authorization_code");
        map.put("redirect_uri","http://auth.kedamall.com/oauth2.0/weibo/success");
        map.put("code",code);
        HttpResponse response = HttpUtils.doPost("https://api.weibo.com",
                "/oauth2/access_token",
                "post",
                new HashMap<String, String>(),
                map,
                new HashMap<String, String>());
        //2.进一步处理
        StatusLine statusLine = response.getStatusLine();
        if(statusLine.getStatusCode()==200){
            //获取到Access Token
            String json = EntityUtils.toString(response.getEntity());
            SocialUser socialUser = JSON.parseObject(json, SocialUser.class);

            R r = memberFeignService.oauthLogin(socialUser);
            if(r.getCode()==0){
                MemberResponseVo responseVo = r.getData("data", new TypeReference<MemberResponseVo>() {
                });
                log.info("登录成功，用户信息："+responseVo.toString());
                session.setAttribute(AuthServerConstant.LOGIN_USER,responseVo);
                //3.登陆成功，跳回首页
                return "redirect:http://kedamall.com";
            }else {
                return "redirect:http://auth.kedamall.com/login.html";
            }
        }else{
            return "redirect:http://auth.kedamall.com/login.html";
        }
    }

6.4 分布式 Session不共享不同步问题

问题描述：

• session不可跨域，它有自己的作用范围。例如：在auth.kedamall.com中保存session，但是网址跳转到kedamall.com中，取不出auth.kedamall.com中保存的session
• 同一个服务，复制多份，session不同步问题。
  
  
  解决方案： 统一存储
  

6.5 SpringSession

6.5.1 核心原理

• @EnableRedisHttpSession导入了RedisHttpSessionConfiguration配置
• 这个配置给容器中添加了一个组件RedisOperationsSessionRepository，这个组件是 Redis 操作 Session 的增删改查封装类。
• 这个配置还添加了一个SessionRepositoryFilter组件，它是 Session 存储过滤器，每个请求过来必须经过这个 Filter。
  • 创建的时候，就自动从容器中获取到了上面的RedisOperationsSessionRepository
  • 核心原理——装饰者模式
    原生的获取session时是通过HttpServletRequest获取的
    这里对request进行包装成了wrappedRequest，并且重写了包装request的getSession()方法

@Override
protected void doFilterInternal(HttpServletRequest request,
      HttpServletResponse response, FilterChain filterChain)
      throws ServletException, IOException {
   request.setAttribute(SESSION_REPOSITORY_ATTR, this.sessionRepository);

    //对原生的request、response进行包装
   SessionRepositoryRequestWrapper wrappedRequest = new SessionRepositoryRequestWrapper(
         request, response, this.servletContext);
   SessionRepositoryResponseWrapper wrappedResponse = new SessionRepositoryResponseWrapper(
         wrappedRequest, response);

   try {
   	  // Filter放行的是包装后的request和responses
   	  //包装后的request和responses应用到了后面整个执行链
      filterChain.doFilter(wrappedRequest, wrappedResponse);
   }
   finally {
      wrappedRequest.commitSession();
   }
}

6.5.2 整合SpringSession

① 搭建环境

导依赖

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