• 需要保存 sku 信息
  当搜索商品名时，查询的是 sku 的标题 sku_title；
  可能通过 sku 的标题、销量、价格区间检索
• 需要保存品牌、分类等信息
  点击分类，检索分类下的所有信息
  点击品牌，检索品牌下的商品信息
• 需要保存 spu 信息
  选择规格，检索共有这些规格的商品

• 在es中新建mapping映射结构：

  "mappings": {
    "properties": {
      "skuId": { "type": "long" },
      "spuId": { "type": "keyword" }, # 精确检索，不分词
      "skuTitle": {
        "type": "text", # 全文检索
        "analyzer": "ik_smart" # 分词器
      },
      "skuPrice": { "type": "keyword" },
      "skuImg": {
        "type": "keyword",
        "index": false, # false 不可被检索
        "doc_values": false # false 不可被聚合
      },
      "saleCount":{ "type":"long" }, # 商品销量
      "hasStock": { "type": "boolean" }, # 商品是否有库存
      "hotScore": { "type": "long"  }, # 商品热度评分
      "brandId":  { "type": "long" }, # 品牌id
      "catalogId": { "type": "long"  }, # 分类id
      "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" }	# 属性值
        }
      }
    }
  }

• 关于 nested 类型——官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/nested.html
  Object 数据类型的数组在不使用nested类型时会被扁平化处理为一个简单的键与值的列表(右图)，即对象的相同属性会放到同一个数组中(同属于first的John和Alice放在了一个数组里)，在检索时会出现错误。参考官网：https://www.elastic.co/guide/en/elasticsearch/reference/current/nested.html#nested-arrays-flattening-objects
  
  所以对于 Object 类型的数组，要使用 nested 字段类型。先指定数组的type类型为nested(如下图)，再存值。参考官网：https://www.elastic.co/guide/en/elasticsearch/reference/current/nested.html#nested-fields-array-objects
  
  

@Data
public class SpuEsModule {
    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<Attrs> attrs;

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

3.商城首页

• 导入thymeleaf模板引擎依赖
  

  <!-- 模板引擎 -->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
  </dependency>

• 将资料里首页的静态资源和页面分别复制到resources下的static(存放静态资源)和templates(存放模板)文件夹下。
• 配置关闭thymeleaf缓存
  

  spring:
    thymeleaf:
      cache: false

• 编写首页跳转接口

  @GetMapping({"/","/index.html"})
  public String indexPage(Model model){
      //查询所有一级分类信息
      List<CategoryEntity> categoryEntities=categoryService.getLevel1();
  
      model.addAttribute("categories",categoryEntities);
      return "index";
  }
  
  //查询所有一级分类信息 
  @Override
  public List<CategoryEntity> getLevel1() {
      List<CategoryEntity> categoryEntities = this.list(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
      return categoryEntities;
  }
  

• 查询二三级分类信息

  @Override
  public Map<String, List<Catelog2Vo>> getCatelogJSON() {
      //1、查出所有分类
      //1、1）查出所有一级分类
      List<CategoryEntity> level1Categories = getLevel1();
      //封装数据
      Map<String, List<Catelog2Vo>> parentCid = level1Categories.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
          //1、根据每个一级分类查询其所有二级分类信息
          List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
          //2、封装二级分类
          List<Catelog2Vo> catalogs2Vos = null;
          if (categoryEntities != null) {
              catalogs2Vos = categoryEntities.stream().map(l2 -> {
                  Catelog2Vo catalogs2Vo = new Catelog2Vo(v.getCatId().toString(),l2.getCatId().toString(), l2.getName(),null);
                  //1、找当前二级分类的三级分类封装成vo
                  List<CategoryEntity> level3Catelog = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", l2.getCatId()));
                  if (level3Catelog != null) {
                      List<Catelog2Vo.Catelog3Vo> category3Vos = level3Catelog.stream().map(l3 -> {
                          //2、封装成指定格式
                          Catelog2Vo.Catelog3Vo category3Vo = new Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                          return category3Vo;
                      }).collect(Collectors.toList());
                      catalogs2Vo.setCatalog3List(category3Vos);
                  }
                  return catalogs2Vo;
              }).collect(Collectors.toList());
          }
          return catalogs2Vos;
      }));
      return parentCid;
  }

• 修改系统的hosts文件(C:\Windows\System32\drivers\etc)，这样通过gulimall.com就能访问到虚拟机了。

  # gulimall #
  我的虚拟机ip地址	gulimall.com

• 修改虚拟机中Nginx的配置文件
  在nginx总配置文件中我们可以看到， http 块中最后有 include /etc/nginx/conf.d/*.conf; 这句配置说明在 conf.d 目录下所有 .conf 后缀的文件内容都会作为 nginx 配置文件 http 块中的配置。这是为了防止主配置文件太复杂，也可以对不同的配置进行分类。我们参考 conf.d 目录下的 default.conf 来配置 gulimall 的 server 块配置。

  server {
      listen       80;
      # 这里写我们再hosts中修改的虚拟机ip对应的域名
      server_name  gulimall.com;
      #charset koi8-r;
      #access_log  /var/log/nginx/log/host.access.log  main;
      location / {
        # 将gulimall.com反向代理到http://192.168.152.1:12000
        proxy_pass http://192.168.152.1:12000;
      }
      #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;
      }
  }

• 效果演示：
  

• 由nginx反向代理到gateway(上游服务器)，在conf中配置上游服务器组(组名gulimall)，这里我们只有一个gateway服务：
  
  
• 配置反向代理地址
  
• ★访问跳转分析
  在使用gulimall.com域名访问时，会在请求头中携带Host:gulimall.com信息。
  
  我们期望网关通过Host断言来将gulimall.com路由到product服务。但是由于我们是先将请求发给nginx，而nginx默认会丢掉这个Host:gulimall.com信息，这样由nginx反向代理给网关的请求里就不带Host信息了，导致即使在网关中配置了正确的路由规则，也无法正确显示首页。所以我们在配置gateway路由规则前，要先配置nginx，使其保留Host:gulimall.com信息。
• 配置nginx保留Host信息
  
  
• 配置网关路由规则
  
  

• 把product服务中static文件夹下的 index包 放到 虚拟机中 nginx 的html里：/mydata/nginx/html/static(mkdir的)/index；
  
  
• 给product服务中的index.html里所有静态资源的请求路径前都加上 /static；
• 在nginx中配置静态资源处理规则：修改 Nginx 配置文件 /mydata/nginx/conf/conf.d/gulimall.conf：

  # 将 /static/请求 都转到/user/share/nginx/html文件夹，也就是在这个文件夹里找静态资源
  location /static/ {
  	root /user/share/nginx/html;
  }

@Override
public Map<String, List<Catelog2Vo>> getCatelogJSON() {
    //1.将多次查询数据库变为查询一次数据库
    //先查询出所有的分类信息
    List<CategoryEntity> selectList = baseMapper.selectList(null);
    //1、查出所有分类
    //1、1）查出所有一级分类
    List<CategoryEntity> level1Categories = getLevel1();
    //封装数据
    Map<String, List<Catelog2Vo>> parentCid = level1Categories.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
        //1、根据每个一级分类查询其所有二级分类信息
        List<CategoryEntity> categoryEntities = getParentCid(selectList,0L);
        //2、封装二级分类
        List<Catelog2Vo> catalogs2Vos = null;
        if (categoryEntities != null) {
            catalogs2Vos = categoryEntities.stream().map(l2 -> {
                Catelog2Vo catalogs2Vo = new Catelog2Vo(v.getCatId().toString(),l2.getCatId().toString(), l2.getName(),null);
                //1、找当前二级分类的三级分类封装成vo
                List<CategoryEntity> level3Catelog = getParentCid(selectList, l2.getCatId());
                if (level3Catelog != null) {
                    List<Catelog2Vo.Catelog3Vo> category3Vos = level3Catelog.stream().map(l3 -> {
                        //2、封装成指定格式
                        Catelog2Vo.Catelog3Vo category3Vo = new Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                        return category3Vo;
                    }).collect(Collectors.toList());
                    catalogs2Vo.setCatalog3List(category3Vos);
                }
                return catalogs2Vo;
            }).collect(Collectors.toList());
        }
        return catalogs2Vos;
    }));
    return parentCid;
}
private List<CategoryEntity> getParentCid(List<CategoryEntity> selectList,Long parentCid) {
    List<CategoryEntity> collect = selectList.stream().filter(item -> item.getParentCid() == parentCid).collect(Collectors.toList());
    //return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
    return collect;
}

二、缓存与分布式锁

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

• 本地缓存是在同一个进程内的内存空间中缓存数据，数据读写都是在同一个进程内完成。
• 分布式缓存一般都是独立部署的一个进程，并且与应用进程部署在不同的机器上。

• 导入坐标

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

• 配置Redis

  spring:
      #Redis相关配置
    redis:
      host: localhost
      port: 6379
      #password: 123456
      database: 0 #redis一共提供了16个数据库，默认使用0号数据库

• 将原来直接从数据库中查询数据的方法抽取成一个方法：

  //从数据库中直接获取数据
  public Map<String, List<Catelog2Vo>> getCatelogJSONFromDB() {
      ...
  }

• 加入缓存的业务逻辑：想从数据库中查数据时直接调用上面抽取的getCatelogJSONFromDB()方法即可：

  @Override
  public Map<String, List<Catelog2Vo>> getCatelogJSON() {
      //加入缓存逻辑
      //1.先判断redis中是否有缓存数据
      ValueOperations<String, String> ops = redisTemplate.opsForValue();
      String json = ops.get("catelogJSON");
      //2.如果没有缓存
      if (StringUtils.isEmpty(json)) {
          //2.1查询数据库
          Map<String, List<Catelog2Vo>> catelogJSON = getCatelogJSONFromDB();
          //2.2将查到的数据放入缓存
          ops.set("catelogJSON", JSON.toJSONString(catelogJSON));
          //2.3返回查询到的数据
          return catelogJSON;
      }
      //如果有缓存数据，将缓存的String数据转成复杂的Map<String, List<Catelog2Vo>>类型后返回
      return JSON.parseObject(json, new TypeReference<Map<String, List<Catelog2Vo>>>() {
      });
  }

• 产生的原因
  SpringBoot 2.0 以后默认使用 lettuce 作为操作 redis 的客户端，它使用 netty 进行网络通信。
  lettuce 自身存在的 bug 会导致 netty 堆外内存溢出。
  netty 如果没有指定堆外内存，默认使用 -Xmx 参数指定的内存；可以通过 -Dio.netty.maxDirectMemory 进行设置，指定别的内存。
  
• 解决方案
  虽然可以通过 -Dio.netty.maxDirectMemory 去调大堆外内存，但这样只会延缓异常出现的时间，而不能避免出现这个异常。
  可以通过升级 lettuce 客户端，或使用 jedis 客户端来解决。
  
• 将lettuce换成jedis：

  <!-- redis -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    //将lettuce排除
    <exclusions>
      <exclusion>
        <groupId>io.lettuce</groupId>
        <artifactId>lettuce-core</artifactId>
      </exclusion>
    </exclusions>
  </dependency>
  //再导入jedis
  <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
  </dependency>

• 要设置锁的自动过期时间，保证能正常删除锁，防止死锁；
• 一般使用uuid作为加锁(占坑)时存入Redis的值，在删锁时与自己的uuid匹配起来才能删，保证删除的是自己的锁；
• 要保证加锁【占位+设置过期时间】和解锁【匹配uuid+删锁】操作的原子性。

  /**
  * 从数据库查询并封装数据::分布式锁
  *
  * @return
  */
  public Map<String, List<Catalogs2Vo>> getCatalogJsonFromDbWithRedisLock() {
      //1、占分布式锁。去redis占坑 设置过期时间必须和加锁是同步的，保证原子性（避免死锁）
      String uuid = UUID.randomUUID().toString();
      Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
      if (lock) {
          System.out.println("获取分布式锁成功...");
          Map<String, List<Catalogs2Vo>> dataFromDb = null;
          try {
              //加锁成功...执行业务
              dataFromDb = getCatalogJsonFromDB();
          } finally {
              // lua 脚本解锁
              String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
              // 删除锁
              redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Collections.singletonList("lock"), uuid);
          }
          return dataFromDb;
      } else {
          System.out.println("获取分布式锁失败...等待重试...");
          //加锁失败...重试机制
          //休眠一百毫秒
          try {
              TimeUnit.MILLISECONDS.sleep(100);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          return getCatalogJsonFromDbWithRedisLock();     //自旋的方式
      }
  }

• Redisson的使用
  • 导入依赖

     <dependency>
       <groupId>org.redisson</groupId>
       <artifactId>redisson</artifactId>
       <version>3.11.1</version>
    </dependency>

  • 配置Redisson

    @Configuration
    public class MyRedissonConfig {
        /**
         * 所有对 Redisson 的使用都是通过 RedissonClient
         *
         * @return
         * @throws IOException
         */
        @Bean(destroyMethod = "shutdown")
        public RedissonClient redisson() throws IOException {
            // 1、创建配置
            Config config = new Config();
            // Redis url should start with redis://&nbs***bsp;rediss://
            config.useSingleServer().setAddress("redis://192.168.163.131:6379");
            // 2、根据 Config 创建出 RedissonClient 实例
            return Redisson.create(config);
        }
    }

  • 使用
    
    【tips】Redisson的优点：
                ①第2步加锁的操作是阻塞式等待，当其他进程获取不到锁时会一直等待直到有锁，作用相当于我们在前面写的通过自旋的方式实现的等待锁。
                ②实现了锁的自动续期：业务运行时间过长时，不用担心锁在业务进行时被删除，因为在拿到锁后会自动给锁续期(30s)。
                ③业务完成，自动解锁：加锁的业务只要完成，就不会给锁续期，即使不手动解锁(没有执行unlock方法)，锁也会自动删除。
    
• ★Redisson如何解决死锁问题？——lock看门狗原理
  在加锁时有两种方式：
      lock()：默认30s超时自动解锁，且实现了锁的自动续期，如果业务未完成，会每隔一段时间给锁续期。
      lock( 指定超时时间 , 时间单位 )：在指定超时时间到了后自动解锁，没有自动续期。因此一般设置指定超时时间＞业务执行时间。
  两种加锁方式的实现原理（源码）：
      
      
      
      两种lock方法都会调用tryAcquire方法尝试获取锁，lock()传入的leaseTime为-1；如果是我们指定了超时时间的话传入的leaseTime就等于指定的超时时间。它会通过一个if判断leaseTime：
          如果leaseTime不等于-1的话就是指定了超时时间，会给Redis发送lua脚本进行占锁。（如下图）
          
          如果leaseTime等于-1的话就是lock()，就使用lockWatchdogTimeout作为过期时间(默认30s)。
          
      由此可知如果只是用lock.lock()不传过期时间的话，会启动看门狗机制；传过期时间的话，就不会启动看门狗机制。
      【接着lock()获取到看门狗超时时间(getLockWatchdogTimeout)后往下看】在没有异常的时候(e==null)会开启一个定时任务(new TimerTask)，来重新给锁设置超时时间(还是看门狗超时时间)进行续期。续期也不是立马续期，而是在三分之一个看门狗时间(lockWatchdogTimeout / 3，默认10s)后进行续期。(也就是renewExpiration方法每次自我调用间隔10s。)
          
          
• 两种加锁方式的选择：
  一般不推荐使用有看门狗机制的lock()方法进行加锁。

• 读写锁的几种组合情况：
  • 读+读：并发读，相当于无锁。只会在redis中记录好所有当前的读锁，他们都会同时加锁成功。
  • 写+读：读者需等待写锁释放才能读到数据。
  • 写+写：阻塞方式，必须等待写锁释放，其他写着才能访问资源。
  • 读+写：写锁需要等待读锁释放。
  总结：只要有写锁的存在，都必须等待。

• 在Redis中存一个名为 "park" 的信号量，设置信号量总量为3个。
  

• 通过redisson客户端的getSemaphore方法来创建一个名为 "park" 的信号量。通过acquire和release方法来获取和释放一个信号量，获取一个信号量，Redis中信号量就 - 1；释放一个信号量，Redis中信号量就 + 1。如果Redis中信号量为0，获取操作就必须等待。
  
  
• 对于获取信号量，还可以使用tryAcquire方法，它的作用是尝试获取一个信号量，能获取就返回true，没有获取到就返回false，不会一直等待别人释放信号量。

• ①如果是用户纬度数据(订单数据、用户数据)，这种并发几率非常小，缓存数据加上过期时间，每隔一段时间触发读的主动更新即可；
• ②如果是菜单，商品介绍等基础数据，也可以去使用canal订阅binlog的方式
• ③缓存数据+过期时间也足够解决大部分业务对于缓存的要求
• ④通过加锁保证并发读写，写写的时候按顺序排好队。读读无所谓。所以适合使用读写锁。(业务不关心脏数据，允许临时脏数据可忽略) ;

• 给缓存的所有数据都设置过期时间，即使数据过期下一次查询会触发主动更新；
• 读写数据的时候，加上分布式的读写锁。

• Cache
  • Cache 接口是缓存的组件规范定义，包含了缓存的各种操作集合；
  • 在Cache 接口下Spring 提供了各种 xxxCache 的实现，如RedisCache、EhCacheCache、ConcurrentMapCache 等
• CacheManager 缓存管理器：用来管理各种Cache。
  • CacheManager 中只有两个方法：
    
    
  • CacheManager支持多种类型的缓存：
    

• 引入springcache的依赖

  <!--spring-boot-starter-cache-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-cache</artifactId>
  </dependency>

  因为我们使用Redis作为缓存，因此还需要引入Redis相关依赖

  <!--引入redis-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
      <exclusions>
          <exclusion>
              <groupId>io.lettuce</groupId>
              <artifactId>lettuce-core</artifactId>
          </exclusion>
      </exclusions>
  </dependency>
  <!--jedis不写版本springboot控制-->
  <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
  </dependency>

• 配置springcache
  • 引入依赖后帮我们做了哪些自动配置：
    • CacheProperties封装了配置文件中可以配置的属性：
      
    • CacheConfiguration会根据缓存类型导入RedisCacheConfiguration，RedisCacheConfiguration自动配好了缓存管理器：
      
  • 需要手动配置——配置使用的缓存类型
    
• 使用 @EnableCaching 开启缓存功能
• springcache的使用——常用的注解
• @Cacheable：加在方法上。将方法的返回数据保存到缓存中：如果缓存中有，就不调用该方法；缓存不命中才调用该方法并将结果放入缓存。

  //将每一个缓存的数据放入指定的缓存分区(通常按照业务类型分)
  @Cacheable({"categroy"})

  默认情况下存入Redis中的缓存数据的特点：
          ①key值自动生成——缓存分区名::SimpleKey{}
          ②缓存的Value值默认使用JDK序列化机制，即是将序列化后的数据存到Redis
          ③默认过期时间TTL:-1，即永不过期
  自定义缓存数据信息：
          ①自定义key值：使用key属性，接收SpEL表达式(以#root开头的那个)，要么就用双引号里加单引号：" ' 指定的key值 ' "来指定key值。这里是把上面的SimpleKey{}换成了我们指定的key值。
                
          ②设置数据过期时间：修改配置文件，time-to-live

  spring:
    cache:
      type: redis
      redis:
        time-to-live: 3600000  #设置存活时间,毫秒

          ③★使用RedisCacheConfiguration配置其他缓存配置信息
              a）原理：上面的自动配置中我们提到，CacheConfiguration会根据缓存类型(比如用Redis作为缓存)导入RedisCacheConfiguration，RedisCacheConfiguration自动配好了缓存管理器，初始化所有的缓存，每个缓存决定了要使用什么配置：配置类中有就用配置类的，没有就用自动配置时默认的。因此想要修改缓存的配置只需要在容器中放一个RedisCacheConfiguration配置类即可，这个Redis缓存配置类容器就会应用到当前RedisCacheManager管理的所有缓存分区中。
              b）具体代码实现：

  @EnableCaching
  @Configuration
  public class MyCacheConfig {
      @Bean
      RedisCacheConfiguration redisCacheConfiguration(){
          RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
          //key的序列化配置——使用String存储key
          config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
          //值的序列化配置——使用JSON形式存储值
          config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
          return config;
      };
  }

          c）存在的问题：在配置文件中缓存配置没有生效(比如我们设置的TTL)。
               原因 ：上面我们自己写的RedisCacheConfiguration配置类没有读取配置文件中的配置。
               解决：

  @EnableConfigurationProperties(CacheProperties.class)
  @Configuration
  @EnableCaching
  public class MyCacheConfig {
      @Bean
      public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
  
          RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
          // config = config.entryTtl();
          //设置Key的序列化方式
          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;
      }
  }

• @CacheEvict：将数据从缓存删除的操作。可以用来实现先写数据再删除缓存的失效模式。

  //删除category缓存分区里key为getLevel1Categorys的缓存数据
  @CacheEvict(value="category缓存分区里的",key="'getLevel1Categorys'")

  【如果一次修改操作需要删除两个或多个缓存该如何删除？】
  ①使用 @Caching 组合两个或多个 @CacheEvict：
      
  ②指定删除某个缓存分区下的所有缓存数据(allEntries)：
      
  
• @CachePut：在不影响方法执行的情况下更新缓存。可以用来实现先写DB再写缓存的双写模式。
  
• @Caching：组合以上多个操作。
• @CacheConfig：在类级别共享缓存的相同配置。
  

• 对读模式(查询数据)下可能出现的问题的解决方案：
  • 缓存穿透：在配置文件中开启缓存空数据：cache-null-values:true；
  • 缓存击穿：SpringCache的读操作默认是不加锁的，可以使用@Cacheable(value = {“categroy”},key = “#root.method.name”,sync = true)，通过sync开启加锁。只有Cacheable有这个属性；
  • 缓存雪崩：指定过期时间：time-to-live: 3600000。
• 对于写模式(修改数据)下缓存数据一致性问题，SpringCache无法解决。一般可以通过读写加锁、引入Canal、直接去数据库中查询等来解决。

• 导入thymeleaf和devtools依赖

  <!-- 模板引擎 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
  </dependency>
  <!-- devtools依赖 -->
  。。。。。。
  

  记得关闭缓存
• 将资料中的检索页面放到 search 服务模块下的 resource/templates 下

• 配置域名映射——修改 Windows hosts 文件：

  虚拟机ip地址  search.gulimall.com

• 找到 Nginx 的配置文件，编辑 gulimall.conf，将所有 *.gulimall.com 的请求都经 Nginx 转发给网关；

  server {
      listen       80;
      server_name  *.gulimall.com;
  		...
   }
  

  记得重启nginx
• 配置网关服务转发到 search 服务

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

• 检索页可以用来检索的条件有很多(如下图)，这些条件的请求参数是跟在URL后面的。
  
• 我们定义一个叫SearchParam的vo，专门用来封装这些条件参数。
  
• 然后还需要在Service(MallSearchService)中定义根据传入的条件参数查询相关数据的方法(search())，并将数据交给Controller然后返回给前端页面。
  
  

• 上面Service中的search方法的返回值类型是Object，那么给前端页面响应的检索结果应该是什么类型呢？通过分析我们可以将返回的检索结果封装成一个vo——SearchResult。

  @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;
      //===========================以上是返回给页面的所有信息============================//
      @Data
      public static class BrandVo {
          private Long brandId;
          private String brandName;
          private String brandImg;
      }
      @Data
      public static class AttrVo {
          private Long attrId;
          private String attrName;
          private List<String> attrValue;
      }
      @Data
      public static class CatalogVo {
          private Long catalogId;
          private String catalogName;
      }
  }

• 这样我们search的返回值类型就应该是SearchResult了。同时因为要将查询结果返回给页面展示，所以需要用Model来接收，最后在页面中渲染展示。
  
  

GET mall_product/_search
{
  "query": {
    "bool": {
      "must": [ {"match": {  "skuTitle": "华为" }} ], # 检索出华为
      "filter": [ # 过滤
        { "term": { "catalogId": "225" } },
        { "terms": {"brandId": [ "2"] } }, 
        { "term": { "hasStock": "false"} },
        {
          "range": {
            "skuPrice": { # 价格1K~7K
              "gte": 1000,
              "lte": 7000
            }
          }
        },
        {
          "nested": {
            "path": "attrs", # 聚合名字
            "query": {
              "bool": {
                "must": [
                  {
                    "term": { "attrs.attrId": { "value": "6"} }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  },
  "sort": [ {"skuPrice": {"order": "desc" } } ],
  "from": 0,
  "size": 5,
  "highlight": {  
    "fields": {"skuTitle": {}}, # 高亮的字段
    "pre_tags": "<b style='color:red'>",  # 前缀
    "post_tags": "</b>"
  },
  "aggs": { # 查完后聚合
    "brandAgg": {
      "terms": {
        "field": "brandId",
        "size": 10
      },
      "aggs": { # 子聚合
        "brandNameAgg": {  # 每个商品id的品牌
          "terms": {
            "field": "brandName",
            "size": 10
          }
        },
        "brandImgAgg": {
          "terms": {
            "field": "brandImg",
            "size": 10
          }
        }
      }
    },
    "catalogAgg":{
      "terms": {
        "field": "catalogId",
        "size": 10
      },
      "aggs": {
        "catalogNameAgg": {
          "terms": {
            "field": "catalogName",
            "size": 10
          }
        }
      }
    },
    "attrs":{
      "nested": {"path": "attrs" },
      "aggs": {
        "attrIdAgg": {
          "terms": {
            "field": "attrs.attrId",
            "size": 10
          },
          "aggs": {
            "attrNameAgg": {
              "terms": {
                "field": "attrs.attrName",
                "size": 10
              }
            }
          }
        }
      }
    }
  }
}

@Override
public SearchResult search(SearchParam param) {
    // 动态构建出查询需要的DSL语句
    SearchResult result = null;
    //1、准备检索请求
    SearchRequest searchRequest = buildSearchRequest(param);
    try {
        //2、执行检索请求
        SearchResponse response = esRestClient.search(searchRequest, MallElasticSearchConfig.COMMON_OPTIONS);
        //3、分析响应数据，封装成我们需要的格式
        result = buildSearchResult(response, param);
    } catch (IOException e) {
        e.printStackTrace();
    }
    return result;
}
-----------------------------------------------------------------------
//构建DSL语句和检索请求
private SearchRequest buildSearchRequest(SearchParam param) {
    // 检索请求构建
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    /**
     * 查询：模糊匹配，过滤（按照属性，分类，品牌，价格区间，库存）
     */
    //1. 构建 bool-query
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    //1.1 bool-must 模糊匹配
    if (!StringUtils.isEmpty(param.getKeyword())) {
        boolQueryBuilder.must(QueryBuilders.matchQuery("skuTitle", param.getKeyword()));
    }
    //1.2.1 bool-filter catalogId 按照三级分类id查询
    if (null != param.getCatalog3Id()) {
        boolQueryBuilder.filter(QueryBuilders.termQuery("catalogId", param.getCatalog3Id()));
    }
    //1.2.2 bool-filter brandId 按照品牌id查询
    if (null != param.getBrandId() && param.getBrandId().size() > 0) {
        boolQueryBuilder.filter(QueryBuilders.termsQuery("brandId", param.getBrandId()));
    }
    //1.2.3 bool-filter attrs 按照指定的属性查询
    if (param.getAttrs() != null && param.getAttrs().size() > 0) {
        param.getAttrs().forEach(item -> {
            //attrs=1_5寸:8寸&2_16G:8G
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            //attrs=1_5寸:8寸
            String[] s = item.split("_");
            String attrId = s[0]; // 检索的属性id
            String[] attrValues = s[1].split(":");//这个属性检索用的值
            boolQuery.must(QueryBuilders.termQuery("attrs.attrId", attrId));
            boolQuery.must(QueryBuilders.termsQuery("attrs.attrValue", attrValues));
            // 每一个属性都要生成一个 nested 查询
            NestedQueryBuilder nestedQueryBuilder = QueryBuilders.nestedQuery("attrs", boolQuery, ScoreMode.None);
            boolQueryBuilder.filter(nestedQueryBuilder);
        });
    }
    //1.2.4 bool-filter hasStock 按照是否有库存查询
    if (null != param.getHasStock()) {
        boolQueryBuilder.filter(QueryBuilders.termQuery("hasStock", param.getHasStock() == 1));
    }
    //1.2.5 skuPrice bool-filter 按照价格区间查询
    if (!StringUtils.isEmpty(param.getSkuPrice())) {
        //skuPrice形式为：1_500或_500或500_
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("skuPrice");
        String[] price = param.getSkuPrice().split("_");
        if (price.length == 2) {
            rangeQueryBuilder.gte(price[0]).lte(price[1]);
        } else if (price.length == 1) {
            if (param.getSkuPrice().startsWith("_")) {
                rangeQueryBuilder.lte(price[1]);
            }
            if (param.getSkuPrice().endsWith("_")) {
                rangeQueryBuilder.gte(price[0]);
            }
        }
        boolQueryBuilder.filter(rangeQueryBuilder);
    }
    // 封装所有的查询条件
    searchSourceBuilder.query(boolQueryBuilder);
    /**
     * 排序，分页，高亮
     */
    // 2.1 排序  形式为sort=hotScore_asc/desc
    if (!StringUtils.isEmpty(param.getSort())) {
        String sort = param.getSort();
        // sort=hotScore_asc/desc
        String[] sortFields = sort.split("_");
        SortOrder sortOrder = "asc".equalsIgnoreCase(sortFields[1]) ? SortOrder.ASC : SortOrder.DESC;
        searchSourceBuilder.sort(sortFields[0], sortOrder);
    }
    // 2.2 分页 from = (pageNum - 1) * pageSize
    searchSourceBuilder.from((param.getPageNum() - 1) * EsConstant.PRODUCT_PAGE_SIZE);
    searchSourceBuilder.size(EsConstant.PRODUCT_PAGE_SIZE);
    // 2.3 高亮
    if (!StringUtils.isEmpty(param.getKeyword())) {
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("skuTitle");
        highlightBuilder.preTags("<b style='color:red'>");
        highlightBuilder.postTags("</b>");

        searchSourceBuilder.highlighter(highlightBuilder);
    }
    System.out.println("构建的DSL语句" + searchSourceBuilder.toString());
    /**
     * 聚合分析
     */
    //1. 按照品牌进行聚合
    TermsAggregationBuilder brand_agg = AggregationBuilders.terms("brand_agg");
    brand_agg.field("brandId").size(50);
    //1.1 品牌的子聚合-品牌名聚合
    brand_agg.subAggregation(AggregationBuilders.terms("brand_name_agg").field("brandName").size(1));
    //1.2 品牌的子聚合-品牌图片聚合
    brand_agg.subAggregation(AggregationBuilders.terms("brand_img_agg").field("brandImg").size(1));
    searchSourceBuilder.aggregation(brand_agg);
    //2. 按照分类信息进行聚合
    TermsAggregationBuilder catalog_agg = AggregationBuilders.terms("catalog_agg");
    catalog_agg.field("catalogId").size(20);
    catalog_agg.subAggregation(AggregationBuilders.terms("catalog_name_agg").field("catalogName").size(1));
    searchSourceBuilder.aggregation(catalog_agg);
    // 3. 按照属性信息进行聚合
    NestedAggregationBuilder attr_agg = AggregationBuilders.nested("attr_agg", "attrs");
    //3.1 按照属性ID进行聚合
    TermsAggregationBuilder attr_id_agg = AggregationBuilders.terms("attr_id_agg").field("attrs.attrId");
    attr_agg.subAggregation(attr_id_agg);
    //3.1.1 在每个属性ID下，按照属性名进行聚合
    attr_id_agg.subAggregation(AggregationBuilders.terms("attr_name_agg").field("attrs.attrName").size(1));
    //3.1.2 在每个属性ID下，按照属性值进行聚合
    attr_id_agg.subAggregation(AggregationBuilders.terms("attr_value_agg").field("attrs.attrValue").size(50));
    searchSourceBuilder.aggregation(attr_agg);
    log.debug("构建的DSL语句 {}", searchSourceBuilder.toString());
    SearchRequest searchRequest = new SearchRequest(new String[]{EsConstant.PRODUCT_INDEX}, searchSourceBuilder);
    return searchRequest;
}
---------------------------------------------------------------------------------
//根据es返回数据封装要返回的响应数据
private SearchResult buildSearchResult(SearchResponse response, SearchParam param) {
    SearchResult result = new SearchResult();
    //1、返回的所有查询到的商品
    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 esModel = JSON.parseObject(sourceAsString, SkuEsModel.class);
            //判断是否按关键字检索，若是就显示高亮，否则不显示
            if (!StringUtils.isEmpty(param.getKeyword())) {
                //拿到高亮信息显示标题
                HighlightField skuTitle = hit.getHighlightFields().get("skuTitle");
                String skuTitleValue = skuTitle.getFragments()[0].string();
                esModel.setSkuTitle(skuTitleValue);
            }
            esModels.add(esModel);
        }
    }
    result.setProduct(esModels);
    //2、当前商品涉及到的所有属性信息
    List<SearchResult.AttrVo> attrVos = new ArrayList<>();
    //获取属性信息的聚合
    ParsedNested attrsAgg = response.getAggregations().get("attr_agg");
    ParsedLongTerms attrIdAgg = attrsAgg.getAggregations().get("attr_id_agg");
    for (Terms.Bucket bucket : attrIdAgg.getBuckets()) {
        SearchResult.AttrVo attrVo = new SearchResult.AttrVo();
        //1、得到属性的id
        long attrId = bucket.getKeyAsNumber().longValue();
        attrVo.setAttrId(attrId);
        //2、得到属性的名字
        ParsedStringTerms attrNameAgg = bucket.getAggregations().get("attr_name_agg");
        String attrName = attrNameAgg.getBuckets().get(0).getKeyAsString();
        attrVo.setAttrName(attrName);
        //3、得到属性的所有值
        ParsedStringTerms attrValueAgg = bucket.getAggregations().get("attr_value_agg");
        List<String> attrValues = attrValueAgg.getBuckets().stream().map(MultiBucketsAggregation.Bucket::getKeyAsString).collect(Collectors.toList());
        attrVo.setAttrValue(attrValues);
        attrVos.add(attrVo);
    }
    result.setAttrs(attrVos);
    //3、当前商品涉及到的所有品牌信息
    List<SearchResult.BrandVo> brandVos = new ArrayList<>();
    //获取到品牌的聚合
    ParsedLongTerms brandAgg = response.getAggregations().get("brand_agg");
    for (Terms.Bucket bucket : brandAgg.getBuckets()) {
        SearchResult.BrandVo brandVo = new SearchResult.BrandVo();
        //1、得到品牌的id
        long brandId = bucket.getKeyAsNumber().longValue();
        brandVo.setBrandId(brandId);
        //2、得到品牌的名字
        ParsedStringTerms brandNameAgg = bucket.getAggregations().get("brand_name_agg");
        String brandName = brandNameAgg.getBuckets().get(0).getKeyAsString();
        brandVo.setBrandName(brandName);
        //3、得到品牌的图片
        ParsedStringTerms brandImgAgg = bucket.getAggregations().get("brand_img_agg");
        String brandImg = brandImgAgg.getBuckets().get(0).getKeyAsString();
        brandVo.setBrandImg(brandImg);
        brandVos.add(brandVo);
    }
    result.setBrands(brandVos);
    //4、当前商品涉及到的所有分类信息
    //获取到分类的聚合
    List<SearchResult.CatalogVo> catalogVos = new ArrayList<>();
    ParsedLongTerms catalogAgg = response.getAggregations().get("catalog_agg");
    for (Terms.Bucket bucket : catalogAgg.getBuckets()) {
        SearchResult.CatalogVo catalogVo = new SearchResult.CatalogVo();
        //得到分类id
        String keyAsString = bucket.getKeyAsString();
        catalogVo.setCatalogId(Long.parseLong(keyAsString));
        //得到分类名
        ParsedStringTerms catalogNameAgg = bucket.getAggregations().get("catalog_name_agg");
        String catalogName = catalogNameAgg.getBuckets().get(0).getKeyAsString();
        catalogVo.setCatalogName(catalogName);
        catalogVos.add(catalogVo);
    }
    result.setCatalogs(catalogVos);
    //===============以上可以从聚合信息中获取====================//
    //5、分页信息-页码
    result.setPageNum(param.getPageNum());
    //5、1分页信息、总记录数
    long total = hits.getTotalHits().value;
    result.setTotal(total);
    //5、2分页信息-总页码-计算
    int totalPages = (int) total % EsConstant.PRODUCT_PAGE_SIZE == 0 ?
            (int) total / EsConstant.PRODUCT_PAGE_SIZE : ((int) total / EsConstant.PRODUCT_PAGE_SIZE + 1);
    result.setTotalPages(totalPages);
    List<Integer> pageNavs = new ArrayList<>();
    for (int i = 1; i <= totalPages; i++) {
        pageNavs.add(i);
    }
    result.setPageNavs(pageNavs);
    //6、构建面包屑导航
    if (param.getAttrs() != null && param.getAttrs().size() > 0) {
        List<SearchResult.NavVo> collect = param.getAttrs().stream().map(attr -> {
            //1、分析每一个attrs传过来的参数值
            SearchResult.NavVo navVo = new SearchResult.NavVo();
            String[] s = attr.split("_");
            navVo.setNavValue(s[1]);
            R r = productFeignService.attrInfo(Long.parseLong(s[0]));
            if (r.getCode() == 0) {
                AttrResponseVo data = r.getData("attr", new TypeReference<AttrResponseVo>() {
                });
                navVo.setNavName(data.getAttrName());
            } else {
                navVo.setNavName(s[0]);
            }
            //2、取消了这个面包屑以后，我们要跳转到哪个地方，将请求的地址url里面的当前置空
            //拿到所有的查询条件，去掉当前
            String encode = null;
            try {
                encode = URLEncoder.encode(attr, "UTF-8");
                encode.replace("+", "%20");  //浏览器对空格的编码和Java不一样，差异化处理
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            String replace = param.get_queryString().replace("&attrs=" + attr, "");
            navVo.setLink("http://search.gulimall.com/list.html?" + replace);
            return navVo;
        }).collect(Collectors.toList());
        result.setNavs(collect);
    }
    return result;
}

三、异步与线程池

2.异步编排

- id: gulimall_host_route
  uri: lb://gulimall-product
  predicates:
    - Host=gulimall.com, item.gulimall.com

（4）将静态资源放到nginx

2.展示当前商品详情功能开发

• 创建线程池配置类
  

  @EnableConfigurationProperties(ThreadPoolConfigProperties.class)
  @Configuration//配置类
  public class MyThreadConfig {
  
      @Bean
      public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties pool) {
          //返回自定义线程池
          return new ThreadPoolExecutor(
                  pool.getCoreSize(),//通过配置文件配置参数
                  pool.getMaxSize(),
                  pool.getKeepAliveTime(),
                  TimeUnit.SECONDS,
                  new LinkedBlockingDeque<>(100000),
                  Executors.defaultThreadFactory(),
                  new ThreadPoolExecutor.AbortPolicy()
          );
      }
  }

• 创建线程池属性配置类
  

  @ConfigurationProperties(prefix = "gulimall.thread")
  // @Component
  @Data
  public class ThreadPoolConfigProperties {
      private Integer coreSize;
      private Integer maxSize;
      private Integer keepAliveTime;
  }

• 在application.properties配置文件中配置线程池信息
  

  #配置线程池
  gulimall.thread.coreSize=20
  gulimall.thread.maxSize=200
  gulimall.thread.keepAliveTime=10

@Override
public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
    SkuItemVo skuItemVo = new SkuItemVo();
    CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
        //1、sku基本信息的获取  pms_sku_info
        SkuInfoEntity info = this.getById(skuId);
        skuItemVo.setInfo(info);
        return info;
    }, executor);
    //3、4、5都要依赖1执行完接收响应数据后才能执行，所以都用thenAcceptAsync()
    CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync((res) -> {
        //3、获取spu的销售属性组合
        List<SkuItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrBySpuId(res.getSpuId());
        skuItemVo.setSaleAttr(saleAttrVos);
    }, executor);
    CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync((res) -> {
        //4、获取spu的介绍    pms_spu_info_desc
        SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId());
        skuItemVo.setDesc(spuInfoDescEntity);
    }, executor);
    CompletableFuture<Void> baseAttrFuture = infoFuture.thenAcceptAsync((res) -> {
        //5、获取spu的规格参数信息
        List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
        skuItemVo.setGroupAttrs(attrGroupVos);
    }, executor);
    //2与1无关，且无返回值，所以用runAsync()就行
    //2、sku的图片信息    pms_sku_images
    CompletableFuture<Void> imageFuture = CompletableFuture.runAsync(() -> {
        List<SkuImagesEntity> imagesEntities = skuImagesService.getImagesBySkuId(skuId);
        skuItemVo.setImages(imagesEntities);
    }, executor);
    //等待5个任务都完成，再返回vo
    CompletableFuture.allOf(saleAttrFuture, descFuture, baseAttrFuture, imageFuture).get();
    return skuItemVo;
}

五、登录认证服务

        登录不是简单查询一下输入的用户名和密码在不在数据库中就行了，项目一开始我们提到，所有的用户登录请求，都应该由OAuth认证中心来统一进行认证。

1.环境搭建

（1）创建认证模块

        

        

（2）模块初始化

（3）域名访问环境搭建

• 修改host文件

  # guli mall #
  192.168.163.131		gulimall.com
  192.168.163.131		search.gulimall.com
  192.168.163.131		item.gulimall.com
  192.168.163.131		auth.gulimall.com

• 配置nginx转发域名(*.gulimall.com)
• 配置网关转发域名

  - id: mall_auth_route
    uri: lb://gulimall-auth-server
    predicates:
      - Host=auth.gulimall.com

（1）相关配置

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.163.131:8848
    alicloud:
      sms:
        host: https://fesms.market.alicloudapi.com
        path: /sms/
        skin: 1
        sign: 175622
        appcode: 93b7e19861a24c519a7548b17dc16d75

（2）发送验证码组件

@ConfigurationProperties(prefix = "spring.cloud.alicloud.sms")
@Data
@Component
public class SmsComponent {
    private String host;
    private String path;
    private String skin;
    private String sign;
    private String appcode;
    public void sendCode(String phone, String code) {
        String method = "GET";
        Map<String, String> headers = new HashMap<>();
        // 最后在header中的格式(中间是英文空格)为 Authorization:APPCODE 93b7e19861a24c519a7548b17dc16d75
        headers.put("Authorization", "APPCODE " + appcode);
        Map<String, String> queries = new HashMap<String, String>();
        queries.put("code", code);
        queries.put("phone", phone);
        queries.put("skin", skin);
        queries.put("sign", sign);
        //JDK 1.8示例代码请在这里下载：  http://code.fegine.com/Tools.zip
        try {
            HttpResponse response = HttpUtils.doGet(host, path, method, headers, queries);
            //System.out.println(response.toString());如不输出json, 请打开这行代码，打印调试头部状态码。
            //状态码: 200 正常；400 URL无效；401 appCode错误； 403 次数用完； 500 API网管错误
            //获取response的body
            System.out.println(EntityUtils.toString(response.getEntity()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（3）发送短信接口

@Controller
@RequestMapping(value = "/sms")
public class SmsSendController {

    @Resource
    private SmsComponent smsComponent;

    /**
     * 提供给别的服务进行调用
     * @param phone
     * @param code
     * @return
     */
    @GetMapping(value = "/sendCode")
    public R sendCode(@RequestParam("phone") String phone, @RequestParam("code") String code) {
        //发送验证码
        smsComponent.sendCode(phone,code);
        return R.ok();
    }
}

（4）在认证服务模块中的登录controller编写发送验证码方法

@ResponseBody
@GetMapping(value = "/sms/sendCode")
public R sendCode(@RequestParam("phone") String phone) {
    //1、接口防刷
    String redisCode = stringRedisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + phone);
    if (!StringUtils.isEmpty(redisCode)) {
        //活动存入redis的时间，用当前时间减去存入redis的时间，判断用户手机号是否在60s内发送验证码
        long currentTime = Long.parseLong(redisCode.split("_")[1]);
        if (System.currentTimeMillis() - currentTime < 60000) {
            //60s内不能再发
            return R.error(BizCodeEnum.SMS_CODE_EXCEPTION.getCode(), BizCodeEnum.SMS_CODE_EXCEPTION.getMsg());
        }
    }
    //2、验证码的再次效验 redis.存key-phone,value-code
    int code = (int) ((Math.random() * 9 + 1) * 100000);
    String codeNum = String.valueOf(code);
    String redisStorage = codeNum + "_" + System.currentTimeMillis();
    //存入redis，防止同一个手机号在60秒内再次发送验证码
    stringRedisTemplate.opsForValue().set(AuthServerConstant.SMS_CODE_CACHE_PREFIX + phone,redisStorage, 10, TimeUnit.MINUTES);
    thirdPartFeignService.sendCode(phone, codeNum);

    return R.ok();
}

• encode()：对明文加密，返回盐值加密后的密文；
• matches(想验证的明文，正确密码的密文)：对明文进行验证，返回boolean值。

  // Spring 盐值加密
  BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
  //加密
  String encode = bCryptPasswordEncoder.encode("123456");
  //★对同一明文得到的密文是不同的，防止暴力解密
  //$2a$10$GT0TjB5YK5Vx77Y.2N7hkuYZtYAjZjMlE6NWGE2Aar/7pk/Rmhf8S 
  //$2a$10$cR3lis5HQQsQSSh8/c3L3ujIILXkVYmlw28vLA39xz4mHDN/NBVUi
  //验证
  boolean matches = bCryptPasswordEncoder.matches("123456", "$2a$10$GT0TjB5YK5Vx77Y.2N7hkuYZtYAjZjMlE6NWGE2Aar/7pk/Rmhf8S");

• OAuth：是一个开放标准，允许用户授权第三方网站访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方网站或分享他们数据的所有内容。
• OAuth2.0 ：对于用户相关的 OpenAPI（例如获取用户信息，动态同步，照片，日志，分享等），为了保护用户数据的安全和隐私，第三方网站访问用户数据前都需要显式的向用户征求授权。
  以用QQ登录****为例，授权流程如下：
       

• 向weibo申请OAuth2.0授权
  微博开放平台→微连接→创建应用→管理应用(如管理应用信息、设置成功和失败回调页)
• 参照OAuth2.0授权文档（https://open.weibo.com/wiki/Connect/login）实现授权社交登录：
  • 在页面点击微博登录跳转到微博登录页面——https://api.weibo.com/oauth2/authorize?client_id=填自己的App Key&response_type=code&redirect_uri=登录成功后的重定向uri；
  • 如果用户同意授权并登录成功，就会跳转到上面的重定向uri网页，并提供一个code，用来换取Access Token(访问令牌)；
  • 换取Access Toke：向 https://api.weibo.com/oauth2/access_token?client_id=App Key&client_secret=App Secret&grant_type=authorization_code&redirect_uri=重定向uri&code=CODE 发送post请求获取Access Token。
• 拿到Access Token后就可以向微博开放的接口获取用户的开放信息。

• 扩大session作用域：在给客户端返回session_id时，通过指定域名setDomain()来扩大session的作用域。
  

• ①session复制(同步)：让同一微服务的多个服务器之间进行session数据同步。
  
  
• ②客户端存储cookie：让客户端自己把信息保存到cookie中。
  
  
• ③hash一致性：利用负载均衡的机制，只要是同一个客户端访问的，就一直定位到同一台主机服务器，这样就实现了session数据的同步。
  
  
• ★④统一存储session：之前session都是存在各自服务器中，所以会造成数据不同步，现在我们可以对session进行统一存储，将每个服务器的session都存到一个DB或Redis中。可以用SpringSession来实现。
  
  

• 引入依赖

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

• 在application.yml中配置session的保存类型

  spring:
    session:
      store-type: redis  //我们用redis保存session

• 在主启动类上加注解

  @EnableRedisHttpSession 

@Configuration
public class GulimallSessionConfig {
    @Bean
    public CookieSerializer cookieSerializer() {
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
        //扩大作用域
        cookieSerializer.setDomainName("gulimall.com");
        cookieSerializer.setCookieName("GULISESSION");
        return cookieSerializer;
    }
    //用json进行序列化将缓存保存到redis
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }
}

（6）SpringSession 核心原理

5.单点登录SSO

（4）导入购物车页面

• 离线购物车(游客购物车)：未登录时加入购物车的商品，在关闭浏览器后，下次再次打开购物车，里面的商品应该是还在的。也就是说即使不登录，也能保存加入到购物车里的商品。
• 登录购物车(在线购物车)：用户在登录状态下加入购物车的商品。

• 在同一个浏览器下，离线购物车中的商品，在登录后要能合并到登录购物车，同时清空离线购物车中的商品。

• 对于登录购物车：
  • 用数据库存：购物车属于读写都频繁的操作，所以放在数据库压力太大了，不推荐。
  • 用redis存：redis可以解决读写高并发的问题，但是redis默认是非持久化的(基于内存)，所以还要解决redis持久化问题。
• 对于离线购物车：
  • 用cookie存：cookie是存在客户端中，没有将用户的购物车信息存到我们的后台服务器中，不利于大数据分析，推荐相关的喜好商品；
  • 用redis存：同上。

• 用 list 存：缺点是如果需要对购物车里的某个商品进行修改，如修改数量，就需要遍历list，然后找到对应商品，再修改(类似链表不适合检索的道理)。
  
• 用 hash 存：hash的key可以用skuId，value再对应该sku的其他信息，这样方便修改。
  
  

• 购物车vo——Cart
  
  
• 购物车里的购物项vo——CartItem
  
  

/**
    在执行目标方法之前，判断用户的登录状态.并封装传递给controller目标请求
 **/
public class CartInterceptor implements HandlerInterceptor {
    public static ThreadLocal<UserInfoTo> toThreadLocal = new ThreadLocal<>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        UserInfoTo userInfoTo = new UserInfoTo();
        HttpSession session = request.getSession();
        //获得当前登录用户的信息
        MemberResponseVo memberResponseVo = (MemberResponseVo) session.getAttribute(LOGIN_USER);
        if (memberResponseVo != null) {
            //用户登录了
            userInfoTo.setUserId(memberResponseVo.getId());
        }
        Cookie[] cookies = request.getCookies();
        if (cookies != null && cookies.length > 0) {
            for (Cookie cookie : cookies) {
                //user-key
                String name = cookie.getName();
                if (name.equals(TEMP_USER_COOKIE_NAME)) {
                    userInfoTo.setUserKey(cookie.getValue());
                    //标记为已是临时用户
                    userInfoTo.setTempUser(true);
                }
            }
        }
        //如果没有临时用户一定分配一个临时用户
        if (StringUtils.isEmpty(userInfoTo.getUserKey())) {
            String uuid = UUID.randomUUID().toString();
            userInfoTo.setUserKey(uuid);
        }
        //目标方法执行之前
        toThreadLocal.set(userInfoTo);
        return true;
    }
    /**
     * 业务执行之后，分配临时用户来浏览器保存
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        //获取当前用户的值
        UserInfoTo userInfoTo = toThreadLocal.get();
        //如果没有临时用户一定保存一个临时用户
        if (!userInfoTo.getTempUser()) {
            //创建一个cookie
            Cookie cookie = new Cookie(TEMP_USER_COOKIE_NAME, userInfoTo.getUserKey());
            //扩大作用域
            cookie.setDomain("gulimall.com");
            //设置过期时间
            cookie.setMaxAge(TEMP_USER_COOKIE_TIMEOUT);
            response.addCookie(cookie);
        }
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

• 解决商品重复提交问题
  使用重定向
• 获取和合并购物车
  • 获取临时购物车：直接根据临时用户id从redis中获取临时购物车中的所有购物项即可；
  • 获取登陆购物车：先判断临时购物车中有没有购物项，如果有，要先将临时购物车中的所有购物项加到登陆购物车中(合并购物车)，并清空临时购物车。然后再获取登录购物车的所有购物项。

• 信息流：用户信息、商品信息等；
• 资金流：付款、退款等金钱操作；
• 物流：商品的发货退货等物流状态。

（1）一个订单的完整组成

（3）订单流程

3.★订单登录拦截

• 远程调用member服务查询用户收货地址
  
• 远程查询购物车所有选中的购物项信息

• 直接访问购物车时，会在请求头的cookie中携带JSESSIONID，用来标注用户登录的session。
  
  
• Feign远程调用购物车服务时，在请求头中没有JSESSIONID，购物车就会认为用户没登录。
  • 原因：从Feign的源码入手，Feign的远程调用会先调用一些拦截器，创建一个新的请求模板，由于新模板中没有请求头信息，所以Feign用新请求访问购物车时就会导致购物车误以为用户没登录。
    
  • 解决：Feign在远程调用前要构造一个新请求，会调用一些拦截器，经过每个拦截器的apply()，之所以丢失请求头是因为之前没有拦截器，所以要携带请求头只需要加上请求拦截器(RequestInterceptor)，重写apply()加上请求头信息。
    
    如何加之前的请求头信息？
    -- 可以使用ThreadLocal来获取之前的请求头信息；
    -- 也可以使用RequestContextHolder(上下文保持器)来获取之前的请求头信息，原理还是通过ThreadLocal。
    

【★★异步下Feign远程调用丢失请求头问题】

• 上面我们分别远程调用member服务和购物车服务获取数据时，是串行化的同步调用(如下图)，为了提高性能我们可以将这两个远程调用改成异步执行。但是新的问题又来了，我们发现报了一个空指针异常，这个空指针是请求拦截器(RequestInterceptor)为空了，我们之前已经加上请求拦截器了，为什么还会为空呢？
  
  
• 原因：我们在请求拦截器RequestInterceptor中通过RequestContextHolder(上下文保持器)来获取老请求的请求头数据，之前同步调用时，从请求进来到拿到数据返回结果一直是同一个线程（72号线程），所以通过上下文保持器可以拿到老请求的数据；但是在将两次远程调用改为异步远程调用后，是由两个新线程(101、102号)来完成远程调用过程，会根据新线程的ThreadLocal来获取上下文中的数据，所以就获取不到老请求的数据了。
          
• 解决：在异步调用之前，先将主线程中的原始请求的上下文数据共享出来，再在新开启的异步任务中重新设置上下文数据，即可：
          

• 需要保证幂等性的常见情况：
  • 用户多次点击按钮
  • 用户页面回退再次提交
  • 微服务互相调用，由于网络问题，导致请求失败，feign就会触发重试机制，此时相当于进行了多次远程调用

• 令牌token机制
  • 原理
    可以在需要保证幂等性的操作执行前，先去获取token，并将token存在Redis中，然后在发送请求的时候带上这个token，服务器通过判断 token 是否在 redis 中有来判断是否是第一次请求，有就表示第一次请求，然后删除 token，继续执行业务；如果判断 redis 中没有token，就表示是重复操作，直接返回重复标记给 client，这样就保证了业务代码不会被重复执行。
  • token机制存在的问题
    • 删除token的时机
      ①先删除token再执行业务逻辑(推荐)：先删除 token，如果业务调用失败，就重新获取 token 再次请求。
      ②先执行业务逻辑再删除token：如果执行该业务耗时比较长，在业务未完成之前又有重复请求进来，此时token还没删，所以还会认为是第一次请求，这样就无法保证幂等性了。
    • 原子性操作
      如果token的获取、判断是否存在、删除不能保证原子性，在高并发下可能会导致重复获取token，无法保证幂等性。因此必须要保证获取、判断、删除token这三个操作的原子性。
      可以在 redis 使用 lua 脚本完成这个操作：

      if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end

• 各种锁机制
• 各种唯一约束
  • 数据库唯一索引约束：比如每次提交新订单都要在订单表中插入一条新纪录，我们可以给订单号order_id加上唯一约束，这样就保证了同一订单不能被多次插入，从而保证了订单提交的幂等性。
    
  • Redis Set 防重：我们知道Redis中的set不允许重复元素，因此可以利用set进行防重。在处理数据之前先计算数据的 MD5 将其放入 redis 的 set，每次处理数据前，先看这个 MD5 是否已经存在，存在说明重复，就不处理。
• 全局请求唯一id

• 当订单服务远程调用库存服务进行锁库存时，锁库存成功了，但是在给订单服务返回结果时由于网络中断等故障没有返回成功，订单服务就会报异常，进行订单回滚，但库存没有回滚。这种属于假失败。
• 多个微服务其中一个失败了回滚只能对本服务回滚，无法对其他成功完成的微服务进行回滚。比如锁库存已经成功了，但是扣减积分时出现了异常需要回滚，现在只能对积分进行回滚，而库存不能回滚了。

• 如果使用 Seata AT（Auto Transaction，自动事务）模式，需要为每个用到分布式事务的微服务创建一个 UNDO_LOG 表（回滚日志表）；
• 下载安装TC服务器——seata-server
• 配置并启动TC服务器
• 整合seata，导入依赖
• 注入代理数据源，所有想要用到分布式事务的微服务中使用seata DataSourceProxy代理自己的数据源
  
  
• 给分布式大事务的入口方法，添加全局事务@GlobalTransactional，每一个小事务(如远程调用的事务)添加@Transactional，即可实现分布式事务管理。

• 使用mq实现库存服务自动解锁：
          如果要解锁库存，首先需要给库存服务发一个消息(包含库存工作清单等，也就是要解锁哪些库存)， 同时库存解锁服务去订阅stock.release.stock.queue里的消息。 比如用路由键stock.release给stock-event-exchange发送了一个消息，交换机会把这个消息路由给stock.release.stock.queue，stock.release.stock.queue里边存的都是库存要解锁的消息，库存解锁服务订阅了该队列，它就会在后台慢慢地根据消息进行库存解锁。这样虽然不是强一致性，但是我们也强求数据一致，哪怕是二十分钟、三十分钟，乃至于一天以后把这个库存解锁了，实现最终一致就行。
  
• 需要库存解锁回滚的情况
  • 1）下订单成功，但订单没有支付被系统自动取消或被用户手动取消，都要解锁库存进行回滚
  • 2）下订单成功，库存锁定成功，但接下来的业务(如扣减积分)调用失败，导致订单回滚，之前锁定的库存就要自动解锁。

• 使用延迟队列实现定时关闭订单
          订单创建成功之后，使用order.create.order路由键将消息路由到order-event-exchange交换机，再由交换机路由到order.delay.queue里，如果过了30分钟还未支付订单，这个延时队列里面的消息就过期了(成为了死信)，然后通过order.release.order又路由回order-event-exchange交换机，再由交换机路由到order.release.order.queue，最终监听order.release.order.queue的释放订单服务，发现有消息(未支付订单)进来了，就会对其进行关闭订单。
  

• 1）由于网络问题，消息没有到达exchange；
• 2）消息到达exchange了，但是还没交给队列，就宕机了；
• 3）消费者从队列拿到消息还没消费就宕机了。

• 失败重试机制：无论以上哪种情况，只要消息发送失败，就要有重试机制。
          我们可以在发送消息前，把消息的详细信息记录到数据库，然后定期扫描数据库，重发失败的消息。
          
  
• 生产者、消费者确认机制：通过确认机制，可以判断消息是否发送失败。
  • 生产者确认机制：ConfirmCallback是成功抵达exchange确认，ReturnCallback是是否抵达mq确认(没有抵达mq才回发ReturnCallback)，所以可以在收到ReturnCallback时修改数据库中消息的发送状态。
  • 消费者确认机制：为了防止消费者收到消息后还未消费就宕机造成的消息丢失，我们可以开启手动ACK，消息消费成功才发送ACK。

• 1）将消费者的消费接口设计成幂等的；
• 2）在rabbitMQ中，每一个发送过来的消息都有一个redelivered字段，用来标记该消息是不是第一次发送过来的，true就代表不是第一次发送的，是重复的消息。

2.项目整合支付宝

• 特殊字符

  ,：枚举

  • (cron="7,9,23 * * * * ?")：代表任意时刻的第7，9，23秒启动这个任务；

  -：范围

  • (cron="7-20 * * * * ?")：任意时刻的 7 到 20 秒之间，每秒启动一次；

  *：任意

  • 指定位置的任意时刻都可以；

  /：步长，每...一次

  • (cron="7/5 * * * * ?")：第 7 秒启动，每 5 秒一次；
  • (cron="*/5 * * * * ?")：任意时间启动之后，每 5 秒一次；

  ?：（出现在日和周几的位置）为了防止日和周冲突，如果1个精确了，另一个就得写?

  • (cron="* * * 1 * ?")：每月的 1 号，启动这个任务，如果两个都写精确值的话，可能会导致冲突，所以其中一个要使用?

  L：（出现在日和周的位置）”，last：最后一个

  • (cron="* * * ? * 3L")：每月的最后一个周二

  W：  写在日的位置，代表工作日(Work Day)

  • (cron="* * * W * ?")：每个月的工作日触发
  • (cron="* * * LW * ?")：每个月的最后一个工作日触发

  #： 第几个

  • (cron="* * * ? * 5#2")：5 代表周四，#2 代表第 2 个，合起来就是每个月的第 2 个周四 
• 示例
  
  

• ①可以利用异步编排——CompletableFuture.runAsync()，自己提交到线程池，让任务异步执行；
• ②直接让任务异步执行，可以替代CompletableFuture：
  • 首先在类上面标注@EnableAsync，开启异步任务功能
  • 然后在方法上标注@Async，执行异步任务
  • 自动配置类参考 TaskExecutionAutoConfiguration
  • 它在配置文件中的线程池属性是：spring.task.execution.pool.xxx

（3）定时上架要秒杀的商品

        

• 可以使用LocalDate和LocalTime构造时间。
  
• 缓存活动信息(每一场活动对应哪些商品)、缓存商品信息(就不用每次都从数据库中查了)
• 随机码：用UUID实现。是一种保护机制，为了防止有用户在得知秒杀请求时，发送大量请求对商品进行秒杀，我们采取了随机码的方式，即每个要参加秒杀的商品，都有一个随机码，只有通过正常提交请求的流程才可以获取，避免了恶意秒杀。
  
  

（2）使用分布式锁解决问题

• 限流：
  限流采用前端限流+后端限流。
  • 前端限流可以给按钮设置点击频率，比如点了第一次抢购之后，一秒以后才能点第二、第三次。通过前端的限流，可以限制一部分的流量。但是如果用恶意脚本去无限制的访问，前端也限不住。
  • 后端限流：用前端限流限制了一些请求，其他请求来到后台时，后台再来识别哪些请求是用户的正常行为，哪些是恶意行为，然后再进行过滤；包括即使是用户的正常行为，服务器也可以对其限流，比如1秒点了十几次，我们只放行一两次，所以通过一步一步的操作，每到达一层，无论是前端还是后端，我们都给它来做一个限流的操作，把不合理的过滤掉，哪怕请求是合理的，点的次数太多了，也将其限制起来，最终后台集群里边收到的流量就会少很多。
• 熔断：
  加入熔断机制，只要调用链的任何一个服务出现问题，我们就给它返回快速失败。这样一失败以后，就能保证我们整个调用链是一个快速返回的，而不是阻塞的。 所以我们的熔断先保证快速失败，如果哪个服务出现问题，我们把它断路之后，相当于就把它隔离了，这样也不会影响别的服务。
  
• 降级：
  
  如果我们自己的服务出现问题，我们也可以让它降级运行，比如流量太大了，秒杀服务快被压垮了，我们可以将一部分的流量直接引导到一个降级页面，告知用户当前服务太忙，请稍后再访问。

6.目前已有的功能

7.登录检查功能——使用拦截器实现登录检查

• 优点：
          从秒杀请求进来，只需要进行一系列判断处理，一直到后面的给前端用户通知，这期间没有操作过一次数据库（因为我们通过定时器提前将要秒杀的商品缓存到了Redis），没做过任何一次远程调用，这是一个非常快的流程，我们只需要校验好所有的合法性就行。因为所有的数据我们都在缓存里边放着。一切正常以后，我们给秒杀订单快速的创建一个单号。然后告诉前端个单号已经准备好了，后台的订单服务，再慢慢的消费。
• 缺点：
          秒杀系统将消息放进mq中，如果说订单服务炸了，就没有消费者来消费这个订单，会导致订单的后续信息准备不好，用户一直支付不成功，所以这一块的后续处理，跟前面的整套业务又不一样，需要加入一些独立的业务处理能力。

@Override
public String kill(String killId, String randomCode, Integer num) {
    MemberTO memberTO = LoginUserInterceptor.threadLocal.get();
    // 获取当前killid的sku信息
    BoundHashOperations<String, String, String> skusOperations = stringRedisTemplate
            .boundHashOps(SeckillConstant.SECKILL_SKU_PREFIX);
    String jsonStr = skusOperations.get(killId);
    if (StringUtils.isNotEmpty(jsonStr)) {
        SeckillSkuRedisDTO seckillSkuRedisDTO = JSON.parseObject(jsonStr, SeckillSkuRedisDTO.class);
        // 校验时间
        long now = new Date().getTime();
        Long startTime = seckillSkuRedisDTO.getStartTime();
        Long endTime = seckillSkuRedisDTO.getEndTime();
        long ttl = endTime - now;
        if (now >= startTime || now <= endTime) {
            // 校验随机码
            if (seckillSkuRedisDTO.getRandomCode().equals(randomCode)) {
                // 验证购买数量是否合理
                if (num <= seckillSkuRedisDTO.getSeckillSkuRelationDTO().getSeckillLimit()) {
                    // 校验用户是否已经购买过，只要秒杀成功就去redis占位absent，需要自动过期，
                    // userId_promotionSessionId_skuId，end-now，milliseconds
                    String key = memberTO.getId() + "_" + killId;
                    Boolean absent = stringRedisTemplate.opsForValue().setIfAbsent(key, num.toString(), ttl,
                            TimeUnit.MILLISECONDS);
                    if (absent) {
                        // 占位成功，说明没买过，减信号量，tryAcquire (num,100,seconds)
                        RSemaphore semaphore = redissonClient.getSemaphore(SeckillConstant
                                .SECKILL_SKU_STOCK_SEMAPHORE + randomCode);
                        try {
                            boolean acquire = semaphore.tryAcquire(num, 100, TimeUnit.MILLISECONDS);
                            if (acquire) {
                                // 秒杀成功，快速下单
                                String orderSn = IdWorker.getTimeId();
                                return orderSn;
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    return null;
}

（4）秒杀后创建订单的流程