Como usar o Elasticsearch no projeto

Prefácio

O módulo de pesquisa de produto está envolvido no projeto. Através da aprendizagem de conhecimentos ES, tento aplicar ES ao projeto. Este blog descreve principalmente como uso ES no projeto. Como o servidor Alibaba Cloud que compramos juntos expirou, não iremos demonstrá-lo aqui. Você deve comprar um bom servidor para trabalhos futuros

Se você também deseja instalar ES e Kibana, você pode seguir meu blog anterior para construir um
portal <---- clique aqui

Modelo de dados em ES

Se você quiser verificar os dados do ES, primeiro precisa armazenar os dados no ES. Naquela época, discuti com meus colegas de classe para importar os dados diretamente no Kibana, mas quando penso nisso, isso é muito problemático. Mais tarde, pensei que o gerenciamento de bastidores escrito por meus colegas tinha produtos. As funções nas prateleiras e, em seguida, comece a partir daqui.

Design de modelo

Dê uma olhada no modelo que projetamos:

@Data
public class SkuEsModel {
    
    
	//具体商品的id
    private Long skuId;
	//某类商品的id 
    private Long spuId;
    //销售商品的标题
    private String skuTitle;
    //销售商品的价格
    private BigDecimal skuPrice;
    //销售商品的图片
    private String skuImg;
    //商品的销量
    private Long saleCount;
    //商品是否有库存
    private Boolean hasStock;
    //商品的评分
    private Long hotScore;
    //商品所属品牌的id
    private Long brandId;
    //商品所属分类的id
    private Long catalogId;
    //商品所属品牌的名字
    private String brandName;
    //商品所属品牌的图片
    private String brandImg;
    //商品所属分类的名字
    private String catalogName;
    //商品所对应的属性
    private List<Attrs> attrs;
    @Data
    public static class Attrs {
    
    
    	//属性id
        private Long attrId;
        //属性的名字
        private String attrName;
        //属性值
        private String attrValue;
    }
}

Por que projetar assim

Primeiro, vamos falar sobre o que as empresas no shopping usam:

• Entre na página de pesquisa através do diretório de três níveis da lista de três níveis na página inicial do shopping
• Insira o nome do produto que deseja pesquisar na caixa de pesquisa na página inicial do shopping e retorne os dados marcando os

Se você clicar para entrar no catálogo de terceiro nível, ele passará um parâmetro de id de categoria, portanto, deve haver um id de categoria no modelo para fornecer pesquisa e, em seguida, inserido na caixa de pesquisa, ele passará um parâmetro de String, que corresponde ao título do produto sku.
Então, por meio dessas pesquisas, quais dados eu preciso fornecer o front end para renderizar na página de detalhes?

As imagens acima são do JD.com. Meus colegas imitaram algumas das funções com base na página do JD.com. Depois de ler as anotações na imagem, você deve entender porque o modelo foi projetado assim. No entanto, existem alguns outros campos, que estão relacionados à página de detalhes do produto. Vamos falar sobre esta página de pesquisa primeiro.
Na página de pesquisa, esses atributos e marcas no meio precisam dar respostas diferentes de acordo com as pesquisas diferentes, para que sejam realizados por meio da operação de agregação em es.
Agora ainda há outro tópico para discussão: como essas informações são obtidas por meio da agregação?
Em primeiro lugar, depois de amanhã o administrador clica na estante, haverá o skuId correspondente e as informações do spu a que pertence. Quando estiver na estante, iremos verificar no banco de dados, encontrar e encapsular as informações no SkuModel e chamar o serviço de pesquisa remotamente. Esses dados são armazenados em es.

Como depositar no ES

Em seguida, observe o design do mapeamento de índice es:

PUT product
{
    
    
  "mappings": {
    
    
    "properties": {
    
    
      "skuId": {
    
    
        "type": "long"
      },
      "spuId": {
    
    
        "type": "long"
      },
      "skuTitle": {
    
    
        "type": "text",//支持全文搜索的
        "analyzer": "ik_smart"//采用ik分词器
      },
      "skuPrice": {
    
    
        "type": "keyword"//必须输入精确值才能搜索
      },
      "skuImg": {
    
    
        "type": "keyword",//必须输入精确值才能搜索
        "index": false,//不能被索引
        "doc_values": false
      },
      "saleCount": {
    
    
        "type": "long"
      },
      "hosStock": {
    
    
        "type": "boolean"
      },
      "hotScore": {
    
    
        "type": "long"
      },
      "brandId": {
    
    
        "type": "long"
      },
      "catelogId": {
    
    
        "type": "long"
      },
      "brandName": {
    
    
        "type": "keyword",
        "index": false,
        "doc_values": false
      },
      "brandImg": {
    
    
        "type": "keyword",
        "index": false,
        "doc_values": false
      },
      "catelogName": {
    
    
        "type": "keyword",
        "index": false,
        "doc_values": false
      },
      "attrs": {
    
    
        "type": "nested",//es的嵌套模型
        "properties": {
    
    
          "attrId": {
    
    
            "type": "long"
          },
          "attrName": {
    
    
            "type": "keyword",
            "index": false,
            "doc_values": false
          },
          "attrValue": {
    
    
            "type": "keyword"
          }
        }
      }
    }
  }
}

Operar API ES: RestHighLevelClient por meio de java para operar a adição, exclusão, modificação e verificação de ES e, em seguida, ver como salvá-lo

@Override
    public boolean productStatusUp(List<SkuEsModel> skuEsModels) throws IOException {
    
    

		//1.在es中建立索引，建立号映射关系
        //2. 在ES中保存这些数据
        BulkRequest bulkRequest = new BulkRequest();
        for (SkuEsModel skuEsModel : skuEsModels) {
    
    
            //构造保存请求
            IndexRequest indexRequest = new IndexRequest(EsConstant.PRODUCT_INDEX);
            indexRequest.id(skuEsModel.getSkuId().toString());
            String jsonString = JSON.toJSONString(skuEsModel);
            indexRequest.source(jsonString, XContentType.JSON);
            bulkRequest.add(indexRequest);
        }


        BulkResponse bulk = esRestClient.bulk(bulkRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);

        //TODO 如果批量错误
        boolean hasFailures = bulk.hasFailures();

        List<String> collect = Arrays.asList(bulk.getItems()).stream().map(item -> {
    
    
            return item.getId();
        }).collect(Collectors.toList());

        log.info("商品上架完成：{}",collect);

        return hasFailures;
    }

Como verificar os dados do ES

Parâmetros de consulta, também projetamos um modelo para encapsular esses parâmetros

@Data
public class SearchParam {
    
    
    /**
     * 页面传递过来的全文匹配关键字
     */
    private String keyword;
    /**
     * 品牌id,可以多选
     */
    private List<Long> brandId;
    /**
     * 三级分类id
     */
    private Long catalog3Id;
    /**
     * 排序条件：sort=price/salecount/hotscore_desc/asc
     */
    private String sort;
    /**
     * 是否显示有货
     */
    private Integer hasStock;
    /**
     * 价格区间查询
     */
    private String skuPrice;
    /**
     * 按照属性进行筛选
     */
    private List<String> attrs;
    /**
     * 页码
     */
    private Integer pageNum = 1;
    /**
     * 原生的所有查询条件
     */
    private String _queryString;
}

Por meio desses parâmetros, vá para es para encontrar o índice correspondente para a consulta de montagem e resumir minhas etapas de consulta:

1. Construa dinamicamente as instruções DSL necessárias para a consulta
2. Prepare a solicitação de pesquisa: 1correspondência difusa, filtragem (de acordo com atributos, classificação, marca, faixa de preço, inventário), classificação, paginação, destaque, análise de 2agregação, agregação: agregação de marca, agregação de classificação, agregação de atributo
3. Executar solicitação de recuperação
4. Analise os dados de resposta e encapsule-os no formato de que precisamos
5. Retorna