一、ElasticSearch简介

ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。ElasticSearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名显示，Elasticsearch是最受欢迎的企业搜索引擎，其次是Apache Solr，也是基于Lucene。

https://docs.spring.io/spring-data/elasticsearch/docs/3.2.0.RC3/reference/html/#preface.versions
Spring Data Elasticsearch与Elasticsearch兼容列表：

Spring Data Elasticsearch	Elasticsearch
3.2.x	6.8.1
3.1.x	6.2.2
3.0.x	5.5.0
2.1.x	2.4.0
2.0.x	2.2.0
1.3.x	1.5.2

二、Maven依赖

elasticsearch6.4.3与spring-boot2.1.8+

SpringBoot--实战开发--整合ElasticSearch(十七)_第1张图片

版本


    org.springframework.boot
    spring-boot-starter-data-elasticsearch

elasticsearch7.3.1与spring-boot2.2.0M5+


    org.springframework.boot
    spring-boot-starter-parent
    2.2.0.M6
    


    org.springframework.boot
    spring-boot-starter-data-elasticsearch


    
        spring-milestones
        Spring Milestones
        https://repo.spring.io/milestone

三、配置

# Elasticsearch
spring.data.elasticsearch.repositories.enabled = true
# 集群名(默认值: elasticsearch)
spring.data.elasticsearch.cluster-name=elasticsearch
#spring.data.elasticsearch.cluster-name=elasticsearch
# 9200端口是用来让HTTP REST API来访问ElasticSearch，而9300端口是传输层监听的默认端口
spring.elasticsearch.jest.uris=http://192.168.77.132:9200/
# 集群节点地址列表，用逗号分隔。如果没有指定，就启动一个客户端节点
spring.data.elasticsearch.cluster-nodes = 192.168.77.132:9300
spring.data.elasticsearch.properties.path.logs=./elasticsearch/log
spring.data.elasticsearch.properties.path.data=./elasticsearch/data
# 存储索引的位置
spring.data.elasticsearch.properties.path.home=/data/project/target/elastic
# 连接超时的时间
spring.data.elasticsearch.properties.transport.tcp.connect_timeout=120s
# 用户名与密码
#spring.data.elasticsearch.properties.shield.user= es:123456

四、注解

1.类上注解：
@Document (相当于Hibernate实体的@Entity/@Table)(必写)，加上了@Document注解之后，默认情况下这个实体中所有的属性都会被建立索引、并且分词。

类型	属性名	默认值	说明
String	indexName	无索引库的名称，建议以项目的名称命名
String	type	“”	类型，建议以实体的名称命名
short	shards	5	默认分区数
short	replica	1	每个分区默认的备份数
String	refreshInterval	“1s”	刷新间隔
String	indexStoreType	“fs”	索引文件存储类型

主键注解：
@Id (相当于Hibernate实体的主键@Id注解)(必写)
只是一个标识，并没有属性。
属性注解
@Field (相当于Hibernate实体的@Column注解)
@Field默认是可以不加的，默认所有属性都会添加到ES中。加上@Field之后，@document默认把所有字段加上索引失效，只有加@Field 才会被索引(同时也看设置索引的属性是否为no)

类型	属性名	默认值	说明
FieldType	type	FieldType.Auto	自动检测属性的类型
FieldIndex	index	FieldIndex.analyzed	默认情况下分词
boolean	store	false	默认情况下不存储原文
String	searchAnalyzer	" "	指定字段搜索时使用的分词器
String	indexAnalyzer	" "	指定字段建立索引时指定的分词器
String[]	ignoreFields	{}	如果某个字段需要被忽略

type：字段类型，是是枚举：FieldType，可以是text、long、short、date、integer、object等
text：存储数据时候，会自动分词，并生成索引
keyword：存储数据时候，不会分词建立索引
Numerical：数值类型，分两类
基本数据类型：long、interger、short、byte、double、float、half_float
浮点数的高精度类型：scaled_float
需要指定一个精度因子，比如10或100。elasticsearch会把真实值乘以这个因子后存储，取出时再还原。
Date：日期类型
elasticsearch可以对日期格式化为字符串存储，但是建议我们存储为毫秒值，存储为long，节省空间。
index：是否索引，布尔类型，默认是true
store：是否存储，布尔类型，默认是false
analyzer：分词器名称，这里的ik_max_word即使用ik分词器

实体类

@Document(indexName = "item",type = "docs", shards = 1, replicas = 0)
public class Goods {
    @Id
    private Long id;
    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String title; //标题
    @Field(type = FieldType.Keyword)
    private String category;// 分类
    @Field(type = FieldType.Keyword)
    private String brand; // 品牌
    @Field(type = FieldType.Double)
    private Double price; // 价格
    @Field(index = false, type = FieldType.Keyword)
    private String images; // 图片地址
}

五、Elasticsearch操作

定义接口

@Component
public interface GoodsRepository extends ElasticsearchRepository {
}

索引操作
使用：ElasticsearchTemplate 模板对象

    /**
     * Elasticsearch模板
     */
    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;
    /**
     * 创建索引，会根据Goods类的@Document注解信息来创建
     * 名称为:goods
     */
    @Test
    public void createIndex() {
        // 创建索引，会根据Item类的@Document注解信息来创建
        elasticsearchTemplate.createIndex(Goods.class);
        // 配置映射，会根据Item类中的id、Field等字段来自动完成映射
        elasticsearchTemplate.putMapping(Goods.class);
    }

    /**
     * 删除索引
     * 可以根据类名或索引名删除。
     */
    @Test
    public void deleteIndex() {
        elasticsearchTemplate.deleteIndex("goods");
    }

SpringBoot--实战开发--整合ElasticSearch(十七)_第2张图片

创建结果

文档操作
Spring Data 不需要写任何DAO处理，自动根据方法名或类的信息进行CRUD操作。只要你定义一个接口，然后继承Repository提供的一些子接口，就能具备各种基本的CRUD功能。
简介使用：

    /**
     * 新增文档
     * 数据查询:goods为索引，docs为文档类型,1为id,pretty为显示样式
     * http://192.168.77.132:9200/goods/docs/1?pretty
     */
    @Test
    public void addDocument() {
        Goods goods = new Goods(1L, "小米手机7", " 手机",
                "小米", 3499.00, "https://img13.360buyimg.com/n1/s450x450_jfs/t1/79993/29/9874/153231/5d7809f4E8f387bff/1dc9e1b6b262f0fb.jpg");
        Goods goods0 = goodsRepository.save(goods);
        log.info(JSON.toJSONString(goods0));
    }

    /**
     * 批量新增
     */
    @Test
    public void createDocumentList() {
        List list = new ArrayList<>();
        list.add(new Goods(2L, "坚果手机R1", " 手机", "锤子", 3699.00, "http://image.leyou.com/123.jpg"));
        list.add(new Goods(3L, "华为META10", " 手机", "华为", 4499.00, "http://image.leyou.com/3.jpg"));
        // 接收对象集合，实现批量新增
        goodsRepository.saveAll(list);
    }

    //    修改文档
    //    修改和新增是同一个接口，区分的依据就是id，这一点跟我们在页面发起PUT请求是类似的。
    @Test
    public void findDocument() {
        // 查询全部，并安装价格降序排序
        Iterable goodsIterable = this.goodsRepository.findAll(Sort.by(Sort.Direction.DESC, "price"));
        goodsIterable.forEach(goods -> System.out.println(JSON.toJSONString(goods)));
    }

SpringBoot--实战开发--整合ElasticSearch(十七)_第3张图片

文档操作

六、Elasticsearch 高级查询

发生	描述
must	该条款（查询）必须出现在匹配的文件，并将有助于得分。
filter	子句（查询）必须出现在匹配的文档中。然而不像 must查询的分数将被忽略。Filter子句在过滤器上下文中执行，这意味着评分被忽略，子句被考虑用于高速缓存。
should	子句（查询）应该出现在匹配的文档中。如果 bool查询位于查询上下文中并且具有mustor filter子句，则bool即使没有should查询匹配，文档也将匹配该查询。在这种情况下，这些条款仅用于影响分数。如果bool查询是过滤器上下文或者两者都不存在，must或者filter至少有一个should查询必须与文档相匹配才能与bool查询匹配。这种行为可以通过设置minimum_should_match参数来显式控制。
must_not	子句（查询）不能出现在匹配的文档中。子句在过滤器上下文中执行，意味着评分被忽略，子句被考虑用于高速缓存。因为计分被忽略，0所有文件的分数被返回。

自定义方法
Spring Data 的另一个强大功能，是根据方法名称自动实现功能。

比如：你的方法名叫做：findByTitle，那么它就知道你是根据title查询，然后自动帮你完成，无需写实现类。

当然，方法名称要符合一定的约定：

关键字	方法名（示例）	ES查询
And	findByNameAndPrice	{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}
Or	findByNameOrPrice	{"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}
Is	findByName	{"bool" : {"must" : {"field" : {"name" : "?"}}}}
Not	findByNameNot	{"bool" : {"must_not" : {"field" : {"name" : "?"}}}}
Between	findByPriceBetween	{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
LessThanEqual	findByPriceLessThan	{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
GreaterThanEqual	findByPriceGreaterThan	{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}
Before	findByPriceBefore	{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
After	findByPriceAfter	{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}
Like	findByNameLike	{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}
StartingWith	findByNameStartingWith	{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}
EndingWith	findByNameEndingWith	{"bool" : {"must" : {"field" : {"name" : {"query" : "*?","analyze_wildcard" : true}}}}}
Contains/Containing	findByNameContaining	{"bool" : {"must" : {"field" : {"name" : {"query" : "?","analyze_wildcard" : true}}}}}
In	findByNameIn(Collectionnames)	{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}
NotIn	findByNameNotIn(Collectionnames)	{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}}
Near	findByStoreNear Not Supported Yet !
True	findByAvailableTrue	{"bool" : {"must" : {"field" : {"available" : true}}}}
False	findByAvailableFalse	{"bool" : {"must" : {"field" : {"available" : false}}}}
OrderBy	findByAvailableTrueOrderByNameDesc	{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}}

价格区间查询

/**
     * 根据价格区间查询
     * @param price1
     * @param price2
     * @return
     */
List findByPriceBetween(double price1, double price2);

@Test
public void indexList() {
    List list = new ArrayList<>();
    list.add(new Goods(1L, "小米手机7", "手机", "小米", 3299.00, "http://image.leyou.com/13123.jpg"));
    list.add(new Goods(2L, "坚果手机R1", "手机", "锤子", 3699.00, "http://image.leyou.com/13123.jpg"));
    list.add(new Goods(3L, "华为META10", "手机", "华为", 4499.00, "http://image.leyou.com/13123.jpg"));
    list.add(new Goods(4L, "小米Mix2S", "手机", "小米", 4299.00, "http://image.leyou.com/13123.jpg"));
    list.add(new Goods(5L, "荣耀V10", "手机", "华为", 2799.00, "http://image.leyou.com/13123.jpg"));
    // 接收对象集合，实现批量新增
   goodsRepository.saveAll(list);
}

@Test
public void queryByPriceBetween(){
    List list = this.goodsRepository.findByPriceBetween(2000.00, 3500.00);
    for (Goods goods: list) {
        System.out.println("goods= " + goods);
    }
}

基本查询

@Test
public void testQuery(){
    // 词条查询
    MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "小米");
    // 执行查询
    Iterable items = this.itemRepository.search(queryBuilder);
    items.forEach(System.out::println);
}

Repository的search方法需要QueryBuilder参数，elasticSearch为我们提供了一个对象QueryBuilders：
QueryBuilders提供了大量的静态方法，用于生成各种不同类型的查询对象，例如：词条、模糊、通配符等QueryBuilder对象。
elasticsearch提供很多可用的查询方式，但是不够灵活。如果想玩过滤或者聚合查询等就很难了。

自定义查询

@Test
public void testNativeQuery(){
    // 构建查询条件
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    // 添加基本的分词查询
    queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米"));
    // 执行搜索，获取结果
    Page items = this.itemRepository.search(queryBuilder.build());
    // 打印总条数
    System.out.println(items.getTotalElements());
    // 打印总页数
    System.out.println(items.getTotalPages());
    items.forEach(System.out::println);
}

NativeSearchQueryBuilder：Spring提供的一个查询条件构建器，帮助构建json格式的请求体
Page：默认是分页查询，因此返回的是一个分页的结果对象，包含属性：
totalElements：总条数
totalPages：总页数
Iterator：迭代器，本身实现了Iterator接口，因此可直接迭代得到当前页的数据

分页查询
利用NativeSearchQueryBuilder可以方便的实现分页：

@Test
public void testNativeQuery(){
    // 构建查询条件
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    // 添加基本的分词查询
    queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));

    // 初始化分页参数
    int page = 0;
    int size = 3;
    // 设置分页参数
    queryBuilder.withPageable(PageRequest.of(page, size));

    // 执行搜索，获取结果
    Page items = this.itemRepository.search(queryBuilder.build());
    // 打印总条数
    System.out.println(items.getTotalElements());
    // 打印总页数
    System.out.println(items.getTotalPages());
    // 每页大小
    System.out.println(items.getSize());
    // 当前页
    System.out.println(items.getNumber());
    items.forEach(System.out::println);
}

可以发现，Elasticsearch中的分页是从第0页开始。

排序
排序也通用通过NativeSearchQueryBuilder完成：

@Test
public void testSort(){
    // 构建查询条件
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    // 添加基本的分词查询
    queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));

    // 排序
    queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC));

    // 执行搜索，获取结果
    Page items = this.itemRepository.search(queryBuilder.build());
    // 打印总条数
    System.out.println(items.getTotalElements());
    items.forEach(System.out::println);
}

聚合为桶
桶就是分组，比如这里我们按照品牌brand进行分组：

@Test
public void testAgg(){
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    // 不查询任何结果
    queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
    // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
    queryBuilder.addAggregation(
        AggregationBuilders.terms("brands").field("brand"));
    // 2、查询,需要把结果强转为AggregatedPage类型
    AggregatedPage aggPage = (AggregatedPage) this.itemRepository.search(queryBuilder.build());
    // 3、解析
    // 3.1、从结果中取出名为brands的那个聚合，
    // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
    StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
    // 3.2、获取桶
    List buckets = agg.getBuckets();
    // 3.3、遍历
    for (StringTerms.Bucket bucket : buckets) {
        // 3.4、获取桶中的key，即品牌名称
        System.out.println(bucket.getKeyAsString());
        // 3.5、获取桶中的文档数量
        System.out.println(bucket.getDocCount());
    }
}

嵌套聚合，求平均值

@Test
public void testSubAgg(){
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    // 不查询任何结果
    queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
    // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
    queryBuilder.addAggregation(
        AggregationBuilders.terms("brands").field("brand")
        .subAggregation(AggregationBuilders.avg("priceAvg").field("price")) // 在品牌聚合桶内进行嵌套聚合，求平均值
    );
    // 2、查询,需要把结果强转为AggregatedPage类型
    AggregatedPage aggPage = (AggregatedPage) this.itemRepository.search(queryBuilder.build());
    // 3、解析
    // 3.1、从结果中取出名为brands的那个聚合，
    // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
    StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
    // 3.2、获取桶
    List buckets = agg.getBuckets();
    // 3.3、遍历
    for (StringTerms.Bucket bucket : buckets) {
        // 3.4、获取桶中的key，即品牌名称  3.5、获取桶中的文档数量
        System.out.println(bucket.getKeyAsString() + "，共" + bucket.getDocCount() + "台");

        // 3.6.获取子聚合结果：
        InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
        System.out.println("平均售价：" + avg.getValue());
    }
}

七、常见错误：

failed to load elasticsearch nodes : org.elasticsearch.client.transport.NoNodeAvailableException: None of the configured nodes are available: [{#transport#-1}{fp9W6s1YS9aWKDtk9RmljQ}{192.168.169.128}{192.168.169.128:9300}]
原因：版本不兼容
java.lang.IllegalStateException: Received message from unsupported version: [6.4.3] minimal compatible version is: [6.8.0]
版本问题：
请使用高版本。
如果ES是7.3.1，SpringBoot请使用:2.2.0.M5+

    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.0.M6
        
    
    
        
            spring-milestones
            Spring Milestones
            https://repo.spring.io/milestone
        
    
    
        org.springframework.boot
        spring-boot-starter-data-elasticsearch
       2.2.0.M6

MapperParsingException[analyzer [ik_max_word] not found for field [title]]
原因：版本问题。

SpringBoot--实战开发--整合ElasticSearch(十七)