@Configuration
public class GulimallElasticSearchConfig {
    // request设置项
    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
        // builder.addHeader("Authorization", "Bearer " + TOKEN);
        // builder.setHttpAsyncResponseConsumerFactory(
        //         new HttpAsyncResponseConsumerFactory
        //                 .HeapBufferedResponseConsumerFactory(30 * 1024 * 1024 * 1024));
        COMMON_OPTIONS = builder.build();
    }
    // 注入RestHighLevelClient
    @Bean
    public RestHighLevelClient esRestClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.128.129", 9200, "http")));
        return client;
    }
}

package com.atguigu.gulimall.gulimallsearch;

import com.alibaba.fastjson.JSON;
import com.atguigu.gulimall.gulimallsearch.config.GulimallElasticSearchConfig;
import lombok.Data;
import lombok.ToString;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.Avg;
import org.elasticsearch.search.aggregations.metrics.AvgAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;

@RunWith(SpringRunner.class)
@SpringBootTest
public class GulimallSearchApplicationTests {

    @Autowired
    private RestHighLevelClient client;

    /*\
     * 测试复杂检索
     */
    @Test
    public void complexSearch() throws IOException {
        // 创建检索请求
        SearchRequest searchRequest = new SearchRequest();
        // 指定索引
        searchRequest.indices("bank");
        // 指定检索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        /*
         * searchSourceBuilder.query();
         * searchSourceBuilder.aggregation();
         * searchSourceBuilder.from()
         * searchSourceBuilder.size()
         */
        /*
         * searchSourceBuilder.query(QueryBuilders.matchAllQuery());
         * searchSourceBuilder.query(QueryBuilders.matchPhraseQuery());
         * searchSourceBuilder.query(QueryBuilders.matchQuery("address", "mill"));
         */
        /*
         * searchSourceBuilder.aggregation(AggregationBuilders.avg("").field(""));
         * searchSourceBuilder.aggregation(AggregationBuilders.terms("").field("").size(99));
         * ……
         */
        searchSourceBuilder.query(QueryBuilders.matchQuery("address", "mill"));
        //1.2）、按照年龄的值分布进行聚合
        TermsAggregationBuilder ageAgg = AggregationBuilders.terms("ageAgg").field("age").size(10);
        searchSourceBuilder.aggregation(ageAgg);

        //1.3）、计算平均薪资
        AvgAggregationBuilder balanceAvg = AggregationBuilders.avg("balanceAvg").field("balance");
        searchSourceBuilder.aggregation(balanceAvg);
        System.out.println("检索条件: " + searchSourceBuilder.toString());
        // 指定检索条件对象
        searchRequest.source(searchSourceBuilder);
        // 执行检索
        SearchResponse response = client.search(searchRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        // 分析结果;
        // 获得hit结果
        SearchHits hits = response.getHits();
        SearchHit[] hitsHits = hits.getHits();
        for (SearchHit hit : hitsHits) {
            String sourceAsString = hit.getSourceAsString();
            Accout accout = JSON.parseObject(sourceAsString, Accout.class);
            System.out.println("accout：" + accout);
        }
        //获取这次检索到的分析信息；
        Aggregations aggregations = response.getAggregations();
//        for (Aggregation aggregation : aggregations.asList()) {
//            System.out.println("当前聚合："+aggregation.getName());
//        }
        Terms terms = aggregations.get("ageAgg");
        for (Terms.Bucket bucket : terms.getBuckets()) {
            String keyAsString = bucket.getKeyAsString();
            System.out.println("年龄：" + keyAsString + "==>" + bucket.getDocCount());
        }
        Avg balanceAvg1 = aggregations.get("balanceAvg");
        System.out.println("平均薪资：" + balanceAvg1.getValue());
    }

    @ToString
    @Data
    static class Accout {

        private int account_number;
        private int balance;
        private String firstname;
        private String lastname;
        private int age;
        private String gender;
        private String address;
        private String employer;
        private String email;
        private String city;
        private String state;

    }

    /*\
     * 测试存储
     */
    @Test
    public void indexData() throws IOException {
        // 创建indexRequest，传入index值
        IndexRequest indexRequest = new IndexRequest("users");
        indexRequest.id("1");
        // 传入文档(jsonString格式)
        User user = new User("张三", "男", 18);
        String jsonString = JSON.toJSONString(user);
        indexRequest.source(jsonString, XContentType.JSON);
        // 执行操作并获得响应数据
        IndexResponse response = client.index(indexRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        System.out.println(response);
    }

    // 自定义类型
    @Data
    static class User {
        private String username;
        private String gender;
        private Integer age;

        public User(String username, String gender, Integer age) {
            this.username = username;
            this.gender = gender;
            this.age = age;
        }
    }

    @Test
    public void contextLoads() {
        System.out.println(client);
    }

}

@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<Attrs> attrs;

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

@Data
public class SkuHasStockTo {
    private Long skuId;
    private Boolean hasStock;
}

@RestController
@RequestMapping("product/spuinfo")
public class SpuInfoController {
    @Autowired
    private SpuInfoService spuInfoService;

    /**
     * 商品上架，保存到ES中
     */
    @PostMapping("/{spuId}/up}")
    public R spuUp(@PathVariable("spuId") Long spuId) {
        spuInfoService.spuUp(spuId);
        return R.ok();
    }
}

    /*
     * 商品上架
     */
    @Override
    public void spuUp(Long spuId) {
        // 将数据存入SkuEsModel对象当中

        // 1 查出sku品牌和分类信息（不需要对每个sku都查询，所以放在stream外面）
        SpuInfoEntity spuInfoEntity = this.getById(spuId);
        BrandEntity brandEntity = brandService.getById(spuInfoEntity.getBrandId());
        Long brandId = brandEntity.getBrandId();
        String brandLogo = brandEntity.getLogo();
        String brandName = brandEntity.getName();
        CategoryEntity categoryEntity = categoryService.getById(spuInfoEntity.getCatalogId());
        String categoryName = categoryEntity.getName();

        // 2 查出sku的attr,并且是可以被全文检索的
        List<ProductAttrValueEntity> baseAttrList = productAttrValueService.baseAttrListForSpu(spuId);
        List<Long> attrIdList = baseAttrList.stream().map(attr -> {
            return attr.getAttrId();
        }).collect(Collectors.toList());

        // 根据查出的所有attr找出可以被全文检索的
        List<Long> searchAttrIdList = attrService.getIdsCanSearch(attrIdList);
        // 使用SET集合方便判断是否存在指定id
        Set<Long> idSet = new HashSet<>(searchAttrIdList);

        List<SkuEsModel.Attrs> skuEsModelAttrsList = baseAttrList.stream().filter(attr -> {
            return idSet.contains(attr.getAttrId());
        }).map(attr -> {
            SkuEsModel.Attrs attrEntity = new SkuEsModel.Attrs();
            BeanUtils.copyProperties(attr, attrEntity);
            return attrEntity;
        }).collect(Collectors.toList());


        // 3 查出当前spuid对应的sku信息
        List<SkuInfoEntity> skuInfoEntities = skuInfoService.getSkuListBySpuId(spuId);

        Map<Long, Boolean> skuHasStockCollect = new HashMap<>();
        try {
            // 3.5 查出所有sku的是否有库存信息
            List<SkuHasStockTo> skuHasStockList = wareFeignService.getSkuHasStockList(skuInfoEntities.stream().map(SkuInfoEntity::getSkuId).collect(Collectors.toList()));
            // 封装到map当中，可以直接查询对应key的value
            skuHasStockCollect = skuHasStockList.stream().collect(Collectors.toMap(SkuHasStockTo::getSkuId, item -> item.getHasStock()));
        } catch (Exception e) {
            log.error("库存服务远程调用异常：原因{}", e);
        }

        // 4 封装每个sku信息
        Map<Long, Boolean> finalSkuHasStockCollect = skuHasStockCollect;
        List<SkuEsModel> upSku = skuInfoEntities.stream().map(skuInfo -> {
            SkuEsModel skuEsModel = new SkuEsModel();
            BeanUtils.copyProperties(skuInfo, skuEsModel);
            skuEsModel.setSkuPrice(skuInfo.getPrice());
            skuEsModel.setSkuImg(skuInfo.getSkuDefaultImg());
            // 远程调用库存系统是否有库存
            if (finalSkuHasStockCollect == null) {
                skuEsModel.setHasStock(true);
            } else {
                skuEsModel.setHasStock(finalSkuHasStockCollect.get(skuInfo.getSkuId()));
            }
            skuEsModel.setHotScore(0L);
            skuEsModel.setBrandId(brandId);
            skuEsModel.setBrandImg(brandLogo);
            skuEsModel.setBrandName(brandName);
            skuEsModel.setCatalogName(categoryName);
            skuEsModel.setAttrs(skuEsModelAttrsList);
            return skuEsModel;
        }).collect(Collectors.toList());

        // 5 发给ES
        R r = searchFeignService.productStatusUp(upSku);
        if (r.getCode() == 0) {
            // 远程调用成功
            // 修改spu的状态为上架
            SpuInfoEntity spu = new SpuInfoEntity();
            spu.setId(spuId);
            spu.setPublishStatus(ProductConstant.StatusEnum.SPU_UP.getCode());
            this.updateById(spu);
        } else {
            // TODO 远程调用失败
        }
    }
}

@FeignClient("gulimall-ware")
public interface WareFeignService {
    /*
     * 检查每个sku是否又库存
     */
    @PostMapping("/ware/waresku/hasstock")
    R getSkuHasStockList(@RequestBody List<Long> skuIdList);
}

@FeignClient("gulimall-search")
public interface SearchFeignService {
    @PostMapping("/search/save/product")
    R productStatusUp(@RequestBody List<SkuEsModel> skuEsModelList);
}

public class R<T> extends HashMap<String, Object> {
    private static final long serialVersionUID = 1L;

    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

@RestController
@RequestMapping("ware/waresku")
public class WareSkuController {
    @Autowired
    private WareSkuService wareSkuService;
    /*
     * 检查每个sku是否又库存
     */
    @PostMapping("/hasstock")
    public List<SkuHasStockTo> getSkuHasStockList(@RequestBody List<Long> skuIdList) {
        List<SkuHasStockTo> hasStock = wareSkuService.getSkuHasStockList(skuIdList);
        return hasStock;
    }
}

/*
 * 检查每个sku是否又库存
 */
@Override
public List<SkuHasStockTo> getSkuHasStockList(List<Long> skuIdList) {
    List<SkuHasStockTo> voList = skuIdList.stream().map(skuId -> {
        SkuHasStockTo skuHasStockVo = new SkuHasStockTo();
        Long count = baseMapper.getSkuStock(skuId);
        skuHasStockVo.setSkuId(skuId);
        // 可能没有库存返回null
        skuHasStockVo.setHasStock(count != null && count > 0);
        return skuHasStockVo;
    }).collect(Collectors.toList());
    return voList;
}

@RestController
@RequestMapping("/search")
public class ElasticSearchController {

    @Autowired
    ElasticSearchService searchService;

    /**
     * 上架商品
     *
     * @param skuEsModelList
     * @return
     */
    @PostMapping("/product")
    public R productStatusUp(@RequestBody List<SkuEsModel> skuEsModelList) {
        searchService.productUp(skuEsModelList);
        return R.ok();
    }

}

@Slf4j
@Service
public class ElasticSearchServiceImpl implements ElasticSearchService {

    @Autowired
    RestHighLevelClient client;

    /**
     * 上架商品
     *
     * @param skuEsModelList
     * @return
     */
    @Override
    public Boolean productUp(List<SkuEsModel> skuEsModelList) throws IOException {
        // 创建索引
        BulkRequest bulkRequest = new BulkRequest();
        for (SkuEsModel skuEsModel : skuEsModelList) {
            //构造保存请求
            IndexRequest indexRequest = new IndexRequest(EsConstant.PRODUCT_INDEX);
            indexRequest.id(String.valueOf(skuEsModel.getSkuId()));
            indexRequest.source(JSON.toJSONString(skuEsModel), XContentType.JSON);
            // 保存请求添加到bulk中
            bulkRequest.add(indexRequest);
        }
        // 执行批量操作
        BulkResponse bulk = client.bulk(bulkRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        // TODO 如果有错误可以处理
        boolean hasFailures = bulk.hasFailures();
        List<String> collect = Arrays.stream(bulk.getItems()).map(item -> {
            return item.getId();
        }).collect(Collectors.toList());
        log.error("商品上架信息：{}", collect);
        return hasFailures;
    }
}

@Controller // 不适用RESTController
public class IndexController {
    @Autowired
    CategoryService categoryService;
    @GetMapping({"/", "/index.html"})
    public String indexPage(Model model) {
        // 1 查出所有一级分类
        List<CategoryEntity> categoryEntityList = categoryService.getLevel1List();

        // thymeleaf已经有了默认前缀，定位到classpath:/resources/templates
        // 默认后缀 html
        model.addAttribute("categoryList", categoryEntityList);
        return "index";
    }
}

/**
 * 前台：渲染首页
 */
@Override
public List<CategoryEntity> getLevel1List() {
    List<CategoryEntity> categoryEntityList = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
    return categoryEntityList;
}

/*
 * 二级分类VO
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Catalog2Vo {
    // 这个属性名要和前端需要的JSON对应
    private String catalog1Id;  // 一级父分类id
    private List<Catalog3Vo> catalog3List;  // 三级分类（本vo为二级分类）
    private String id;
    private String name;

    /*
     * 三级分类VO
     */
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public static class Catalog3Vo {
        private String catalog2Id;
        private String id;
        private String name;
    }
}

/*
 * 渲染二级、三级分类
 * 这里的路径与catalogLoader.js中发送请求的路径一致
 */
@ResponseBody   // 返回值以JSON方式返回，且不需要跳转页面
@GetMapping("/index/catalog.json")
public Map<String, List<Catalog2Vo>> getCatalogJson(Model model) {
    Map<String, List<Catalog2Vo>> category = categoryService.getCatalogJson();
    return category;
}

/*
 * 渲染二级、三级分类
 */
@Override
public Map<String, List<Catalog2Vo>> getCatalogJson() {
    List<CategoryEntity> level1List = this.getLevel1List();
    // 封装数据
    Map<String, List<Catalog2Vo>> catalogMap = level1List.stream().collect(Collectors.toMap(k -> {
        return k.getCatId().toString();
    }, parent -> {
        // 将二级分类的内容封装到一级分类当中
        List<CategoryEntity> children2List = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", parent.getCatId()));
        List<Catalog2Vo> catalog2VoList = null;
        if (children2List != null) {
            catalog2VoList = children2List.stream().map(child2 -> {
                Catalog2Vo catalog2Vo = new Catalog2Vo(parent.getCatId().toString(), null, child2.getCatId().toString(), child2.getName());
                // 封装三级分类信息
                List<CategoryEntity> children3List = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", child2.getCatId()));
                if (children3List != null) {
                    List<Catalog2Vo.Catalog3Vo> catalog3VoList = children3List.stream().map(child3 -> {
                        Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo(child2.getCatId().toString(), child3.getCatId().toString(), child3.getName());
                        return catalog3Vo;
                    }).collect(Collectors.toList());
                    catalog2Vo.setCatalog3List(catalog3VoList);
                }
                return catalog2Vo;
            }).collect(Collectors.toList());
        }
        return catalog2VoList;
    }));
    return catalogMap;
}

/*
 * 渲染二级、三级分类
 */
@Override
public Map<String, List<Catalog2Vo>> getCatalogJson() {
    /*
     * 优化
     * 多次查询数据库 -》 一次查询
     */
    // 一次查询数据库，获得所有的分类
    List<CategoryEntity> allCatList = baseMapper.selectList(null);
    // 获得一级分类
    List<CategoryEntity> level1List = getCatListByParentCid(allCatList, 0L);
    // 封装数据
    Map<String, List<Catalog2Vo>> catalogMap = level1List.stream().collect(Collectors.toMap(k -> {
        return k.getCatId().toString();
    }, parent -> {
        // 将二级分类的内容封装到一级分类当中
        List<CategoryEntity> children2List = getCatListByParentCid(allCatList, parent.getCatId());
        List<Catalog2Vo> catalog2VoList = null;
        if (children2List != null) {
            catalog2VoList = children2List.stream().map(child2 -> {
                Catalog2Vo catalog2Vo = new Catalog2Vo(parent.getCatId().toString(), null, child2.getCatId().toString(), child2.getName());
                // 封装三级分类信息
                List<CategoryEntity> children3List = getCatListByParentCid(allCatList, child2.getCatId());
                if (children3List != null) {
                    List<Catalog2Vo.Catalog3Vo> catalog3VoList = children3List.stream().map(child3 -> {
                        Catalog2Vo.Catalog3Vo catalog3Vo = new Catalog2Vo.Catalog3Vo(child2.getCatId().toString(), child3.getCatId().toString(), child3.getName());
                        return catalog3Vo;
                    }).collect(Collectors.toList());
                    catalog2Vo.setCatalog3List(catalog3VoList);
                }
                return catalog2Vo;
            }).collect(Collectors.toList());
        }
        return catalog2VoList;
    }));
    return catalogMap;
}

/*
 * 根据parentCid查询下级分类
 */
private List<CategoryEntity> getCatListByParentCid(List<CategoryEntity> allCatList, Long parentCid) {
    // return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", parent.getCatId()));
    List<CategoryEntity> collect = allCatList.stream().filter(categoryEntity -> {
        return categoryEntity.getParentCid().equals(parentCid);
    }).collect(Collectors.toList());
    return collect;
}

@Test
public void redis() {
    ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();
    // 保存
    valueOperations.set("hello", "hello_" + UUID.randomUUID());
    // 查询
    String hello = valueOperations.get("hello");
    System.out.println("之前保存的数据是： " + hello);
}

/*
 * 渲染二级、三级分类(使用缓存)
 */
@Override
public Map<String, List<Catalog2Vo>> getCatalogJson() {
    String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
    if (StringUtils.isEmpty(catalogJSON)) {
        // 缓存中没有
        // 查询并封装
        Map<String, List<Catalog2Vo>> catalogJsonFromDb = getCatalogJsonFromDb();
        // 放入缓存 (注意存入JSON字符串)
        redisTemplate.opsForValue().set("catalogJSON", JSON.toJSONString(catalogJsonFromDb));
        return catalogJsonFromDb;
    }
    // 从缓存中拿数据
    Map<String, List<Catalog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catalog2Vo>>>() {
    });
    return result;
}

/**
 * 修改(级联更新，连表更新)
 */
@Caching(evict = {
        @CacheEvict(cacheNames = "category", key = "'level1Category1'"),  // 删除缓存
        @CacheEvict(cacheNames = "category", key = "'level1Category2'")
})
@Override
@Transactional
public void updateDetail(CategoryEntity category) {
    this.updateById(category);
    categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());
}
/**
 * 前台：渲染首页，一级分类
 */
@Cacheable({"category"})  // @Cacheable(缓存分区名)，如果缓存中有则该方法不会被调用，否则会调用方法并将结果放入缓存
@Override
public List<CategoryEntity> getLevel1List() {
    List<CategoryEntity> categoryEntityList = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
    return categoryEntityList;
}

public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock() {
//1、 占分布式锁。 去 redis 占坑String uuid = UUID.randomUUID().toString();
Boolean lock =
redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,TimeUnit.SECONDS);
if(lock){
System.out.println("获取分布式锁成功...");
//加锁成功... 执行业务
//2、 设置过期时间， 必须和加锁是同步的， 原子的
//redisTemplate.expire("lock",30,TimeUnit.SECONDS);
Map<String, List<Catelog2Vo>> dataFromDb;
try{
dataFromDb = getDataFromDb();
}finally {
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1]) else return 0 end";
//删除锁
Long lock1 = redisTemplate.execute(new
DefaultRedisScript<Long>(script, Long.class)
, Arrays.asList("lock"), uuid);
} //
获取值对比+对比成功删除=原子操作 lua 脚本解锁
// String lockValue = redisTemplate.opsForValue().get("lock");
// if(uuid.equals(lockValue)){
// //删除我自己的锁
// redisTemplate.delete("lock");//删除锁
// }
return dataFromDb;
}else {
//加锁失败...重试。 synchronized ()
//休眠 100ms 重试
System.out.println("获取分布式锁失败...等待重试");
try{
Thread.sleep(200);
}catch (Exception e){
} r
eturn getCatalogJsonFromDbWithRedisLock();//自旋的方式
}
}

@Configuration
public class MyRedissonConfig {
    /*
     * 所有对redisson的使用都是通过client对象
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        // 创建配置
        Config config = new Config();
        // 单redis节点模式
        config.useSingleServer().setAddress("redis://192.168.128.129:6379");
        return Redisson.create(config);
    }
}

/**
 * 封装页面所有可能传递过来的条件
 */
@Data
public class SearchParamVo {
    private String keyword; // 全文匹配关键字
    private Long catalog3Id;    // 三级分类id
    /**
     * sort=saleCount_asc/desc
     * sort=skuPrice_asc/desc
     * sort=hotScore_asc/desc
     */
    private String sort;    // 排序条件
    private Integer hasStock;   // 是否有货
    private String skuPrice;    // 价格区间
    private List<Long> brandId;   // 品牌id 可多选
    private List<String> attrs; // 按照属性进行筛选
    private Integer pageNum;    // 页码
}

/**
 * 检索返回数据模型
 */
@Data
public class SearchResultVo {
    private List<SkuEsModel> products;  //sku在elasticsearch中的模型

    // 分页信息
    private Integer pageNum;    // 当前页码
    private Long total; // 总记录数
    private Integer totalPages; // 总页码

    private List<BrandVo> brands;   // 当前查询到的所有涉及到的品牌
    private List<CatalogVo> catalogs;   // 当前查询到的所有涉及到的分类
    private List<AttrVo> attrs;     // 当前查询到的所有涉及到的属性

    /**
     * 内部类，品牌信息
     */
    @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;
    }

}

@Service
public class MallSearchServiceImpl implements MallSearchService {

    @Autowired
    private RestHighLevelClient client;

    /*
     * 根据keyword检索所有商品
     */
    @Override
    public SearchResultVo search(SearchParamVo searchParamVo) {
        // 准备检索请求
        SearchRequest searchRequest = buildSearchRequest(searchParamVo);
        try {
            // 执行检索请求
            SearchResponse response = client.search(searchRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 分析响应数据并封装
        SearchResult searchResult = buildSearchResult();


        return null;
    }

    /*
     * 创建检索结果
     */
    private SearchResult buildSearchResult() {
        return null;
    }

    /*
     * 创建检索请求
     */
    private SearchRequest buildSearchRequest(SearchParamVo param) {
        // 指定检索条件,详见dsl.json
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 查询：模糊匹配，过滤（按照属性、分类、品牌、价格区间、库存）
        // 1 query -> bool 开始
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        // 1.1 bool -> must 模糊匹配
        // must -> match
        if (!StringUtils.isEmpty(param.getKeyword())) {
            MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("skuTitle", param.getKeyword());
            boolQuery.must(matchQuery);
        }
        // 1.2 bool -> filter 过滤
        // filter -> 第一个term 按照分类过滤
        if (param.getCatalog3Id() != null) {
            TermQueryBuilder termQuery = QueryBuilders.termQuery("catalogId", param.getCatalog3Id());
            boolQuery.filter(termQuery);
        }
        // filter -> 第二个terms 按照品牌过滤
        if (param.getBrandId() != null) {
            TermsQueryBuilder termsQuery = QueryBuilders.termsQuery("brandId", param.getBrandId());
            boolQuery.filter(termsQuery);
        }
        // filter -> 第三个nested 按照属性过滤
        if (param.getAttrs() != null && param.getAttrs().size() > 0) {
            // 操作每一个attr(每一个attr都有一个nested)
            for (String attrStr : param.getAttrs()) {
                // nested -> query -> bool
                BoolQueryBuilder nestedBool = QueryBuilders.boolQuery();
                // 页面提交格式：attr = 1_5寸:8寸
                String[] strings = attrStr.split("_");
                String attrId = strings[0];
                String[] attrValues = strings[1].split(":");
                // bool -> must -> term、terms
                nestedBool.must(QueryBuilders.termQuery("attrs.attrId", attrId));
                nestedBool.must(QueryBuilders.termsQuery("attrs.attrValue", attrValues));
                boolQuery.filter(QueryBuilders.nestedQuery("attrs", nestedBool, ScoreMode.None));
            }
        }
        
        // filter -> 第四个term 按照库存过滤
        if (param.getHasStock() != null) {
            TermQueryBuilder termQuery = QueryBuilders.termQuery("hasStock", param.getHasStock() == 1);
            boolQuery.filter(termQuery);
        } else {
            TermQueryBuilder termQuery = QueryBuilders.termQuery("hasStock", true);
            boolQuery.filter(termQuery);
        }
        // filter -> 第四个range 按照价格区间过滤
        if (!StringUtils.isEmpty(param.getSkuPrice())) {
            RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("skuPrice");
            String[] priceRange = param.getSkuPrice().split("_");
            if (param.getSkuPrice().startsWith("_")) {
                //  _xxx, 小于
                rangeQuery.lte(priceRange[1]);
            } else if (param.getSkuPrice().endsWith("_")) {
                //  xxx_, 大于
                rangeQuery.gte(priceRange[0]);
            } else {
                // 区间
                rangeQuery.gte(priceRange[0]).lte(priceRange[1]);
            }
            boolQuery.filter(rangeQuery);
        }
        searchSourceBuilder.query(boolQuery);

        // 排序、分页、高亮
        // 2 sort
        if (!StringUtils.isEmpty(param.getSort())) {
            String sort = param.getSort();
            String[] sortValue = sort.split("_");
            searchSourceBuilder.sort(sortValue[0], SortOrder.fromString(sortValue[1]));
        }
        // 2 from sieze
        if (param.getPageNum() != null) {
            searchSourceBuilder.from((param.getPageNum() - 1) * EsConstant.PAGE_SIZE);
        } else {
            searchSourceBuilder.from(0);
        }
        searchSourceBuilder.size(EsConstant.PAGE_SIZE);
        // 2 highlight
        if (!StringUtils.isEmpty(param.getKeyword())) {
            searchSourceBuilder.highlighter(new HighlightBuilder().field("skuTitle").preTags("<b style='color:red'>").postTags("</b>"));
        }

        // TODO 聚合分析
        // 3 aggs

        String s = searchSourceBuilder.toString();
        System.out.println("构建的DSL：" + s);


        // 创建request，指定索引、检索条件
        SearchRequest searchRequest = new SearchRequest(new String[]{EsConstant.PRODUCT_INDEX}, searchSourceBuilder);
        return searchRequest;
    }
}

// 聚合分析
// 3 aggs
// 3.1 品牌聚合
TermsAggregationBuilder brand_agg = AggregationBuilders.terms("brand_agg").field("brandId").size(EsConstant.BRAND_SIZE);
// 3.1 子聚合
brand_agg.subAggregation(AggregationBuilders.terms("brand_img_agg").field("brandImg").size(1));
brand_agg.subAggregation(AggregationBuilders.terms("brand_name_agg").field("brandName").size(1));
searchSourceBuilder.aggregation(brand_agg);
// 3.2 分类聚合
TermsAggregationBuilder catalog_agg = AggregationBuilders.terms("catalog_agg").field("catalogId").size(EsConstant.CATALOG_SIZE);
// 3.2 子聚合
catalog_agg.subAggregation(AggregationBuilders.terms("catalog_name_agg").field("catalogName").size(1));
searchSourceBuilder.aggregation(catalog_agg);
// 3.3 属性聚合
NestedAggregationBuilder attr_agg = AggregationBuilders.nested("attr_agg", "attrs");
// 3.3 子聚合
TermsAggregationBuilder attr_id_agg = AggregationBuilders.terms("attr_id_agg").field("attrs.attrId");
// 3.3 子子聚合
attr_id_agg.subAggregation(AggregationBuilders.terms("attr_name_agg").field("attrs.attrName").size(1));
attr_id_agg.subAggregation(AggregationBuilders.terms("attr_value_agg").field("attrs.attrValue").size(50));
attr_agg.subAggregation(attr_id_agg);
searchSourceBuilder.aggregation(attr_agg);

/*
   * 创建检索结果
   */
  private SearchResultVo buildSearchResult(SearchResponse response, SearchParamVo param) {
      SearchResultVo resultVo = new SearchResultVo();
      SearchHits hits = response.getHits();

      // 1 封装商品
      List<SkuEsModel> skuList = new ArrayList<>();
      if (hits.getHits() != null && hits.getHits().length > 0) {
          for (SearchHit hit : hits.getHits()) {
              // 获得hit中的resource，json转为对象
              SkuEsModel sku = JSON.parseObject(hit.getSourceAsString(), SkuEsModel.class);
              // 是否高亮
              if (!StringUtils.isEmpty(param.getKeyword())) {
                  HighlightField highlightField = hit.getHighlightFields().get("skuTitle");
                  String highlight = highlightField.getFragments()[0].toString();
                  sku.setSkuTitle(highlight);
              }
              skuList.add(sku);
          }
      }
      resultVo.setProducts(skuList);

      // 2 封装属性聚合信息
      List<SearchResultVo.AttrVo> attrVoList = 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()) {
          SearchResultVo.AttrVo attrVo = new SearchResultVo.AttrVo();
          // 封装id，在聚合中
          attrVo.setAttrId(Long.valueOf(String.valueOf(bucket.getKeyAsNumber())));
          // 封装name，在子聚合中
          ParsedStringTerms attr_name_agg = bucket.getAggregations().get("attr_name_agg");
          attrVo.setAttrName(attr_name_agg.getBuckets().get(0).getKeyAsString());
          // 封装valueList，在子聚合中
          List<String> attrValue = new ArrayList<>();
          ParsedStringTerms attr_value_agg = bucket.getAggregations().get("attr_value_agg");
          for (Terms.Bucket aggBucket : attr_value_agg.getBuckets()) {
              attrValue.add(aggBucket.getKeyAsString());
          }
          attrVo.setAttrValue(attrValue);
          attrVoList.add(attrVo);
      }
      resultVo.setAttrs(attrVoList);

      // 3 封装品牌聚合信息
      List<SearchResultVo.BrandVo> brandVoList = new ArrayList<>();
      // 获得聚合
      ParsedLongTerms brand_agg = response.getAggregations().get("brand_agg");
      // 根据brandId有许多个bucket
      for (Terms.Bucket bucket : brand_agg.getBuckets()) {
          // 封装brandId，在聚合中
          SearchResultVo.BrandVo brandVo = new SearchResultVo.BrandVo();
          brandVo.setBrandId(Long.valueOf(bucket.getKeyAsString()));
          // 封装brandName\brandImg，在子聚合中
          ParsedStringTerms brand_name_agg = bucket.getAggregations().get("brand_name_agg");
          brandVo.setBrandName(brand_name_agg.getBuckets().get(0).getKeyAsString());
          ParsedStringTerms brand_img_agg = bucket.getAggregations().get("brand_img_agg");
          brandVo.setBrandImg(brand_img_agg.getBuckets().get(0).getKeyAsString());
          brandVoList.add(brandVo);
      }
      resultVo.setBrands(brandVoList);

      // 4 封装分类聚合信息
      List<SearchResultVo.CatalogVo> catalogVoList = new ArrayList<>();
      // 获得聚合
      ParsedLongTerms catalog_agg = response.getAggregations().get("catalog_agg");
      // 根据catelogId有许多个bucket
      for (Terms.Bucket bucket : catalog_agg.getBuckets()) {
          // 封装CatalogId，在聚合中
          SearchResultVo.CatalogVo catalogVo = new SearchResultVo.CatalogVo();
          catalogVo.setCatalogId(Long.valueOf(bucket.getKeyAsString()));
          // 封装CatalogName，在子聚合中
          ParsedStringTerms catalog_name_agg = bucket.getAggregations().get("catalog_name_agg");
          catalogVo.setCatalogName(catalog_name_agg.getBuckets().get(0).getKeyAsString());
          catalogVoList.add(catalogVo);
      }
      resultVo.setCatalogs(catalogVoList);

      // 5 封装分页信息
      long total = hits.getTotalHits().value;
      resultVo.setTotal(total);
      resultVo.setTotalPages((int) ((total + EsConstant.PRODUCT_PAGE_SIZE - 1) / EsConstant.PRODUCT_PAGE_SIZE));
      resultVo.setPageNum(param.getPageNum());

      return resultVo;
  }