ElasticSearch使用spring-data-elasticSearch的用法

　　spring-data-Elasticsearch 使用之前,必须先确定版本,elasticsearch 对版本的要求比较高。

　　spring和elasticsearch有两种链接方式，一种是用TCP协议，默认端口是9300，还有一种用http协议。

　　用到的注解：

　　@Document(indexName = "mytest",type = "mytest") //indexName索引名称，type类别

　　主键可以使用@Id 注解 import org.springframework.data.annotation.Id

　　Jest是使用http请求进行链接的用elasticsearch 默认的端口9200 进行连接

　　使用Repository的接口接口名称的查询

 　方法都有
  1.单个保存  save方法能够进行更新操作  如果不传id,elasticsearch会自动创建id
  2.批量保存
  3.按照id单个查询
  4.index  方法和save方法相同

　　QueryBuilders 方法介绍

QueryBuilder boolQueryBuilder = QueryBuilders.boolQuery(); // bool语句的封装组合语句 and not or
QueryBuilders.termQuery(null,null); //精确查询完全匹配
QueryBuilders.termsQuery(null,1,2); // 精确查询批量匹配
QueryBuilders.matchQuery(null,null); //单个匹配 field不支持通配符, 前缀具高级特性
QueryBuilders.matchAllQuery(); //查询所有
QueryBuilders.multiMatchQuery("text","",""); //匹配多个字段, field有通配符忒行
QueryBuilders.idsQuery(); //根据id查询
QueryBuilders.constantScoreQuery(boolQueryBuilder).boost(12.12f); //包裹查询, 高于设定分数, 不计算相关性
QueryBuilders.disMaxQuery(); // 对子查询的结果做union, score沿用子查询score的最大值,
QueryBuilders.fuzzyQuery("",""); //模糊查询不能用通配符
QueryBuilders.moreLikeThisQuery(new String[2]); //基于内容的查询
QueryBuilders.boostingQuery();//它接受一个positive查询和一个negative查询。只有匹配了positive查询的文档才会被包含到结果集中，但是同时匹配了negative查询的文档会被降低其相关度，通过将文档原本的_score和negative_boost参数进行相乘来得到新的_score
QueryBuilders.functionScoreQuery(); //根据权重分查询
QueryBuilders.rangeQuery(); //范围查询
QueryBuilders.spanNearQuery() //跨度查询
QueryBuilders.wildcardQuery("user", "ki*hy") //通配符查询
QueryBuilders.nestedQuery() //嵌套查询

　　关键字

关键字	使用示例	等同于的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” : “?”}}}}}}
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}}}}

　模板的使用

1.增加

IndexQuery的作用是保存对象到elasticsearch。用法如下。

        @Autowired

        private ElasticsearchTemplate elasticsearchTemplate;

        Book book = new Book("《西游记后传》", "小白龙", 100);

        IndexQuery indexQuery = new IndexQueryBuilder()

                .withIndexName("library")

                .withType("book")

                .withId(book.getId()+"")

                .withObject(book) //对象或集合

                .build();

        elasticsearchTemplate.index(indexQuery);

2.删除

        //第一种删除具体的一条记录

        elasticsearchTemplate.delete("library","book",100+"");

        //第二种删除indexName/type/下的所有

        DeleteQuery deleteQuery = new DeleteQuery();

        deleteQuery.setIndex("library");

        deleteQuery.setType("book");

        elasticsearchTemplate.delete(deleteQuery);

        //第三种删除indexName/下的所有

        elasticsearchTemplate.deleteIndex("library");

        //第四种删除查询出来的所有

        deleteQuery = new DeleteQuery();

        deleteQuery.setQuery(QueryBuilders.matchQuery("id","100"));

        elasticsearchTemplate.delete(deleteQuery);

3.更新

        Book book = new Book("《西游记后传》", "猪八戒", 100);

        UpdateQuery updateQuery = new UpdateQueryBuilder()

                .withIndexName("library")

                .withType("book")

                .withId(book.getId()+"")

                .build();

        elasticsearchTemplate.update(updateQuery);

4.查询

查询不同于前面几个，查询比较复杂，比如模糊查询，组合查询，准确查询等。这些变化来源于不同的QueryBuilder，查询的模板是相同的。如下：

        @Autowired

        private ElasticsearchTemplate elasticsearchTemplate;

        Sort sort = new Sort(Sort.Direction.DESC, "id");//以id值为准 降序排列，ASC为升序

        Pageable pageable = new PageRequest(0, 10, sort);//查看第0页，以每页10条划分

        SearchQuery searchQuery = new NativeSearchQueryBuilder()

                .withQuery(QueryBuilders.matchAllQuery()) // 自定义查询（这是不同的地方）

                .withPageable(pageable) // 自定义分页

                .build();

        Page<Book> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,Book.class);

        System.out.println("页数" + sampleEntities.getTotalPages());

        System.out.println("行数" + sampleEntities.getTotalElements());

        System.out.println("大小" + sampleEntities.getSize());

        System.out.println("当前第几页" + sampleEntities.getNumber());

        System.out.println("当前页的数量"+sampleEntities.getNumberOfElements());

        System.out.println("List<Book>:"+sampleEntities.getContent());

匹配所有文档的查询。

matchAllQuery()

为提供的字段名和文本创建类型为“BOOLEAN”的匹配查询。(解释过来就是单个匹配，可以模糊匹配)

matchQuery(String name, Object text) //name 字段值 ，text 查询文本（不支持通配符）

为提供的字段名和文本创建一个通用查询。

commonTermsQuery(String name, Object text)

为提供的字段名和文本创建类型为“BOOLEAN”的匹配查询。

multiMatchQuery(Object text, String... fieldNames)

为提供的字段名和文本创建一个文本查询，并输入“短句”。

matchPhraseQuery(String name, Object text)

为提供的字段名和文本创建一个与类型“PHRASE_PREFIX”匹配的查询。

matchPhrasePrefixQuery(String name, Object text)

匹配包含术语的文档的查询。

termQuery(String name, Object value)

使用模糊查询匹配文档的查询

fuzzyQuery(String name, Object value)

与包含指定前缀的术语的文档相匹配的查询。

prefixQuery(String name, String prefix)

在一定范围内匹配文档的查询。

rangeQuery(String name)

实现通配符搜索查询。支持的通配符是*，它匹配任何字符序列(包括空字符)，而?它匹配任何单个字符。注意，这个查询可能很慢，因为它需要遍历许多项。为了防止异常缓慢的通配符查询，通配符项不应该以一个通配符*或?开头。

wildcardQuery(String name, String query) //query 通配符查询字符串

将包含术语的文档与指定的正则表达式匹配的查询

regexpQuery(String name, String regexp) //regexp的正则表达式

解析查询字符串并运行它的查询。有两种模式。第一,当没有字段添加(使用QueryStringQueryBuilder.field(字符串),将运行查询一次,非前缀字段将使用QueryStringQueryBuilder.defaultField(字符串)。第二,当一个或多个字段添加(使用QueryStringQueryBuilder.field(String)),将运行提供的解析查询字段,并结合使用DisMax或普通的布尔查询(参见QueryStringQueryBuilder.useDisMax(布尔))。

queryStringQuery(String queryString)

类似于query_string查询的查询，但不会为任何奇怪的字符串语法抛出异常。

simpleQueryStringQuery(String queryString)

可以使用BoostingQuery类来有效地降级与给定查询匹配的结果。

boostingQuery()

匹配与其他查询的布尔组合匹配的文档的查询

boolQuery()

创建一个可用于实现MultiTermQueryBuilder的子查询的SpanQueryBuilder。

spanMultiTermQueryBuilder(MultiTermQueryBuilder multiTermQueryBuilder)

允许定义自定义得分函数的查询。

functionScoreQuery(QueryBuilder queryBuilder, ScoreFunctionBuilder function)

更像这样的查询，查找“like”提供的文档，例如提供的MoreLikeThisQueryBuilder.likeText(String)，它是针对查询所构造的字段进行检查的

moreLikeThisQuery(String... fields)

构造一个新的非计分子查询，包含子类型和要在子文档上运行的查询。这个查询的结果是这些子文档匹配的父文档。

hasChildQuery(String type, QueryBuilder query)

构造一个新的非评分父查询，父类型和在父文档上运行的查询。这个查询的结果是父文档匹配的子文档。

hasParentQuery(String type, QueryBuilder query)

基于对其中任何一个项进行匹配的若干项的字段文件

termsQuery(String name, String... values)

一个查询构建器，它允许构建给定JSON字符串或二进制数据作为输入的查询。当您希望使用Java Builder API，但仍然需要将JSON查询字符串与其他查询构建器结合时，这是非常有用的。

wrapperQuery(String source)

QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery("name", "Love You");

添加一些文本以查找“类似”的文档

addLikeText(String... likeTexts)

查找类似文档

like(Item... likeItems)

设置不从其中选择（比如我们调用.like("西游").unlike("西游记")这样会导致啥也查不到）

unlike(String... unlikeTexts)

添加一些文本以查找与此不同的文档

addUnlikeText(String... unlikeTexts)

设置将包含在任何生成查询中的查询条件的最大数量。默认25

maxQueryTerms(int maxQueryTerms)

设置单词被忽略的频率，默认5，小于将不会被发现

minDocFreq(int minDocFreq)

设置单词仍然出现的最大频率。单词出现更多的文档将被忽略。默认为无限

maxDocFreq(int maxDocFreq)

设置将被忽略的单词的最小单词长度，默认0

minWordLength(int minWordLength)

设置将被忽略的单词的最大单词长度，默认无限

maxWordLength(int maxWordLength)

设置停止词，匹配时会忽略停止词

stopWords(String... stopWords)

设置词语权重，默认是1

boostTerms(float boostTerms)

查询权重（默认1）

boost(float boost)

设置不从其中选择术语的文本（文档Item）

ignoreLike(String... likeText)

使用elasticsearchTemplate的java代码

term是代表完全匹配，也就是精确查询，搜索前不会再对搜索词进行分词，所以我们的搜索词必须是文档分词集合中的一个

TermsBuilder:构造聚合函数

AggregationBuilders:创建聚合函数工具类

BoolQueryBuilder:拼装连接(查询)条件

QueryBuilders:简单的静态工厂”导入静态”使用。主要作用是查询条件(关系),如区间\精确\多值等条件

NativeSearchQueryBuilder:将连接条件和聚合函数等组合

SearchQuery:生成查询

elasticsearchTemplate.query:进行查询

Aggregations:Represents a set of computed addAggregation.代表一组添加聚合函数统计后的数据

Bucket:满足某个条件(聚合)的文档集合

SearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(matchAllQuery()).build();

return elasticsearchTemplate.queryForList(searchQuery, Product.class);