微服务项目之电商--21.ElasticSearch索引库数据导入

Love The Way You Lie 2021-10-18 09:34 336阅读 0赞

**目录**

1.索引库数据导入

1.1.创建搜索服务

1.2.索引库数据格式分析

1.2.1.以结果为导向

1.2.2.需要什么数据

1.2.3.最终的数据结构

1.3.商品微服务提供接口

1.3.1.商品分类名称查询

1.3.2.编写FeignClient

1.4.导入数据

1.4.1.创建GoodsRepository

1.4.2.创建索引

1.4.3.导入数据

--------------------

# 1.索引库数据导入 #

## 1.1.创建搜索服务 ##

创建module：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 1][]

Pom文件：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>leyou</artifactId>
            <groupId>com.leyou.parent</groupId>
            <version>1.0.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.leyou.search</groupId>
        <artifactId>leyou-search</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
        </dependencies>
    </project>

application.yml：

server:
      port: 8083
    spring:
      application:
        name: search-service
      data:
        elasticsearch:
          cluster-name: elasticsearch
          cluster-nodes: 192.168.56.101:9300
    eureka:
      client:
        service-url:
          defaultZone: http://127.0.0.1:10086/eureka
      instance:
        lease-renewal-interval-in-seconds: 5 # 每隔5秒发送一次心跳
        lease-expiration-duration-in-seconds: 10 # 10秒不发送就过期
        prefer-ip-address: true
        ip-address: 127.0.0.1
        instance-id: ${spring.application.name}:${server.port}

启动类：

@SpringBootApplication
    @EnableDiscoveryClient
    @EnableFeignClients
    public class LySearchService {
    
        public static void main(String[] args) {
            SpringApplication.run(LySearchService.class, args);
        }
    }

## 1.2.索引库数据格式分析 ##

接下来，我们需要商品数据导入索引库，便于用户搜索。

那么问题来了，我们有SPU和SKU，到底如何保存到索引库？

### 1.2.1.以结果为导向 ###

大家来看下搜索结果页：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 2][]

可以看到，每一个搜索结果都有至少1个商品，当我们选择大图下方的小图，商品会跟着变化。

因此，**搜索的结果是SPU，即多个SKU的集合**。

既然搜索的结果是SPU，那么我们索引库中存储的应该也是SPU，但是却需要包含SKU的信息。

### 1.2.2.需要什么数据 ###

再来看看页面中有什么数据：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 3][]

直观能看到的：图片、价格、标题、副标题

暗藏的数据：spu的id，sku的id

另外，页面还有过滤条件：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 4][]

这些过滤条件也都需要存储到索引库中，包括：

商品分类、品牌、可用来搜索的规格参数等

综上所述，我们需要的数据格式有：

spuId、SkuId、商品分类id、品牌id、图片、价格、商品的创建时间、sku信息集、可搜索的规格参数

### 1.2.3.最终的数据结构 ###

我们创建一个类，封装要保存到索引库的数据，并设置映射属性：

@Document(indexName = "goods", type = "docs", shards = 1, replicas = 0)
    public class Goods {
        @Id
        private Long id; // spuId
        @Field(type = FieldType.Text, analyzer = "ik_max_word")
        private String all; // 所有需要被搜索的信息，包含标题，分类，甚至品牌
        @Field(type = FieldType.Keyword, index = false)
        private String subTitle;// 卖点
        private Long brandId;// 品牌id
        private Long cid1;// 1级分类id
        private Long cid2;// 2级分类id
        private Long cid3;// 3级分类id
        private Date createTime;// 创建时间
        private List<Long> price;// 价格
        @Field(type = FieldType.Keyword, index = false)
        private String skus;// sku信息的json结构
        private Map<String, Object> specs;// 可搜索的规格参数，key是参数名，值是参数值
    }

一些特殊字段解释：

*  all：用来进行全文检索的字段，里面包含标题、商品分类信息
 *  price：价格数组，是所有sku的价格集合。方便根据价格进行筛选过滤
 *  skus：用于页面展示的sku信息，不索引，不搜索。包含skuId、image、price、title字段
 *  specs：所有规格参数的集合。key是参数名，值是参数值。
    
    例如：我们在specs中存储 内存：4G,6G，颜色为红色，转为json就是：

{
        "specs":{
            "内存":[4G,6G],
            "颜色":"红色"
        }
    }

当存储到索引库时，elasticsearch会处理为两个字段：

*  specs.内存：\[4G,6G\]
 *  specs.颜色：红色

另外， 对于字符串类型，还会额外存储一个字段，这个字段不会分词，用作聚合。

*  specs.颜色.keyword：红色

## 1.3.商品微服务提供接口 ##

索引库中的数据来自于数据库，我们不能直接去查询商品的数据库，因为真实开发中，每个微服务都是相互独立的，包括数据库也是一样。所以我们只能调用商品微服务提供的接口服务。

先思考我们需要的数据：

*  SPU信息
 *  SKU信息
 *  SPU的详情
 *  商品分类名称（拼接all字段）

再思考我们需要哪些服务：

*  第一：分批查询spu的服务，已经写过。
 *  第二：根据spuId查询sku的服务，已经写过
 *  第三：根据spuId查询SpuDetail的服务，已经写过
 *  第四：根据商品分类id，查询商品分类名称，没写过
 *  第五：根据商品品牌id，查询商品的品牌，没写过

因此我们需要额外提供一个查询商品分类名称的接口。

### 1.3.1.商品分类名称查询 ###

controller：

/**
     * 根据商品分类id查询名称
     * @param ids 要查询的分类id集合
     * @return 多个名称的集合
     */
    @GetMapping("names")
    public ResponseEntity<List<String>> queryNameByIds(@RequestParam("ids") List<Long> ids){
        List<String > list = this.categoryService.queryNameByIds(ids);
        if (list == null || list.size() < 1) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return ResponseEntity.ok(list);
    }

测试：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 5][]

### 1.3.2.编写FeignClient ###

1.3.2.1.问题展现

操作leyou-search工程

现在，我们要在搜索微服务调用商品微服务的接口。

第一步要引入商品微服务依赖：`leyou-item-interface`。

<dependency>
        <groupId>com.leyou.service</groupId>
        <artifactId>ly-item-interface</artifactId>
        <version>${leyou.latest.version}</version>
    </dependency>

第二步，编写FeignClient

@FeignClient(value = "item-service")
    @RequestMapping("/goods")
    public interface GoodsClient {
    
        /**
         * 分页查询商品
         * @param page
         * @param rows
         * @param saleable
         * @param key
         * @return
         */
        @GetMapping("/spu/page")
        ResponseEntity<PageResult<SpuBo>> querySpuByPage(
                @RequestParam(value = "page", defaultValue = "1") Integer page,
                @RequestParam(value = "rows", defaultValue = "5") Integer rows,
                @RequestParam(value = "saleable", defaultValue = "true") Boolean saleable,
                @RequestParam(value = "key", required = false) String key);
    
        /**
         * 根据spu商品id查询详情
         * @param id
         * @return
         */
        @GetMapping("/spu/detail/{id}")
        ResponseEntity<SpuDetail> querySpuDetailById(@PathVariable("id") Long id);
    
        /**
         * 根据spu的id查询sku
         * @param id
         * @return
         */
        @GetMapping("sku/list")
        ResponseEntity<List<Sku>> querySkuBySpuId(@RequestParam("id") Long id);
    }

以上的这些代码直接从商品微服务中拷贝而来，完全一致。差别就是没有方法的具体实现。大家觉得这样有没有问题？

而FeignClient代码遵循SpringMVC的风格，因此与商品微服务的Controller完全一致。这样就存在一定的问题：

*  代码冗余。尽管不用写实现，只是写接口，但服务调用方要写与服务controller一致的代码，有几个消费者就要写几次。
 *  增加开发成本。调用方还得清楚知道接口的路径，才能编写正确的FeignClient。

1.3.2.2.解决方案

因此，一种比较友好的实践是这样的：

*  我们的服务提供方不仅提供实体类，还要提供api接口声明
 *  调用方不用字自己编写接口方法声明，直接继承提供方给的Api接口即可，

第一步：服务的提供方在`leyou-item-interface`中提供API接口，并编写接口声明：

商品分类服务接口：

@RequestMapping("category")
    public interface CategoryApi {
    
        @GetMapping("names")
        ResponseEntity<List<String>> queryNameByIds(@RequestParam("ids") List<Long> ids);
    }

商品服务接口，返回值不再使用ResponseEntity：

@RequestMapping("/goods")
    public interface GoodsApi {
    
        /**
         * 分页查询商品
         * @param page
         * @param rows
         * @param saleable
         * @param key
         * @return
         */
        @GetMapping("/spu/page")
        PageResult<SpuBo> querySpuByPage(
                @RequestParam(value = "page", defaultValue = "1") Integer page,
                @RequestParam(value = "rows", defaultValue = "5") Integer rows,
                @RequestParam(value = "saleable", defaultValue = "true") Boolean saleable,
                @RequestParam(value = "key", required = false) String key);
    
        /**
         * 根据spu商品id查询详情
         * @param id
         * @return
         */
        @GetMapping("/spu/detail/{id}")
        SpuDetail querySpuDetailById(@PathVariable("id") Long id);
    
        /**
         * 根据spu的id查询sku
         * @param id
         * @return
         */
        @GetMapping("sku/list")
        List<Sku> querySkuBySpuId(@RequestParam("id") Long id);
    }

需要引入springMVC及leyou-common的依赖：

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.0.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.leyou.common</groupId>
        <artifactId>leyou-common</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </dependency>

第二步：在调用方`leyou-search`中编写FeignClient，但不要写方法声明了，直接继承`leyou-item-interface`提供的api接口：

商品的FeignClient：

@FeignClient(value = "item-service")
    public interface GoodsClient extends GoodsApi {
    }

商品分类的FeignClient：

@FeignClient(value = "item-service")
    public interface CategoryClient extends CategoryApi {
    }

是不是简单多了？

项目结构：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 7][]

1.3.2.3.测试

在leyou-search中引入springtest依赖：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

创建测试类：

在接口上按快捷键：`Ctrl + Shift + T`

![20190811093328989.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 8][]

测试代码：

@RunWith(SpringRunner.class)
    @SpringBootTest(classes = LeyouSearchApplication.class)
    public class CategoryClientTest {
    
        @Autowired
        private CategoryClient categoryClient;
    
        @Test
        public void testQueryCategories() {
            List<String> names = this.categoryClient.queryNameByIds(Arrays.asList(1L, 2L, 3L));
            names.forEach(System.out::println);
        }
    }

## 1.4.导入数据 ##

导入数据只做一次,以后的更新删除等操作通过消息队列来操作索引库

### 1.4.1.创建GoodsRepository ###

java代码：

public interface GoodsRepository extends ElasticsearchRepository<Goods, Long> {
    }

### 1.4.2.创建索引 ###

我们新建一个测试类，在里面进行数据的操作：

@RunWith(SpringRunner.class)
    @SpringBootTest(classes = LeyouSearchApplication.class)
    public class ElasticsearchTest {
    
        @Autowired
        private GoodsRepository goodsRepository;
    
        @Autowired
        private ElasticsearchTemplate elasticsearchTemplate;
    
        @Test
        public void createIndex(){
            // 创建索引
            this.elasticsearchTemplate.createIndex(Goods.class);
            // 配置映射
            this.elasticsearchTemplate.putMapping(Goods.class);
        }
    }

通过kibana查看：

![20190811093753126.png][]

### 1.4.3.导入数据 ###

导入数据其实就是查询数据，然后把查询到的Spu转变为Goods来保存，因此我们先编写一个SearchService，然后在里面定义一个方法， 把Spu转为Goods

@Service
    public class SearchService {
    
        @Autowired
        private CategoryClient categoryClient;
    
        @Autowired
        private GoodsClient goodsClient;
    
        @Autowired
        private SpecificationClient specificationClient;
    
        private ObjectMapper mapper = new ObjectMapper();
    
        public Goods buildGoods(Spu spu) throws IOException {
            Goods goods = new Goods();
    
            // 查询商品分类名称
            List<String> names = this.categoryClient.queryNameByIds(Arrays.asList(spu.getCid1(), spu.getCid2(), spu.getCid3()));
            // 查询sku
            List<Sku> skus = this.goodsClient.querySkuBySpuId(spu.getId());
            // 查询详情
            SpuDetail spuDetail = this.goodsClient.querySpuDetailById(spu.getId());
            // 查询规格参数
            List<SpecParam> params = this.specificationClient.querySpecParam(null, spu.getCid3(), true, null);
    
            // 处理sku，仅封装id、价格、标题、图片，并获得价格集合
            List<Long> prices = new ArrayList<>();
            List<Map<String, Object>> skuList = new ArrayList<>();
            skus.forEach(sku -> {
                prices.add(sku.getPrice());
                Map<String, Object> skuMap = new HashMap<>();
                skuMap.put("id", sku.getId());
                skuMap.put("title", sku.getTitle());
                skuMap.put("price", sku.getPrice());
                skuMap.put("image", StringUtils.isBlank(sku.getImages()) ? "" : StringUtils.split(sku.getImages(), ",")[0]);
                skuList.add(skuMap);
            });
    
            // 处理规格参数
            Map<String, Object> genericSpecs = mapper.readValue(spuDetail.getGenericSpec(), new TypeReference<Map<String, Object>>() {
            });
            Map<String, Object> specialSpecs = mapper.readValue(spuDetail.getSpecialSpec(), new TypeReference<Map<String, Object>>() {
            });
            // 获取可搜索的规格参数
            Map<String, Object> searchSpec = new HashMap<>();
    
            // 过滤规格模板，把所有可搜索的信息保存到Map中
            Map<String, Object> specMap = new HashMap<>();
            params.forEach(p -> {
                if (p.getSearching()) {
                    if (p.getGeneric()) {
                        String value = genericSpecs.get(p.getId().toString()).toString();
                        if(p.getNumeric()){
                            value = chooseSegment(value, p);
                        }
                        specMap.put(p.getName(), StringUtils.isBlank(value) ? "其它" : value);
                    } else {
                        specMap.put(p.getName(), specialSpecs.get(p.getId().toString()));
                    }
                }
            });
    
            goods.setId(spu.getId());
            goods.setSubTitle(spu.getSubTitle());
            goods.setBrandId(spu.getBrandId());
            goods.setCid1(spu.getCid1());
            goods.setCid2(spu.getCid2());
            goods.setCid3(spu.getCid3());
            goods.setCreateTime(spu.getCreateTime());
            goods.setAll(spu.getTitle() + " " + StringUtils.join(names, " "));
            goods.setPrice(prices);
            goods.setSkus(mapper.writeValueAsString(skuList));
            goods.setSpecs(specMap);
            return goods;
        }                                                   
    
    }

因为过滤参数中有一类比较特殊，就是数值区间： ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 9][]

所以我们在存入时要进行处理：

private String chooseSegment(String value, SpecParam p) {
        double val = NumberUtils.toDouble(value);
        String result = "其它";
        // 保存数值段
        for (String segment : p.getSegments().split(",")) {
            String[] segs = segment.split("-");
            // 获取数值范围
            double begin = NumberUtils.toDouble(segs[0]);
            double end = Double.MAX_VALUE;
            if(segs.length == 2){
                end = NumberUtils.toDouble(segs[1]);
            }
            // 判断是否在范围内
            if(val >= begin && val < end){
                if(segs.length == 1){
                    result = segs[0] + p.getUnit() + "以上";
                }else if(begin == 0){
                    result = segs[1] + p.getUnit() + "以下";
                }else{
                    result = segment + p.getUnit();
                }
                break;
            }
        }
        return result;
    }

然后编写一个测试类，循环查询Spu，然后调用IndexService中的方法，把SPU变为Goods，然后写入索引库：

@Test
    public void loadData(){
        // 创建索引
        this.elasticsearchTemplate.createIndex(Goods.class);
        // 配置映射
        this.elasticsearchTemplate.putMapping(Goods.class);
        int page = 1;
        int rows = 100;
        int size = 0;
        do {
            // 查询分页数据
            PageResult<SpuBo> result = this.goodsClient.querySpuByPage(page, rows, true, null);
            List<SpuBo> spus = result.getItems();
            size = spus.size();
            // 创建Goods集合
            List<Goods> goodsList = new ArrayList<>();
            // 遍历spu
            for (SpuBo spu : spus) {
                try {
                    Goods goods = this.searchService.buildGoods(spu);
                    goodsList.add(goods);
                } catch (Exception e) {
                    break;
                }
            }
    
            this.goodsRepository.saveAll(goodsList);
            page++;
        } while (size == 100);
    }

通过kibana查询， 可以看到数据成功导入：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 10][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70]: /images/20211018/801b06556de3481f84971e5de546452a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 1]: /images/20211018/c4af6c19c8c642f78728081a3782bb0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 2]: /images/20211018/8c6cc47c2c36420180fca9a4a4614ecf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 3]: /images/20211018/d5193fadc3ec485ebc31bc2c1860ac0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 4]: /images/20211018/e50c85eed1e14498bff4423eb098700b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 5]: /images/20211018/78e2933b700142d185ad47111391ca83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 6]: /images/20211018/55aa539f0a5f4cb99cb36c44b98b74bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 7]: /images/20211018/4edbc1b43d9e44c89d409a7129afc9c5.png
[20190811093328989.png]: /images/20211018/2e086055c1cc4f7c89f1cd0d1ba13627.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 8]: /images/20211018/75879b15f6c340b89782cb0b7cf403ab.png
[20190811093753126.png]: /images/20211018/4516eb87a6f3470f88c60158d96ad4b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 9]: /images/20211018/3256c188771d4e4cb01ad72501d92396.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 10]: /images/20211018/e26dd0d6b06b4d7e9422a29e1dd66e73.png