Elasticsearch-ais是我新写的Elasticsearch框架（或者也可以称之为springboot组件），他的操作方式非常简单，比现有的Elasticsearch操作方式都简单，希望大家可以使用
导入

        <dependency><groupId>com.github.lihang212010</groupId><artifactId>ais</artifactId><version>1.0.1</version></dependency><dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-client</artifactId><version>7.3.1</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.58</version><optional>true</optional></dependency>

ELASTICSEARCH-AIS

ELASTICSEARCH-AIS

地址：https://github.com/lihang212010/Elasticsearch-ais

javadoc:http://49.232.76.209:8080/download/apidocs/

为什么使用ais

更简单接近原生的代码操作

estemplate.term(“worker”,“farmer”); //这是查询worker属性为farmer的结果

自动映射结果
@RequestMapping("terms")
public List<User> terms() throws IOException {estemplate.terms("age",25,35,10,68);return estemplate.execute(index,User.class);
}

可以直接复制kibana中的代码
@RequestMapping("/findCustom")
public List<User>  findCustom(User user) throws IllegalAccessException, NoSuchFieldException, IOException {String script="GET demo/_search\n" +"{\n" +"  \"query\": {\n" +"    \"bool\": {\n" +"      \"must\": [\n" +"        {\n" +"          \"wildcard\": {\n" +"            \"name\": {\n" +"              \"value\": \"#{name}\"\n" +"            }\n" +"          }\n" +"        },\n" +"        {\n" +"          \"term\": {\n" +"            \"id\": {\n" +"              \"value\": \"#{id}\"\n" +"            }\n" +"          }\n" +"        }\n" +"      ],\n" +"      \"must_not\": [\n" +"        {\n" +"          \"range\": {\n" +"            \"age\": {\n" +"              \"gte\": #{age}\n" +"            }\n" +"          }\n" +"        }\n" +"      ]\n" +"    }\n" +"  },\n" +"  \"from\": \"#{pageFrom}\",\n" +"  \"size\": \"#{pageSize}\"\n" +"}";return estemplateCustom.excute(script,user);
}

对复杂需求的处理可以使用json和java代码

@Elasticsearch
public interface UserJson {
List findName(String name);
List findIdName(String name,String id);
}

{
“findName”: {
“requestMethod”: “GET”,
“index”: “demo/_search”,
“script”: {
“query”: {
“wildcard”: {
“name”: {
“value”: “#{name}”
}
}
}
}
},

“findIdName”: {

"requestMethod": "GET",
"index": "demo/_search",
"script": {"query": {"bool": {"must": [{"wildcard": {"name": {"value": "#{name}"}}},{"term": {"id": {"value": "#{id}"}}}]}}
}

}
}


@[TOC](maven导入)
简单配置pop.xml
    <dependency><groupId>com.github.lihang212010</groupId><artifactId>ais</artifactId><version>1.0.0</version></dependency><dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-client</artifactId><version>7.3.1</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.58</version><optional>true</optional></dependency>

@[TOC](配置文件配置属性)
elasticsearch.ais.url=node-3:9200                            集群则用逗号隔开
elasticsearch.ais.aisResource=com.ais                         @Elasticsearch注解的接口位置，不配置则扫描所有路径，会导致springboot启动较慢，建议配置为项目路径elasticsearch.ais.userName=""                                      用户名elasticsearch.ais.passWard=""                                       密码elasticsearch.ais.socketTimeout=30000                        socket连接超时时间elasticsearch.ais.connectTimeout=10000                       connect连接超时时间elasticsearch.ais.scheme="http"                                    访问方式elasticsearch.ais.header=""                                            请求头elasticsearch.ais.value=""                                                请求头对应值elasticsearch.ais.jsonPath=static                               json文件路径@[TOC](ESTEPLATE，简单例子)
ESTEPLATE，最简单的操作
Esteplate是ais中最简单也是最常用的操作Elasticsearch的操作方式，它可以让你只用几行代码就轻松实现所需要的功能。在使用的时候我们只需要借助spring中的注入，便可以轻松使用
@Autowired
Estemplate estemplate;

下面我简单的写出几个使用例子，这些例子只是展示ais操作的简单。
@Autowired
Estemplate estemplate;@RequestMapping("/insert1")
public void insert1(List<User> list,String index) throws IOException {estemplate.insert(list,index);
}

User是一个实体类实际上我们的操作只有 estemplate.insert(list,index); 这么一行，index是对应插入的索引位置，list则是一个实体类List，ais会自动排除List中的空值，所以并不需要我们对空值进行判断。当然除了这些ais还支持Map对象的插入和单一实体类的插入。
@Autowired
Estemplate estemplate;@RequestMapping("/delete")
public void delete(String index,String id) throws IOException {estemplate.delete(index,id);
}


index是需要删除的对应索引，id则是需要删除的id查询是Elasticsearch中最重要最常用的功能而ais简化了足够平常工作需求的查询操作，对于过于复杂的操作，Elasticsearch也提供了类似Mybatis的方式进行操作。
@Autowired
Estemplate estemplate;    public List<User> find() throws IOException {estemplate.wildcard("name","li");estemplate.term("worker","farmer");estemplate.rangelte("age",18);return estemplate.execute("/demo/user",User.class);
}

比如我们需要查询name属性中包含li，worker属性等于farmer，age小于等于18的对象，只需要3行查询和一行执行即可。@[TOC](插入)
插入
ais支持3种方式的插入,批量插入和单一一条数据的插入，它插入的对应api只有一行estemplate.insert(list,index);list为需要插入的数据，它支持3种方式，List，Map，和单一实体类，index为对应索引（elasticsearch7中抛弃了type）对于我们需要插入一条数据的情况，User为对应实体类
@Autowired
Estemplate estemplate;public void insert3(String index,User user) throws IOException {estemplate.insert(user,index);
}

对于需要插入一组数据的情况
public void insert1(List<User> list,String index) throws IOException {estemplate.insert(list,index);
}

对于需要插入一组数据并且自定义每一个数据的对应id时
public void insert2(Map<Object,User> map,String index) throws IOException {estemplate.insert(map,index);
}


map中的键为你需要设置的id，值则是对应的数据@[TOC](查询)
查询
查询是Elasticsearch中最重要的操作，Esteplate封装的查询与Elasticsearch中的查询操作是非常相似的，如果你熟练使用kibana，则可以无难度使用ais的查询，当然，你如果没有操作过kibana，也可以很快上手ais的查询。查询规则
Esteplate默认所有查询为query查询，但是同样支持过滤查询，这里简单说一下Elasticsearch的2种查询，过滤查询（filter）和评分查询（query），评分查询会对查询结果进行打分排序，但性能方面略次于过滤查询，因此我们可以对不要求查询结果的选项进行过滤查询Esteplate的将查询分为4类must                  必须满足的查询must_not         必须不满足的查询filter_must               必须满足的过滤查询filter_must_not      必须不满足的过滤查询Esteplate的默认查询为must查询，但是可以在第一个参数中修改本次查询的查询方式如：
estemplate.term("worker","farmer");  //这是查询worker属性为farmer的结果estemplate.term("must_not","worker","farmer");   //这是查询worker属性不为farmer的结果estemplate.term("filter_must","worker","farmer");   //这是通过过滤查询查询worker属性为farmer的结果estemplate.term("filter_must_not","worker","farmer");   //这是通过过滤查询查询worker属性不为farmer的结果Esteplate会默跳过空值
比如
    estemplate.wildcard("name","li");estemplate.term("worker","");estemplate.rangelte("age",18);


worker如果为空值，则本次查询将只对name和age进行查询@[TOC](查询相关API)这些API如果你操纵过kibana，一定会非常属性，他和Elasticsearch中的名字是相同的，如果你不太明白，本文将提供一些简单的使用场景，对于每一个查询的具体内容，更建议Elasticsearch官方文档
.
.
.
查询常用参数
type，           查询的方式，默认为must，可以选择must_not，filter_must ，filter_must_notkey，             对应字段，查询的对应属性在Elasticsearch中名称value，          需要查询的对应值index              对应索引boost              排名分数比例，默认为1具体API查询相关的APIterm              准确查询，必备参数：key，value            可选参数type，boostwildcard       左右模糊查询，必备参数:key，value   可选参数：type，boostmatch           分词查询，必备参数key，value    可选参数type，boostwildcardLeft                 左模糊查询，必备参数:key，value   可选参数：type，boostwildcardRight                右模糊查询，必备参数:key，value   可选参数：type，boostwildcardFree                 自定义模糊查询，必备参数:key，value   可选参数：boostterms           包含查询，必备参数key，value，这里的value可以是数组和一个数，可选参数：typematch_phrase         短语匹配，必备参数key，value，可选参数：slop：作用为词与词之间允许相隔的单词数目;          typematch_phrase_prefix      短语前缀匹配，必备参数key，value，可选参数：slop：词与词之间允许相隔的单词数目，max_expansions：指定前缀最多匹配多少结果;         typecommon                    高频率查询，通过排除文章中的常用词来提高查询结果，不影响性能，必备参数：key，value，cutoff_frequency：排除文章中出现频率多少的词，可选参数：typeexits                          判断某一属性是否存在，必备参数key，可选参数：typefuzzy                          纠错查询，会允许输入的参数有多少错误，必备参数：key，value，可选参数：fuzziness：允许多少错误，prefix_length：精确查询的长度，typegeo_shape              地理位置查询，必备参数：key，coordinates：地理位置坐标，通常为一个多维数组，relation：查询方式ids                             id查询，必备参数values，可以是一个id，也可以是一个id组成的数组,可选参数：typemulti_match          多字段分词查询，必备参数value，需要查找的值，keys，对应的字段数组，可选参数：typemore_like_this      必须包含词查询，要求某（一个或多个）字段内容必须包含某一分词，必备参数：value：必须包含的分词，keys：字段，可以是一个或多个，min_term_freq：最小包含数目，
max_query_terms：最多包含数目，可选参数：typepercolate                 索引属性查询，对某一字段的索引属性进行查询，必备字段：key，value，field：存索引查询 的类型的字段，可选参数，typeprefix                        左模糊（较为推荐），必备字段，key，value，可选参数：boost，typequery_string           较为严格的字符串查询（可以进行和或非等操作，但如果查询中包含无效内容，则查询失败），必备字段：default_field：对应字段，query_：查询内容，可选参数：typerange                         范围查询，必备参数：key，gte：大于等于的数值，lte小于等于的数值，可选参数：typerangegte                    大于等于范围查询，必备参数：key，gte：大于等于的数值，可选参数：typerangelte                         小于等于范围查询，必备参数：key，lte小于等于的数值，可选参数：typeregexp                         正则查询，必备参数：key，value，可选参数：max_determinized_states：查询所需最大数目，默认10000,flags：可选运算符，typescript                          脚本，可以自由植入自己想进行的语句，必备参数：source：植入的脚本，可选参数，lang，params，typesimple_query_string         使用较为简单的符号操作进行查询（如+-|等），查询更为严格，必备参数：value，filed：一个或多个字段，可选参数：typewripper                        接受其他查询内容的查询，必备参数：query：其余查询的base64编码，可选参数：typefindFree                        插入Elasticsearch原生的语句，默认参数：query：插入的语句，可选参数：typeshould                       可以进行或之类的操作，也可以进行加分，minimum_should_match：最少满足多少项.
.
.
处理结果相关的API（这些操作较为简单，不依依展示，将会在几个常用查询例子中展示）source                     字段筛选，可以让结果之显示几个字段，参数：fields：一个或多个字段version                   是否显示版本号timeout                  查询时间stored_fields        另一种不太被推荐的字段筛选stats                      结果统计sort                        排序，如果需要对多个值进行排序，请在奇数位写需要排序的字段，偶数位写排序规则size                         （分页）每一页的最大数目from                       （分页）从第几页开始查询script_fields           脚本profile                      是否查看具体的聚合搜索过程以及具体耗时情况partial_fields          更加强大更为推荐的字段筛选indices_boost         相关度控制highlight                   高亮，可选字段pre_tags：高亮字段前面添加内容，post_tags：后面添加内容explain                      是否开启查看如何评分collapse                    字段折叠docvalue_fields      另一种查询，节省空间但会禁止使用sort、aggregate、access the field from script等查询结果：（以下3种查询均匀异步查询方法，使用方法类似）excute             获得所有查询结果并映射到实体类，参数：index：索引名，tClass：需要的返回值类型，requestMethod：请求方式excuteOne       执行所有查询，参数：index：索引名，tClass：需要的返回值类型，requestMethod：请求方式，tClass：需要的返回值类型excuteJson      执行所有查询并返回最原始的就是哦你结果，参数：index：索引名，requestMethod：请求方式如果你对这些查询有所疑问，接下来将会用几个简单的例子展示这些查询@[TOC](wildcard)wildcard是模糊查询，假如，我们有这样一组数据在ais中我们可以这样estemplate.wildcard("name","范");这样便会查询于所有名字中包含“范”的内容而在kibana中的查询是这样的

GET demo/_search
{
“query”: {
“wildcard”: {
“name”: {
“value”: “范”
}
}
}
}

estemplate.wildcardLeft("name","范");  这样则是查询name中所有范开头的内容estemplate.wildcardRight("name","范");  这样则是查询name中所有范结尾的内容estemplate.wildcardFree("name","*范*");  使用wildcardFree则需要自己插入匹配符号*或者.        *是匹配多个字符，.是匹配一个@[TOC](term)term是准确搜索
Elasticsearch一些版本中对字段属性中含有keyword必须加keyword，没有keyword属性则无所谓estemplate.term("name.keyword","奚范");
查询name中值为奚范的熟悉kibana中

GET demo/_search
{
“query”: {
“term”: {
“name.keyword”: {
“value”: “奚范”
}
}
}
}

@[TOC]match
match是分词查询，什么是分词查询比如：我们是朋友它是由我们，朋友，是3个词组成的在elasticsearch使用match查询这3个词中的任意一个都应该得到我们是朋友结果。同样我们的查询内容也会被分词，然后去和文章内容的分词比较match查询是elasticsearch中的核心查询，对于中文查询来说比较著名的是IK分词器
在ais中
estemplate.match("name","奚范");在kibana中

GET demo/_search
{
“query”: {
“match”: {
“name”: {
“query”: “奚范”
}
}
}
}

@[TOC]terms
terms又叫包含查询
例如
estemplate.terms("age",25,35,10,68);它可以查询age属性为23,35,10,68的所有数据，也可以查询age是一个数组，数组中有这几个数字中的数据
比如在程序中执行后这是我得到的一些结果在kibana中的terms

GET demo/_search
{
“query”: {
“terms”: {
“age”: [10,25,35,68]
}
}
}

@[TOC](match_phrase)
match_phrase是短语查询estemplate.match_phrase("title","We  friends",2);    2是允许词与词之间最大相隔几个单词
在文中title的内容为We are good friends，而我们查询的内容是We friends，中间少一个good，但是我们允许词与词之间可以有2个相隔单词，所以可以查询到对应内容kibana中语句

GET demo/_search
{
“query”: {
“match_phrase”: {
“title”: {
“query”: “We friends”,
“slop”: 2
}
}
}
}

@[TOC](match_phrase_prefix)
match_phrase_prefix 比起match_phrase多了个前缀查询还是这组数据
estemplate.match_phrase_prefix("title","We  good f",2);这句话的意思是查询语句中We are good然后下一个单词的首字母为f开头的数据，可以允许最多空2个词

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“match_phrase_prefix”: {
“title”: {
“query”: “We good f”,
“max_expansions”: 10,
“slop”:2
}
}
}
]
}
}
}

@[TOC](common)
common主要作用是排除查询选项中一些常用词比如英语中的is，are，汉语中的是，我，他之类参数：cutoff_frequency：出现的频率使用方式estemplate.common("title","We are",0.01);kibana中

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“match_phrase_prefix”: {
“title”: {
“query”: “We good f”,
“max_expansions”: 10,
“slop”:2
}
}
}
]
}
}
}

@[TOC](extis)
extis   判断某一属性是否存在estemplate.exits("title");kibana中使用方式

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“common”: {
“title”: {
“query”: “We are”,
“cutoff_frequency”: 0.01
}
}
}
]
}
}
}


@[TOC](fuzzy)
fuzzy是一种允许错误的term查询
参数：fuzziness：允许多少错误estemplate.fuzzy("name","李松",1);
因为允许一个错误所以可以查询李张，和张松这些数据kibana中的

GET demo/_search
{
“query”: {
“fuzzy”: {
“name”: {
“value”: “孙a”,
“fuzziness”: 1
}
}
}
}

@[TOC](ids)
查询某一个id，注意Elasticsearch一般是独立与存储数据的，所以一般会设置id等于数据中的某一字段使用方式estemplate.ids("09EprnABqEAuwq_e8YJH","19EprnABqEAuwq_e8YJH");查询这2个id的对应数据或者estemplate.ids("09EprnABqEAuwq_e8YJH");查询此id对应数据kibana中

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“ids”: {
“values”: [
“09EprnABqEAuwq_e8YJH”,
“19EprnABqEAuwq_e8YJH”
]
}
}
]
}
}
}

@[TOC](multi_match)
multi_match          多字段分词查询
.
estemplate.multi_match("are","name","title");查询在name和title字段中含有are单词的数据
.
kibana中代码

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“multi_match”: {
“query”: “are”,
“fields”: [
“name”,
“title”
]
}
}
]
}
}
}

@[TOC](more_like_this)
more_like_this      必须包含词查询，要求某（一个或多个）字段内容必须包含某一分词，必备参数：value：必须包含的分词，keys：字段，可以是一个或多个，min_term_freq：最小包含数目，max_query_terms：最多包含数目，可选参数：type
.
estemplate.more_like_this(1,10,"are","title");作用：查询出字段title中含有1-10个are的数据
.
kibana中代码

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“more_like_this”: {
“fields”: [
“title”
],
“like”: “are”,
“min_term_freq”: 1,
“max_query_terms”: 10
}
}
]
}
}
}


@[TOC](prefix)
PREFIX
左模糊查询estemplate.prefix("name","李");查询所有姓“李”的.
kibana中代码

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“prefix”: {
“name”: {
“value”: “李”
}
}
}
]
}
}
}

@[TOC](query_string)
query_string           较为严格的字符串查询（可以进行和或非等操作，但如果查询中包含无效内容，则查询失败），必备字段：default_field：对应字段，query_：查询内容，可选参数：typeestemplate.query_string("name","(孙李) OR (李周)");查询name为孙李或者李周的人
.kibana中

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“query_string”: {
“default_field”: “name”,
“query”: “(孙李)OR(李周)”
}
}
]
}
}
}

@[TOC](range)
range                         范围查询，必备参数：key，gte：大于等于的数值，lte小于等于的数值，可选参数：type
.
estemplate.range("age",10,100);查询age在10和100之间的数据
.estemplate.rangelte("age",100);查询age小于100的数据estemplate.rangegte("age",10);查询age大于10的数据
.
kibana中语句

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“range”: {
“age”: {
“gte”: 10,
“lte”: 100
}
}
}
]
}
}
}


@[TOC](regexp)
regexp                         正则查询，必备参数：key，value，可选参数：max_determinized_states：查询所需最大数目，默认10000,flags：可选运算符，type
.
estemplate.regexp("name","孙.?");查询孙开头的字当然正则表达式的写法很多，几乎可以满足所有需求，大家可以自行百度
.
kibana中代码

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“regexp”: {
“name”: {
“value”: “孙.?”
}
}
}
]
}
}
}

@[TOC](script)
script                          脚本，可以自由植入自己想进行的语句，必备参数：source：植入的脚本，可选参数，lang，params，typescript是高级elasticsearch程序员的必备技能，它使用了另一种语言，本文将不在具体解释，只提供一个简单例子
.
estemplate.script("doc['age']>10");查询age大于10的数据
.
kibana中代码

GET demo/_search
{
“query”: {
“bool”: {
“must”: [
{
“regexp”: {
“name”: {
“value”: “孙.?”
}
}
}
]
}
}
}

@[TOC](findFree)
findFree                        插入Elasticsearch原生的语句，默认参数：query：插入的语句，可选参数：type对于api中没有的查询方式或者更为麻烦的查询方式或者想自己拼写代码的人可以使用
    String query="{\n" +"    \"term\": {\n" +"      \"name.keyword\": {\n" +"        \"value\": \"奚范\"\n}" +"      }\n" +"    }";estemplate.findFree(query);

@[TOC](should)
should是或操作，在ais中使用着稍显复杂
estemplate.should(1,Find.term("name","张三"),Find.term("name","liu"));
这个是在后面的2个精确情况下必须满足其中其中一个
Find是一个静态类，他的使用方式和Esteplate相似@[TOC](几个常用的查询例子)
几个常用的查询例子

@RestController
public class Finds {

@Autowired
Estemplate estemplate;private String index="demo";/*
* 这个查询为age在10和48之间,但不在22-24的，name首字母为李的，title中含有are，worker是Teacher或者Doctor的从0位开始到第20位
* */
@RequestMapping("find1")
public List<User> find1() throws IOException {estemplate.range("age",10,48);estemplate.range("must_not","age",22,24);estemplate.prefix("name","李");estemplate.wildcard("title","are");estemplate.terms("worker","Teacher","Doctor");estemplate.from(0);estemplate.size(20);return estemplate.execute(index,User.class);
}/*
* 姓名是张三或者liu的age大于20的
* */
@RequestMapping("find2")
public List<User> find2() throws IOException {estemplate.script("doc['age']>20");estemplate.should(1,Find.term("name","张三"),Find.term("name","liu"));estemplate.from(0);estemplate.size(20);return estemplate.execute(index,User.class);
}

}

@[TOC](在前后端分离或者微服务中查询的简单使用)
在前后端分离或者微服务中的简单使用

@RestController
public class FindController {

@Autowired
Estemplate estemplate;private String index="demo";/** User为实体类,ais中默认会排除空值，所以并不需要检测空值* */
@RequestMapping("find")
public List<User> find(User user) throws IOException {estemplate.prefix("name",user.getName());estemplate.wildcard("title",user.getTitle());estemplate.term("age",user.getAge());estemplate.wildcard("data",user.getDate());estemplate.from(0);estemplate.size(20);return estemplate.execute(index,User.class);
}

}

@[TOC](修改)
修改有3种，一种是修改单一属性的Map中的key为你要修改的字段，value为要修改的值
public void update(String id, Map<String,Object> map,String index) throws IOException {estemplate.update(id,map,index);
}

这一种是批量修改，第一个Map的key是id，Map中的Map的key为你要修改的字段，value为要修改的值
public void update1(Map<String,Map<String,Object>> map,String index) throws IOException {estemplate.update(map,index);
}

还有一种是借助查询规则的修改
例如下面的是将所有名字中包含李的修改title为***
@RequestMapping("/update_by_query")
public void update_by_query() throws IOException {estemplate.wildcard("name","李");Map<String,String> map=new HashMap();map.put("title","We are good friends. Our friendship will last forever");estemplate.update_by_query(map,index);
}

@[TOC](删除)
删除ais有2种删除一种是根据id删除,可以根据一个或多个id
public void delete(String index,String id) throws IOException {estemplate.delete(index,id);
}public void delete(String index,String ...id) throws IOException {estemplate.delete(index,id);
}

另一种是借助查询规则进行删除,比如下面的例子是删除所有age等于10岁的
public void delete_query() throws IOException {estemplate.term("age","10");estemplate.delete_by_query("demo");
}

@[TOC](实体类的增删改差模板使用)
POJOTEMPLATE-一个实体类的增删改差
POJOTemplate是一个对实体类进行规则定义的模板，在使用它的时候我们只需要继承POJOTemplate这个抽象类，然后定义相对应的查询规则
例如：

@Repository
public class UserTemplate extends POJOTemplate {

/*
* 设置索引
* */
@Override
public void setIndex() {this.index="demo";
}
/*
* 设置分页等属性
* */
@Override
public void setConfig(User entity) {estemplate.from(entity.getPageFrom());estemplate.size(entity.getPageSize());
}/*
* 设置可以通过id和name进行查询
* */
@Override
public void findRule(User user) {estemplate.term("id",user.getId());estemplate.wildcard("name.keyword",user.getName());
}

}


首先我们要定义他对应的索引名字，然后定义它的一些设置规则（如分页高亮等）和查询规则，然后我们便可以根据对应的id或者name进行查询，修改，删除等操作（默认删除和修改使用的是查询规则）

@RestController
public class FindController {

@Resource
UserTemplate userTemplate;@RequestMapping("findUser")
public List<User> findUser(User user) throws IOException {return userTemplate.find(user);
}@RequestMapping("updateUser")
public String updateUser(User user) throws IOException {try {Map<String,String> map=new HashMap<>();map.put("name","走姊姊");return userTemplate.update(user,map).toString();}catch (Exception e){return e.toString();}}@RequestMapping("insertUser")
public String insertUser(User user){try {return userTemplate.insert(user).toString();} catch (Exception e) {return "error" + e;}
}@RequestMapping("deleteUser")
public String deleteUser(User user){try {return userTemplate.delete(user).toString();}catch (Exception e){return e.toString();}
}

}

@[TOC](模板规则)
模板使用的一些规则
POJO是一种非常容易的对elasticsearch操作的方法，使用它可以我们甚至将实体类中没一个属性都去写一个查询规则，将查询，修改，删除，增加等操作简化成一个类。
但是使用它的时候要注意一点
默认删除，查询和修改使用的规则都是查询规则，他们能够共同使用的原因是因为Esteplate会自动跳过对空值的查询，因此，如果你需要使用自定义查询findFree时，请做好空值处理。另外，如果你不想自己的删除修改和查询使用同一规则，那么你可以给他们没一个都定义对应的规则
如：

@Repository
public class UserTemplate extends POJOTemplate {

@Override
public void setIndex() {this.index="demo";
}
@Override
public void setConfig(User entity) {estemplate.from(entity.getPageFrom());estemplate.size(entity.getPageSize());
}/*
* 设置可以通过id和name进行查询
* */
@Override
public void findRule(User user) {estemplate.term("id",user.getId());estemplate.wildcard("name.keyword",user.getName());
}/*
* 设置的只可以使用id进行删除
* */
@Override
public void deleteRule(User user){estemplate.term("id",user.getId());
}/** 设置的只可以使用name进行修改* */
@Override
public void updateRule(User user){estemplate.term("name",user.getId());
}

}

@[TOC](@Elasticsearch，json与java代码分离查询)
@Elasticsearch是一种类似与Mybatis的查询方式，不过相对应的是把xml查询文件修改为json文件，原因是elasticsearch的查询方式是基于json的
首先说下json的规则，json文件名必须与接口的文件名相同，然后json的第一级是对应的方法，第二季有3个属性，index对应索引位置，requestMethod请求方式，script对应脚本，对于需要替换的属性，使用#{}标注（数字等在ais中同样使用引号，负责#{}便不是json的格式了），然后使用@Elasticsearch只有3种返回结果，JSONObject,String,List<Entity>格式，对于正常的查找，我们使用list格式即可，其余操作按情况而定。
另外在使用@Autowired时，ais之默认把接口名字的首字母小写后注入为bean，
比如接口名字为FInd
则
@Autowired
Find find;下面简单看下它的几个例子

@Elasticsearch
public interface UserJson {
List findName(String name);
List findIdName(String name,String id);
}

{
“findName”: {
“requestMethod”: “GET”,
“index”: “demo/_search”,
“script”: {
“query”: {
“wildcard”: {
“name”: {
“value”: “#{name}”
}
}
}
}
},

“findIdName”: {

"requestMethod": "GET",
"index": "demo/_search",
"script": {"query": {"bool": {"must": [{"wildcard": {"name": {"value": "#{name}"}}},{"term": {"id": {"value": "#{id}"}}}]}}
}

}
}

@Elasticsearch
public interface UserSenior {
List findSenior(User user);
List findSeniorTest(User user);
}

{
“findSenior”: {
“requestMethod”: “GET”,
“index”: “demo/_search”,
“script”: {
“query”: {
“bool”: {
“must”: [
{
“wildcard”: {
“name”: {
“value”: “#{name}”
}
}
},
{
“term”: {
“id”: {
“value”: “#{id}”
}
}
}
],
“must_not”: [
{
“range”: {
“age”: {
“gte”: “#{age}”
}
}
}
]
}
}
}
},
“findSeniorTest”: {
“requestMethod”: “GET”,
“index”: “demo/_search”,
“script”: {
“query”: {
“bool”: {
“must”: [
{
“wildcard”: {
“name”: {
“value”: “#{name}”
}
}
},
{
“term”: {
“id”: {
“value”: “#{id}”
}
}
}
],
“must_not”: [
{
“range”: {
“age”: {
“gte”: “#{age}”
}
}
}
]
}
},
“from”: “#{pageFrom}”,
“size”: “#{pageSize}”
}
}
}

@RestController
public class FindJson {

@Autowired
UserJson userJson;@Autowired
UserSenior userSenior;@RequestMapping("/findName")
public List<User> findName(String name){return userJson.findName(name);
}@RequestMapping("/findIdName")
public List<User> findIdName(String name,String id){return userJson.findIdName(name,id);
}@RequestMapping("/findSenior")
public List<User> findSenior(User user){return userSenior.findSenior(user);
}@RequestMapping("/findSeniorTest")
public List<User> findSeniorTest(User user){return userSenior.findSeniorTest(user);
}

}

@[TOC](kibana内容的直接引用)
@Elasticsearch可以满足你的所有操作，但是当你的操作内容过于简单时候你可以选择EsteplateCuston，它是@Elasticsearch的java代码格式
你可能发现，我们是将所以kibana的代码复制出来，然后将对应的字段值替换成#{}
另外，EsteplateCuston里的方法当然不只有一种，它还可以单纯的去做执行，和一部分异步操作等功能（异步并不完善但可以使用）它方法中的参数：
index：索引
requestMethod：请求方式
tClass：实体类.class
entity: 对应实体类
url：请求路径

@RestController
public class FindCustom {

@Autowired
EstemplateCustom estemplateCustom;@RequestMapping("/findCustom")
public List<User>  findCustom(User user) throws IllegalAccessException, NoSuchFieldException, IOException {String script="GET demo/_search\n" +"{\n" +"  \"query\": {\n" +"    \"bool\": {\n" +"      \"must\": [\n" +"        {\n" +"          \"wildcard\": {\n" +"            \"name\": {\n" +"              \"value\": \"#{name}\"\n" +"            }\n" +"          }\n" +"        },\n" +"        {\n" +"          \"term\": {\n" +"            \"id\": {\n" +"              \"value\": \"#{id}\"\n" +"            }\n" +"          }\n" +"        }\n" +"      ],\n" +"      \"must_not\": [\n" +"        {\n" +"          \"range\": {\n" +"            \"age\": {\n" +"              \"gte\": #{age}\n" +"            }\n" +"          }\n" +"        }\n" +"      ]\n" +"    }\n" +"  },\n" +"  \"from\": \"#{pageFrom}\",\n" +"  \"size\": \"#{pageSize}\"\n" +"}";return estemplateCustom.excute(script,user);
}

}

@ELASTICSEARCHASYNC
@ElasticsearchAsync是@Elasticserach的异步操作，他们的使用方式相同但是@ElasticsearchAsync的操作并不太稳定和完善，我会及时完善对应的功能。

Elasticsearch-ais使用方式相关推荐

  1. Elasticsearch学习(3) spring boot整合Elasticsearch的原生方式

    前面我们已经介绍了spring boot整合Elasticsearch的jpa方式,这种方式虽然简便,但是依旧无法解决我们较为复杂的业务,所以原生的实现方式学习能够解决这些问题,而原生的学习方式也是E ...

  2. MySQL从零到一解读增量同步数据到elasticsearch canal adapter方式(binlog)实现

    本文是作者在单机上面从零到一实现增量同步MySQL数据到elasticsearch canal adapter方式(binlog)实现. 实现步骤 (1)安装MySQL (2)开启MySQL binl ...

  3. 【Elasticsearch】十九种Elasticsearch字符串搜索方式

    1.概述 十九种Elasticsearch字符串搜索方式 刚开始接触Elasticsearch的时候被Elasticsearch的搜索功能搞得晕头转向,每次想在Kibana里面查询某个字段的时候,查出 ...

  4. 【Elasticsearch】十九种Elasticsearch字符串搜索方式终极介绍 各种 查询

    本文为博主九师兄(QQ:541711153 欢迎来探讨技术)原创文章,未经允许博主不允许转载. 可以加我问问题,免费解答,有问题可以先私聊我,本人每天都在线,会帮助需要的人. 但是本博主因为某些原因, ...

  5. ElasticSearch通过Scroll方式遍历索引（Python代码）

    当我们要查询的数据量过大的时候,用es的from+size的方式会报错,会提示你from+size不能大于10000 那么可以用es的scroll方式,实际是一种深度分页机制 直接上代码: #-*- ...

  6. [ElasticSearch] 三种方式进行ES检索评分控制

    一.概要 在使用ES进行搜索时,评分的控制是非常关键的. 而如何对搜索评分进行定制化控制,让其更符合我们想要的评分结果呢? 对boost参数进行控制 通过rescore对查询结果的评分进行二次控制 使 ...

  7. java elasticsearch_在Spring java框架中使用ElasticSearch的最佳方式

    @Document( indexName = "person" , type = "user") public class Person { @Id priva ...

  8. Laravel 以ElasticSearch的方式使用scout

    Laravel5.3已经发布了,这次版本多了一个官方工具包:scout.这个包的作用就是帮助大家更好的将全文检索工具和项目更好的结合,让开发者使用起来更方便.但是我发现了一个问题:Laravel官方文 ...

  9. 结合CAP理论分析ElasticSearch的分布式实现方式

    简介 首先引出本人对ElasticSearch分布式的特点:再者针对分布式系统CAP理论,来论证分析ElasticSearch如何实现分布式?另外分析ElasticSearch在CAP理论的实现中是如 ...

最新文章

  1. 架构的能力是不断打磨1.0，2.0成就3.0，4.0
  2. 院士：国内科研目前内卷太严重，勿简单“抬轿子”
  3. C#中的Partial
  4. 聊聊微服务的隔离和熔断
  5. 【转】投影矩阵的推导
  6. 数学--数论--HDU 2104 丢手绢（离散数学 mod N+ 剩余类 生成元）+（最大公约数）
  7. LeetCode 314. 二叉树的垂直遍历（BFS/DFS）
  8. python 生成html_Python使用pyh生成HTML文档的方法示例
  9. ubuntu下vim配置成c++开发编辑器
  10. 牛客网–华为机试在线训练9：提取不重复的数
  11. 为什么vi用HJKL和ESC
  12. com.alibaba.fastjson.JSONArray cannot be cast to com.alibaba.fastjson.JSONObject
  13. XNA Game Studio 4.0 Programming 随便读，随便记 “Rendering Text”
  14. 网吧计费系统的破解方法
  15. 图片飞出去的特效怎么做？3分钟AE制作教程
  16. 增量式编码器工作原理以及使用
  17. MarkDown数学公式基本语法
  18. android6.0 cta认证,手机cta认证要求有哪些?
  19. 睿联技术在创业板过会：收入依赖摄像机单机，计划募资11亿元
  20. 古月居ROS暑期学校无人机部分学习笔记

热门文章

  1. JS Decorator —— 装饰器(装饰模式)
  2. 多线程？不用怕，大不了多学几遍 - 工具类
  3. 电机控制编程的数学运算优化方案
  4. php菜单无限极分类
  5. 信息传递（tarjan算法）
  6. Linux系统部署apk配置nginx
  7. 大数据基础知识（上）
  8. rz command
  9. css3 立方体3d旋转效果
  10. Maven入门-6-Maven的生命周期和核心命令详细介绍