ElasticSearch

version: "3.1"
services: 
  elasticsearch: 
    image: daocloud.io/library/elasticsearch:6.5.4
    restart: always
    container_name: elasticsearch
    ports: 
      - 9200:9200
  kibana: 
    image: daocloud.io/library/kibana:6.5.4
    restart: always
    container_name: kibana
    ports: 
      - 5601:5601
    environment: 
      - elasticsearch_url=http://localhost:9200
    depends_on: 
      - elasticsearch

docker-compose up -d

docker-compose logs -f           #查看日志

2.2启动时的问题

elasticsearch exited with code 78

max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

使用root用户：

sysctl -w vm.max_map_count=262144

sysctl -a|grep vm.max_map_count

vm.max_map_count = 262144

上述方法修改之后，如果重启虚拟机将失效，所以

在 /etc/sysctl.conf文件最后添加一行： vm.max_map_count=262144
OpenJDK 64-Bit Server VM warning: UseAVX=2 is not supported on this CPU, setting it to UseAVX=0

找到jvm.options配置文件 find /var/lib/docker/overlay/ -name jvm.options

修改UseAVX=0

首先访问es,安装成功

再访问kibana,安装成功

2.3安装IK分词器

github.com上搜索"ik"

GitHub - medcl/elasticsearch-analysis-ik: The IK Analysis plugin integrates Lucene IK analyzer into elasticsearch, support customized dictionary.

ik和es版本一致

下载地址： https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.5.4/elasticsearch-analysis-ik-6.5.4.zip

进入ES容器内部，跳转到bin目录下，执行bin目录下的脚本文件：

docker exec -it 79fa bash
cd bin 
./elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.5.4/elasticsearch-analysis-ik-6.5.4.zip

如果在docker容器内网络太慢，需多次深试太慢等，可考虑手动安装

1.首先将下载好的ik分词器拖到linux里面

2.将压缩包移动到容器中

docker cp /root/elasticsearch-analysis-ik-6.5.4.zip elasticsearch:/usr/share/elasticsearch/plugins

3.进入es容器

docker exec -it 79fa /bin/bash

4、创建目录

mkdir /usr/share/elasticsearch/plugins/ik

5、将文件压缩包移动到ik中

mv /usr/share/elasticsearch/plugins/elasticsearch-analysis-ik-6.5.4.zip /usr/share/elasticsearch/plugins/ik

6、进入目录

cd /usr/share/elasticsearch/plugins/ik

7、解压

unzip elasticsearch-analysis-ik-6.5.4.zip

8、删除压缩包（这步可以省略）

rm -rf elasticsearch-analysis-ik-6.5.4.zip

9、退出镜像

exit

10、重启docker镜像

docker restart elasticsearch

原文链接(ik分词器内存不足解决办法_星空不物语yog的博客-CSDN博客)

安装成功。详见(https://github.com/medcl/elasticsearch-analysis-ik GitHub - medcl/elasticsearch-analysis-ik: The IK Analysis plugin integrates Lucene IK analyzer into elasticsearch, support customized dictionary.):

三、ElasticSearch基本操作

3.1 ES的结构

3.1.1 索引 Index, 分片和备份

ES的服务中，可以创建多个索引。

每一个索引默认被分成5片存储

每一个分片都会存在至少一个备份分片。

备份分片默认不会帮助检索数据，当ES检索压力特别大的时候，备份分片才会帮助检索数据。

备份的分片必须放在不同的服务器中。

3.1.2 类型 Type (类似数据库表)

一个索引下，可以创建多个类型

Ps:根据版本不同，类型的创建也不同

3.1.3 文档 Doc

一个类型下，可以有多个文档，这个文档就类似于MySQL表中的多行数据。

3.1.4 属性 Field

一个文档中，可以包含多个属性。类似于MySQL表中的一行数据存在多个列。

3.2 操作ESRESTful语法

GET请求：

http://ip:prot/index 查询索引信息

http://ip:prot/index/type/doc_id : 查询指定的文档信息

POST请求：

http://ip:port/index/type/_search: 查询文档，可以在请求体中添加json字符串来代替查询条件

http://ip:port/index/type/doc_id/_update: 修改文档，在请求体中指定json字符串代表修改的具体信息

PUT请求：

http://ip:port/index: 创建一个索引，需要在请求体中指定索引的信息，类型，结构

http://ip:port/index/type/_mappings: 代表创建索引时，指定索引文档存储的属性的信息

DELETE请求:

http://ip:port/index：删除跑路

http://ip:port/index/type/doc_id: 删除指定的文档

3.3 索引的操作

3.3.1 创建一个索引

#创建一个索引
PUT /student
{
  "settings": {"number_of_shards": 5,
    "number_of_replicas": 1
  }
}

创建成功。

3.3.2 查看索引信息

#查看索引信息
GET /student

3.3.3 删除索引

#删除索引
DELETE /student

3.4 ES中Field可以指定的类型

string:

text: 一般被用于全文检索。将当前Field进行分词

keyword: 当前Field不会被分词

数据类型：

long：A signed 64-bit integer with a minimum value of -263 and a maximum value of 263-1.
integer：A signed 32-bit integer with a minimum value of -231 and a maximum value of 231-1.
short：A signed 16-bit integer with a minimum value of -32,768 and a maximum value of 32,767.
byte：A signed 8-bit integer with a minimum value of -128 and a maximum value of 127.
double：A double-precision 64-bit IEEE 754 floating point number, restricted to finite values.
float：A single-precision 32-bit IEEE 754 floating point number, restricted to finite values.
half_float：A half-precision 16-bit IEEE 754 floating point number, restricted to finite values. 精度是16位
scaled_float：A finite floating point number that is backed by a long, scaled by a fixed double scaling factor.

时间类型：

data类型: 针对时间类型指定具体的格式

布尔类型:

boolean类型：表达true和flase

二进制类型：

binary类型暂时支持Base 64 encode string

范围类型：

long_range: 赋值时，无序指定具体的内容，只需要存储一个范畴即可，指定gt, lt,gte,lte

integer_range: 同上。

double_range: 同上。

float_range: 同上。

date_range: 同上。

ip_range: 同上。

经纬度类型：

geo_point: 用来存储经纬度的

ip类型:

ip: 可以存储IPv4或者IPv6

其他的数据类型参考官网：Field datatypes | Elasticsearch Reference [6.0] | Elastic

3.5 创建索引并指定数据结构

#创建索引 指定数据结构
PUT /book
{
  "settings": {
      #分片数
    "number_of_shards": 5, 
      #备份数
    "number_of_replicas": 1
  },
  # 指定数据结构
  "mappings": {
    #类型Type
    "novel": {
      #文档存储的Field
      "properties": {
        #Field属性名
        "name": {
          #类型
          "type": "text",
          #指定分词器
          "analyzer": "ik_max_word",
          #指定当前Field可以被作为查询的条件
          "index": true,
          #是否需要额外存储
          "store": false
        },
        "author": {
          "type": "keyword"
        },
        "count": {
          "type": "long"
        },
        "onSale": {
          "type": "date",
          #时间类型的格式化方式
          "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
        },
        "descr": {
          "type": "text",
          "analyzer": "ik_max_word"
        }
      }
    }
  }
}

3.6文档的操作

文档在ES服务中的唯一标识，_index, _type, _id 三个内容为符合，锁定一个文档，操作是添加还是修改。

3.6.1新建文档

自动生成_id

#添加文档，自动生成id
POST  /book/novel
{
  "name": "盘龙",
  "author": "我吃西红柿",
  "count": 100000,
  "on-sale": "2000-01-01",
  "descr": "你是个上天入地不进佛门看不见二龙戏水天空之城来无影去无踪一百万年"
}

手动指定_id

#添加文档，手动指定，还可以修改
POST  /book/novel/13
{
  "name": "水浒传",
  "author": "施耐庵",
  "count": 100000,
  "on-sale": "2000-01-01",
  "descr": "生死之交一碗酒，说走就走啊，"
}

3.6.2修改文档

覆盖式修改

#添加文档，手动指定，还可以修改
POST  /book/novel/13
{
  "name": "水浒传",
  "author": "施耐庵",
  "count": 50060,
  "on-sale": "2000-01-01",
  "descr": "生死之交一碗酒，说走就走啊，"
}

doc修改方式

#修改文档， 基于doc方式
POST /book/novel/13/_update 
{
  "doc": {
    # 指定上需要修改的field和对应的值
    "count": "123456"
  }
}

3.6.3 删除文档

#根据id删除文档
DELETE /book/novel/6_Z6-IgBZ4yYF0O03_PD  //_id

四. Java操作ElasticSearch

4.1 Java连接ES

1.创建Maven工程

2.导入依赖

 //elasticesearch
 <!-- https://mvnrepository.com/artifact/org.elasticsearch/elasticsearch -->
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>6.5.4</version>
        </dependency>
        //elasticesearch的高级API
        <!-- https://mvnrepository.com/artifact/org.elasticsearch.client/elasticsearch-rest-high-level-client -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>6.5.4</version>
        </dependency>
        //junit
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        //lombok
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.22</version>
        </dependency>

3.创建测试类，转接ES

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;

public class ESClient {
    public static RestHighLevelClient getClient(){
        //创建HttpHost对象
        HttpHost httpHost = new HttpHost("192.168.0.252", 9200);

        //创建RestClientBuilder
        RestClientBuilder clientBuilder = RestClient.builder(httpHost);

        //创建RestHighLevelClient
        RestHighLevelClient client = new RestHighLevelClient(clientBuilder);

        //返回
        return client;
    }
}

4.2 Java创建索引

4.2.1 创建索引

public class Demo2 {

    RestHighLevelClient client = ESClient.getClient();
    String index = "persons";
    String type="man";

    @Test
    public void createIndex() throws IOException {
        //1.准备关于索引的settings
        Settings.Builder settings = Settings.builder().put("number_of_shards", 3).put("number_of_replicas", 1);
        //2.准备关于索引的结构mappings
        XContentBuilder mappings = JsonXContent.contentBuilder()
                .startObject()
                    .startObject("properties")
                        .startObject("name")
                            .field("type", "text")
                        .endObject()
                        .startObject("age")
                            .field("type", "integer")
                        .endObject()
                        .startObject("birthday")
                            .field("type", "date")
                            .field("format", "yyyy-MM-dd")
                        .endObject()
                    .endObject()
                .endObject();
        //3. 将settings和mappings封装到一个一个Request对象
        CreateIndexRequest request = new CreateIndexRequest(index)
                .settings(settings)
                .mapping(type, mappings);
        //4.通过client对象去连接ES并执行创建索引
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        //5.输出
        System.out.println(response);
    }
}

4.2.2检查索引是否存在

    @Test
    public void exists() throws IOException {
        //1. 准备request对象
        GetIndexRequest request = new GetIndexRequest();
        request.indices(index);
        //2. 通过client去操作
       boolean exists =  client.indices().exists(request, RequestOptions.DEFAULT);
        //3. 输出
        System.out.println(exists);
    }

4.2.3 删除索引

 @Test
    public void delete() throws IOException {
        //1. 准备Request对象
        DeleteIndexRequest request = new DeleteIndexRequest();
        request.indices(index);
        //2. 通过client对象执行
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);

        //3. 获取返回结果
        System.out.println(delete.isAcknowledged());
    }

4.3 Java操作文档

4.3.1 添加文档操作

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.10.2</version>
        </dependency>

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    @JsonIgnore
    private Integer id;
    private String name;
    private Integer age;
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
}

public class Demo3 {
    ObjectMapper mapper=new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "persons";
    String type="man";

    @Test
    public void createDoc() throws IOException {
        //1.准备一个json数据
        Person person= new Person(1, "张三", 23, new Date());
        String json = mapper.writeValueAsString(person);
        //2.准备一个request对象
        IndexRequest request = new IndexRequest(index, type, person.getId().toString());
        request.source(json, XContentType.JSON);

        //3.通过client对象执行添加
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);

        //4.输出返回结果
        System.out.println(response.getResult().toString());
    }
}

4.3.2 修改文档

 @Test
    public void updateDoc() throws IOException {
        //1. 创建一个Map, 指定需要悠的内容
        Map<String, Object> doc=new HashMap<>();
        doc.put("name", "张大三");
        String docId="1";
        //2. 创建request对象， 封装数据
        UpdateRequest request = new UpdateRequest(index, type, docId);
        request.doc(doc);
        //3. 通过client对角执行
        UpdateResponse update = client.update(request, RequestOptions.DEFAULT);
        //4. 输出返回结果
        System.out.println(update.getResult().toString());
    }

4.3.3 删除文档

 @Test
    public void deleteDoc() throws IOException {
        //1.封装Request对象
        DeleteRequest request = new DeleteRequest(index, type, "1");
        //2. client执行
        DeleteResponse delete = client.delete(request, RequestOptions.DEFAULT);
        //3. 输出结果
        System.out.println(delete);
    }

4.4 Java批量文件操作

4.4.1 批量添加

    @Test
    public void bulkCreateDoc() throws IOException {
        //1. 准备多个 json 数据
        Person p1= new Person(1, "张三", 23, new Date());
        Person p2= new Person(2, "李四", 24, new Date());
        Person p3= new Person(3, "王麻子", 25, new Date());

        String json1 = mapper.writeValueAsString(p1);
        String json2 = mapper.writeValueAsString(p2);
        String json3 = mapper.writeValueAsString(p3);

        //2. 创建Request, 将准备好的数据封装进去
        BulkRequest request = new BulkRequest();
        request.add(new IndexRequest(index, type, p1.getId().toString()).source(json1, XContentType.JSON));
        request.add(new IndexRequest(index, type, p2.getId().toString()).source(json2, XContentType.JSON));
        request.add(new IndexRequest(index, type, p3.getId().toString()).source(json3, XContentType.JSON));
        //3. 用client执行
        BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);

        //4. 输出结果
        System.out.println(resp.toString());
    }

4.4.2 批量删除

    @Test
    public void bulkDeleteDoc() throws IOException {
        //1. 封装Requext对象
        BulkRequest request = new BulkRequest();
        request.add(new DeleteRequest(index, type, "1"));
        request.add(new DeleteRequest(index, type, "2"));
        request.add(new DeleteRequest(index, type, "3"));

        //2. client执行
       BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);

       //3. 输出
        System.out.println(bulkResponse);
    }

五、ElasticSearch练习

准备练习数据

索引：sms-logs-index

类型：sms-logs-type

字段名称备注
createDate 创建时间
sendDate 发送时间
longCode 发送的长号码,
mobile 如: 13825642584
corpName 发送公司名称，需要分词检索
smsContent 下发短信内容，需要分词检索
state 短信下发状态 0 成功， 1 失败
operatorid 运营商编号 1 移动， 2 联通 3 电信
province 省份
ipAddr 下发服务器IP地址
replyTotal 短信状态报告返回时长(秒)
fee 扣费(分)

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SmsLogs {
    private String id;// 唯一ID 1
    private Date createDate;// 创建时间
    private Date sendDate; // 发送时间
    private String longCode;// 发送的长号码
    private String mobile;// 下发手机号
    private String corpName;// 发送公司名称
    private String smsContent; // 下发短信内容
    private Integer state; // 短信下发状态 0 成功 1 失败
    private Integer operatorId; // '运营商编号 1 移动 2 联通 3 电信
    private String province;// 省份
    private String ipAddr; //下发服务器IP地址
    private Integer replyTotal; //短信状态报告返回时长（秒）
    private Integer fee;  // 费用
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.study.com.study.entity.SmsLogs;
import com.study.utils.ESClient;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.common.xcontent.json.JsonXContent;

import org.junit.Test;

import java.io.IOException;
import java.util.Date;

public class TestData {


    ObjectMapper mapper = new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    /**
     * 创建索引
     * @throws IOException
     */
    @Test
    public void createSmsLogsIndex() throws IOException, IOException {
        //1. settings
        Settings.Builder settings = Settings.builder()
                .put("number_of_shards", 3)
                .put("number_of_replicas", 1);

        //2. mapping.
        XContentBuilder mapping = JsonXContent.contentBuilder()
                .startObject()
                .startObject("properties")
                .startObject("createDate")
                .field("type", "date")
                .endObject()
                .startObject("sendDate")
                .field("type", "date")
                .endObject()
                .startObject("longCode")
                .field("type", "keyword")
                .endObject()
                .startObject("mobile")
                .field("type", "keyword")
                .endObject()
                .startObject("corpName")
                .field("type", "keyword")
                .endObject()
                .startObject("smsContent")
                .field("type", "text")
                .field("analyzer", "ik_max_word")
                .endObject()
                .startObject("state")
                .field("type", "integer")
                .endObject()
                .startObject("operatorId")
                .field("type", "integer")
                .endObject()
                .startObject("province")
                .field("type", "keyword")
                .endObject()
                .startObject("ipAddr")
                .field("type", "ip")
                .endObject()
                .startObject("replyTotal")
                .field("type", "integer")
                .endObject()
                .startObject("fee")
                .field("type", "long")
                .endObject()
                .endObject()
                .endObject();

        //3. 添加索引.
        CreateIndexRequest request = new CreateIndexRequest(index);
        request.settings(settings);
        request.mapping(type, mapping);
        client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println("OK!!");
    }

    /**
     * 文档
     * @throws IOException
     */
    @Test
    public void addTestData() throws IOException {
        BulkRequest request = new BulkRequest();

        SmsLogs smsLogs = new SmsLogs();
        smsLogs.setMobile("13800000000");
        smsLogs.setCorpName("途虎养车");
        smsLogs.setCreateDate(new Date());
        smsLogs.setSendDate(new Date());
        smsLogs.setIpAddr("10.126.2.9");
        smsLogs.setLongCode("10690000988");
        smsLogs.setReplyTotal(10);
        smsLogs.setState(0);
        smsLogs.setSmsContent("【途虎养车】亲爱的张三先生/女士，您在途虎购买的货品(单号TH123456)已 到指定安装店多日，" + "现需与您确认订单的安装情况，请点击链接按实际情况选择（此链接有效期为72H）。您也可以登录途 虎APP进入" + "“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问，请致电400-111-8868向途虎咨 询。");
        smsLogs.setProvince("北京");
        smsLogs.setOperatorId(1);
        smsLogs.setFee(3);
        request.add(new IndexRequest(index, type, "21").source(mapper.writeValueAsString(smsLogs), XContentType.JSON));

        smsLogs.setMobile("13700000001");
        smsLogs.setProvince("上海");
        smsLogs.setSmsContent("【途虎养车】亲爱的刘红先生/女士，您在途虎购买的货品(单号TH1234526)已 到指定安装店多日，" + "现需与您确认订单的安装情况，请点击链接按实际情况选择（此链接有效期为72H）。您也可以登录途 虎APP进入" + "“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问，请致电400-111-8868向途虎咨 询。");
        request.add(new IndexRequest(index, type, "22").source(mapper.writeValueAsString(smsLogs), XContentType.JSON));


        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs1 = new SmsLogs();
        smsLogs1.setMobile("13100000000");
        smsLogs1.setCorpName("盒马鲜生");
        smsLogs1.setCreateDate(new Date());
        smsLogs1.setSendDate(new Date());
        smsLogs1.setIpAddr("10.126.2.9");
        smsLogs1.setLongCode("10660000988");
        smsLogs1.setReplyTotal(15);
        smsLogs1.setState(0);
        smsLogs1.setSmsContent("【盒马】您尾号12345678的订单已开始配送，请在您指定的时间收货不要走开 哦~配送员：" + "刘三，电话：13800000000");
        smsLogs1.setProvince("北京");
        smsLogs1.setOperatorId(2);
        smsLogs1.setFee(5);
        request.add(new IndexRequest(index, type, "23").source(mapper.writeValueAsString(smsLogs1), XContentType.JSON));

        smsLogs1.setMobile("18600000001");
        smsLogs1.setProvince("上海");
        smsLogs1.setSmsContent("【盒马】您尾号7775678的订单已开始配送，请在您指定的时间收货不要走开 哦~配送员：" + "王五，电话：13800000001");
        request.add(new IndexRequest(index, type, "24").source(mapper.writeValueAsString(smsLogs1), XContentType.JSON));

        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs2 = new SmsLogs();
        smsLogs2.setMobile("15300000000");
        smsLogs2.setCorpName("滴滴打车");
        smsLogs2.setCreateDate(new Date());
        smsLogs2.setSendDate(new Date());
        smsLogs2.setIpAddr("10.126.2.8");
        smsLogs2.setLongCode("10660000988");
        smsLogs2.setReplyTotal(50);
        smsLogs2.setState(1);
        smsLogs2.setSmsContent("【滴滴单车平台】专属限时福利！青桔/小蓝月卡立享5折，特惠畅骑30天。" + "戳 https://xxxxxx退订TD");
        smsLogs2.setProvince("上海");
        smsLogs2.setOperatorId(3);
        smsLogs2.setFee(7);
        request.add(new IndexRequest(index, type, "25").source(mapper.writeValueAsString(smsLogs2), XContentType.JSON));

        smsLogs2.setMobile("18000000001");
        smsLogs2.setProvince("武汉");
        smsLogs2.setSmsContent("【滴滴单车平台】专属限时福利！青桔/小蓝月卡立享5折，特惠畅骑30天。" + "戳 https://xxxxxx退订TD");
        request.add(new IndexRequest(index, type, "26").source(mapper.writeValueAsString(smsLogs2), XContentType.JSON));


        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs3 = new SmsLogs();
        smsLogs3.setMobile("13900000000");
        smsLogs3.setCorpName("招商银行");
        smsLogs3.setCreateDate(new Date());
        smsLogs3.setSendDate(new Date());
        smsLogs3.setIpAddr("10.126.2.8");
        smsLogs3.setLongCode("10690000988");
        smsLogs3.setReplyTotal(50);
        smsLogs3.setState(0);
        smsLogs3.setSmsContent("【招商银行】尊贵的李四先生,恭喜您获得华为P30 Pro抽奖资格,还可领100 元打" + "车红包,仅限1天");
        smsLogs3.setProvince("上海");
        smsLogs3.setOperatorId(1);
        smsLogs3.setFee(8);
        request.add(new IndexRequest(index, type, "27").source(mapper.writeValueAsString(smsLogs3), XContentType.JSON));

        smsLogs3.setMobile("13990000001");
        smsLogs3.setProvince("武汉");
        smsLogs3.setSmsContent("【招商银行】尊贵的李四先生,恭喜您获得华为P30 Pro抽奖资格,还可领100 元打" + "车红包,仅限1天");
        request.add(new IndexRequest(index, type, "28").source(mapper.writeValueAsString(smsLogs3), XContentType.JSON));

        // -------------------------------------------------------------------------------------------------------------------

        SmsLogs smsLogs4 = new SmsLogs();
        smsLogs4.setMobile("13700000000");
        smsLogs4.setCorpName("中国平安保险有限公司");
        smsLogs4.setCreateDate(new Date());
        smsLogs4.setSendDate(new Date());
        smsLogs4.setIpAddr("10.126.2.8");
        smsLogs4.setLongCode("10690000998");
        smsLogs4.setReplyTotal(18);
        smsLogs4.setState(0);
        smsLogs4.setSmsContent("【中国平安】奋斗的时代，更需要健康的身体。中国平安为您提供多重健康保 障，在奋斗之路上为您保驾护航。退订请回复TD");
        smsLogs4.setProvince("武汉");
        smsLogs4.setOperatorId(1);
        smsLogs4.setFee(5);
        request.add(new IndexRequest(index, type, "29").source(mapper.writeValueAsString(smsLogs4), XContentType.JSON));

        smsLogs4.setMobile("13990000002");
        smsLogs4.setProvince("武汉");
        smsLogs4.setSmsContent("【招商银行】尊贵的王五先生,恭喜您获得iphone 56抽奖资格,还可领5 元打" + "车红包,仅限100天");
        request.add(new IndexRequest(index, type, "30").source(mapper.writeValueAsString(smsLogs4), XContentType.JSON));

        // -------------------------------------------------------------------------------------------------------------------


        SmsLogs smsLogs5 = new SmsLogs();
        smsLogs5.setMobile("13600000000");
        smsLogs5.setCorpName("中国移动");
        smsLogs5.setCreateDate(new Date());
        smsLogs5.setSendDate(new Date());
        smsLogs5.setIpAddr("10.126.2.8");
        smsLogs5.setLongCode("10650000998");
        smsLogs5.setReplyTotal(60);
        smsLogs5.setState(0);
        smsLogs5.setSmsContent("【北京移动】尊敬的客户137****0000，5月话费账单已送达您的139邮箱，" + "点击查看账单详情 http://y.10086.cn/; " + " 回Q关闭通知，关注“中国移动139邮箱”微信随时查账单【中国移动 139邮箱】");
        smsLogs5.setProvince("武汉");
        smsLogs5.setOperatorId(1);
        smsLogs5.setFee(4);
        request.add(new IndexRequest(index, type, "31").source(mapper.writeValueAsString(smsLogs5), XContentType.JSON));

        smsLogs5.setMobile("13990001234");
        smsLogs5.setProvince("山西");
        smsLogs5.setSmsContent("【北京移动】尊敬的客户137****1234，8月话费账单已送达您的126邮箱，\" + \"点击查看账单详情 http://y.10086.cn/; \" + \" 回Q关闭通知，关注“中国移动126邮箱”微信随时查账单【中国移动 126邮箱】");
        request.add(new IndexRequest(index, type, "32").source(mapper.writeValueAsString(smsLogs5), XContentType.JSON));
        // -------------------------------------------------------------------------------------------------------------------

        client.bulk(request,RequestOptions.DEFAULT);

        System.out.println("OK!");
    }
}

六. ElasticSearch的各种查询

6.1 term&terms查询

6.1.1 terms查询

term的查询是代表完全匹配，搜索之前不会对用户搜索的关键字进行分词，对用户分词的关键字去文档分词库中去匹配内容。

#term查询
POST /sms-logs-index/sms-logs-type/_search
{
  "from": 0,               # limit ？
  "size": 5,               # limit x.？
  "query": {
    "term": {
      "province": {
        "value": "北京"
      }
    }
  }
}

//java代码实现
public class Demo4 {
    ObjectMapper mapper=new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    @Test
    public void termQuery() throws IOException {
        //1. 创建Request对象
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.from(0);
        builder.size(5);
        builder.query(QueryBuilders.termQuery("province", "北京"));
        request.source(builder);
        //3. 执行查询
        SearchResponse resp = client.search(request, RequestOptions.DEFAULT);
        //4. 获取_source中的数据， 并展示
        for(SearchHit hit : resp.getHits().getHits())
        {
            Map<String, Object> result = hit.getSourceAsMap();
            System.out.println(result);
        }
    }
}

6.1.2 terms查询

terms和term的查询机制是一样的，都不会将指定的查询关键字进行分词，直接去分词库中匹配，找到相应文档内容。

terms是在针对一个字段包含多个值的时候使用。

term: where province="北京"

terms: where province="北京" or province=? or province=?

#terms查询
POST /sms-logs-index/sms-logs-type/_search
{
  "from": 0,
  "size": 5,
  "query": {
    "terms": {
      "province": [
        "北京",
        "山西",
        "武汉"
      ]
    }
  }
}

    //java代码实现
    @Test
    public void termsQuery() throws IOException {
        //1. 创建Request
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 封装查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.termsQuery("province", "北京", "山西"));
        request.source(builder);

        //3. 执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出_source
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.2 match查询

match查询属于高层查询，他会根据你查询的字段类型不一样，采用不同的查询的方式。

查询的是日期或者是数值，会自动基于字符串查询内容转换为日期或者数值对待。
如果查询的内容是一个不能被分词的内容(keyword)， match查询不会对你指定的查询关键字进行分词。
如果查询的内容时一个可以被分词的内容(text), match会将指定的查询内容根据一定的方式去分词，去分词库中匹配指定的内容。

match查询，实际底层就是多个term查询，将多个term查询的结果给封装到一起。

6.2.1 match_all 查询

查询全部内容，不指定任何查询条件。

#match all 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match_all": {}
  }
}

  @Test
    public void matchAllQuery() throws IOException {
        //1. 创建Request
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchAllQuery());
        builder.size(20);   //ES默认只查询10条数据， 如果想查询更多的，添加size
        request.source(builder);

        //3. 执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }

        System.out.println(response.getHits().getHits().length);
    }

6.2.2 match 查询

指定一个Field作为筛选条件

#match 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": "收货安装"
    }
  }
}

    @Test
    public void matchQuery() throws IOException {
        //1. 创建Request
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchQuery("smsContent", "收货安装"));

        request.source(builder);

        //3. 执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.2.3 布尔match查询

基于一个Field匹配的内容，采用and或者or的方式连接

#希尔match 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": {
        "query": "中国 健康",
        "operator": "and"
      }
      
    }
  }
}

#希尔match 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": {
        "query": "中国 健康",
        "operator": "or"
      }
      
    }
  }
}

    @Test
    public void booleanMatchQuery() throws IOException {
        //1. 创建Request
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchQuery("smsContent", "中国 健康").operator(Operator.OR));   //选择AND 或者 OR

        request.source(builder);

        //3. 执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.2.4 muti_match查询

match针对一个field做检索， muti_match针对多个field进行检索，多个field对应一个text。

# muti_match 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "multi_match": {
        "query": "北京",
        "fields": ["province", "smsContent"]
    }
  }
}

    @Test
    public void multiMatchQuery() throws IOException {
        //1. 创建Request
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.multiMatchQuery("北京", "province", "smsContent"));  

        request.source(builder);

        //3. 执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.3 其他查询

6.3.1 id查询

#id查询
GET /sms-logs-index/sms-logs-type/1

    @Test
    public void findById() throws IOException {
        //1. 创建GetRequest
        GetRequest request = new GetRequest(index, type, "31");

        //2、执行查询
        GetResponse response = client.get(request, RequestOptions.DEFAULT);

        //3、输出结果
        System.out.println(response.getSource());
    }

6.3.2 ids查询

根据多个id查询，类似MySql中的where id in (id1, id2, id3, ....)

# ids 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "ids": {
        "values": ["29", "30"]
    }
  }
}

   @Test
    public void findByIds() throws IOException {
        //1、创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2、指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.idsQuery().addIds("29","31"));
        request.source(builder);

        //3、执行
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4、输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.3.3 prefix查询

前缀查询，可以通过一个关键字去指定一个Field前缀，从而查询到指定的文档

#prefix 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "prefix": {
      "corpName": {
        "value": "途虎"
      }
    }
  }
}

 @Test
    public void findByPrefix() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.prefixQuery("corpName", "盒马"));
        request.source(builder);

        //3. 执行
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.3.4 fuzzy查询

模糊查询，我们输入字符的大概，ES就可以去根据输入的内容大概去匹配一下结果。

#fuzzy 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "fuzzy": {
      "corpName": {
        "value": "盒马行生",
        "prefix_length": 2    #指定前面几个字符不允许出现错误的
      }
    }
  }
}

    @Test
    public void findByFuzzy() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.fuzzyQuery("corpName", "盒马先生").prefixLength(2));
        request.source(builder);

        //3. 执行
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.3.5 wildcard查询

通配查询，和MySQL中的like是一个套路，可以在查询时，在字符串中指定通配符*和点位符?

#wildcard 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "wildcard": {
      "corpName": {
        "value": "中国*"      # 可以使用 * 和 ?指定通配符和点位符
      }
    }
  }
}

   @Test
    public void findByWildCard() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.wildcardQuery("corpName","中国*"));
        request.source(builder);

        //3. 执行
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.3.6 range查询

范围查询，只针对数值类型, 对某一个Field进行大于或者小于的范围指定

#range 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "range": {
      "fee": {
        "gte": 5,   
        "lte": 10
        # 可以使用  gt：>     gte: >=   lt: <   lte:  <=
      }
    }
  }
}

    @Test
    public void findByRange() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.rangeQuery("fee").gte(5).lte(10));
        request.source(builder);

        //3. 执行
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.3.7 regexp查询

正则查询，通过编写的正则表达式去匹配内容。

PS: prefix, fuzzy, wildcard和regexp查询效率相对比较低，要求效率比较高时，避免去使用

#regexp 查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "regexp": {
      "mobile": "180[0-9]{8}"
    }
  }
}

    @Test
    public void findByRegexp() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.regexpQuery("mobile", "139[0-9]{8}"));
        request.source(builder);

        //3. 执行
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.4 深分页 Scroll

ES对from + size是有限制的， from+size二者之和不能超过1W

原理：

from+size在ES查询数据的方式：

第一步先将用户指定的关键字进行分词，
第二步将词汇云分词库中进行检索，得到多个文档的id,
第三步去各个分片中去拉取指定的数据，耗时较长
第四步将数据根据score进行排序，耗时较长
第五步根据from的值，将查询到的数据舍弃一部分。
第六步返回结果。

Scroll在ES查询数据的方式

第一步先将用户指定的关键进行分词
第二步将词汇去分词库中进行检索，得到多个文档的id
第三步将文档的id存放在一个ES的上下文中.
第四步根据指定的size的个数去ES中检索指定个数的数据，拿完数据的文档id, 会从上下文中移除。
第五步如果需要下一页数据，直接去ES的上下文中，找后续内容。
第六步循环第四步和第五步

Scroll查询方式，不适合做实时的查询

#执行scroll查询，返回第一页数据， 并且将文档id信息存放在ES上下文中，指定生存时间1m
POST /sms-logs-index/sms-logs-type/_search?scroll=1m
{
  "query": {
    "match_all": {}
  },
  "size": 2,
  "sort": [        #排序   自定义，  可以多个字段
    {
      "fee": {
        "order": "desc"
      }
    }
  ]
}
#根据scroll查询第下一页数据
POST /_search/scroll
{
  "scroll_id" : "<根据第一步得到的scroll_id去指定>",
  "scroll": "<scroll信息的生存时间>"
}

#删除scroll在上下文中的数据
DELETE /_search/scroll/scroll_id

java实现scroll分布

public class Demo7 {
    ObjectMapper mapper=new ObjectMapper();
    RestHighLevelClient client = ESClient.getClient();
    String index = "sms-logs-index";
    String type = "sms-logs-type";

    @Test
    public void scrollQuery() throws IOException {
        //1. 创建searchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2. 指定scroll信息
        request.scroll(TimeValue.timeValueMinutes(1L));
        //3. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.size(4);
        builder.sort("fee", SortOrder.DESC);
        builder.query(QueryBuilders.matchAllQuery());
        request.source(builder);
        //4. 获取返回结果scrollId, source
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        String scrollId = response.getScrollId();
        System.out.println("----------------首页-----------------");
        for(SearchHit hit : response.getHits().getHits())
        {
            System.out.println(hit.getSourceAsMap());
        }
       while (true)
       {
           //5. 创建SearchScrollRequest
           SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
           //6. 指定scrollId的生存时间
           scrollRequest.scroll(TimeValue.timeValueMinutes(1l));
           //7. 执行查询获取返回结果
           SearchResponse scroll = client.scroll(scrollRequest, RequestOptions.DEFAULT);
           //8. 判断是否查询到了数据，输出
           SearchHit[] hits = scroll.getHits().getHits();
           if(hits != null && hits.length > 0)
           {
               System.out.println("___________下一页__________");
               for(SearchHit hit : hits)
               {
               System.out.println(hit.getSourceAsMap());
               }
           }else {
               //9. 判断没有查询到数据-退出循环
               System.out.println("__________结束_____________");
               break;
           }
       }

       //10. 创建ClearScrollRequest
        ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
       //11. 指定scrollId
        clearScrollRequest.addScrollId(scrollId);
        //12. 删除ScrollId
        ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);

        //13. 输出结果
        System.out.println("删除scroll: " + clearScrollResponse.isSucceeded());
    }
}

6.5 delete-by-query

根据term，match等查询方式去删除大量的文档

Ps:如查你需要的内容，是index下的大部分数据，推荐创建一个全新的index, 将保留的文档内容，添加到全新的索引。

#delete-by-query
POST /sms-logs-index/sms-logs-type/_delete_by_query
{
  "query": {
    "range": {
      "fee": {
        "lt": 4
      }
    }
  }
}

    @Test
    public void deleteByQuery() throws IOException {
        //1. 创建DeleteByQueryRequest
        DeleteByQueryRequest request = new DeleteByQueryRequest(index);
        request.types(type);
        //2. 指定检索的条件     和SearchRequest指定Query的方式不一样
        request.setQuery(QueryBuilders.rangeQuery("fee").lt(4));
        //3. 执行删除
        BulkByScrollResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
        //4. 输出返回结果
        System.out.println(response.toString());
    }

6.6 复合查询

6.6.1 bool查询

复合过滤器，将你的多个查询条件，以一定的逻辑组合在一起。

must：所有的条件，用must组合在一起，表示And的意思。

must_not：将must_not中的条件，全部都不能匹配，标识Not的意思。

should: 所有的条件，用should组合在一起，表示Or的意思。

# 查询省份为武汉或者北京
# 运营商不是联通
# smsCoutent中包含中国和平安
# bool查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
             "province": {
              "value": "北京"
             }
          }
        },
         {
          "term": {
             "province": {
              "value": "武汉"
             }
          }
        }
        ],
        "must_not": [
          {
            "term": {
              "operatorId": {
                "value": "2"
              }
            }
          }
        ],
        "must": [
          {
            "match": {
              "smsContent": "中国"
            }
          },
           {
            "match": {
              "smsContent": "平安"
            }
          }
        ]
    }
  }
}

  @Test
    public void BoolQuery() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2.指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //# 查询省份为武汉或者北京
        boolQueryBuilder.should(QueryBuilders.termQuery("province", "武汉"));
        boolQueryBuilder.should(QueryBuilders.termQuery("province", "北京"));
        //# 运营商不是联通
        boolQueryBuilder.mustNot(QueryBuilders.termQuery("operatorId", 2));
        //# smsContent中包含中国和平安
        boolQueryBuilder.must(QueryBuilders.matchQuery("smsContent", "中国"));
        boolQueryBuilder.must(QueryBuilders.matchQuery("smsContent", "平安"));

        builder.query(boolQueryBuilder);
        request.source(builder);
        //3. 执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits()){
            System.out.println(hit.getSourceAsMap());
        }
    }

6.6.2 boosting查询

boosting查询可以帮助我们去影响查询后的score。

positive: 只有匹配上positive的查询的内容，才会被放到返回的结果集中。

negative: 如果匹配上和positive并且也匹配上了negative, 就可以降低这样的文档score.

negative_boost: 指定系数，必须小于1.0

关于查询时，分数是如何计算的：

搜索的关键字在文档中出现的频次越高，分数就越高

指定的文档内容越短，分数就越高。

在搜索时，指定的关键字也会被分词，这个被分词的内容，被分词库匹配的个数越多，分数越高

#boosting查询， 收货安装
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "boosting": {
      "positive": {
        "match": {
          "smsContent": "收货安装"
        }
      },
        "negative": {
          "match": {
            "smsContent": "王五"
          }
        },
        "negative_boost": 0.5
      }
    }
}“

    @Test
    public void BoostingQuery() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2.指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoostingQueryBuilder boostingQueryBuilder = QueryBuilders.boostingQuery(
                QueryBuilders.matchQuery("smsContent", "收货安装"),
                QueryBuilders.matchQuery("smsContent", "王五")
        ).negativeBoost(0.5f);
        builder.query(boostingQueryBuilder);
        request.source(builder);
        
        //3. 执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4. 输出结果
        for(SearchHit hit : response.getHits().getHits()){
            System.out.println(hit.getSourceAsMap());
        }
    }

6.7 filter查询

query，根据查询条件，去计算文档的匹配度得到一个分数，并且根据分数进行排序，不会做缓存的。

filter, 根据查询条件去查询文档，不去计算分数，而且filter会对经常被过滤的数据进行缓存。

# filter查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
             "corpName": "盒马鲜生"
          }
        },
         {
          "range": {
             "fee": {
              "lte": 5
             }
          }
        }
      ]
    }
  }
}

    @Test
    public void filter() throws IOException {
        //1.SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2.查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(QueryBuilders.termQuery("corpName", "盒马鲜生"));
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("fee").lte(5));
        builder.query(boolQueryBuilder);
        request.source(builder);
        //3.执行查询
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //4.输出结果
        for (SearchHit hit : search.getHits().getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

6.8 高亮查询

高亮查询就是用户输入的关键字，以一定的生特殊样式展示给用户，让用户知道为什么这个结果被检索出来。

高亮展示的数据，本身就是文档中的一个Field，单独将Field以highlight的形式返回。

ES提供了一个highlight属性，和query同级别的。

fragment_size: 指定高亮数据展示多少个字符回来。

pre_tags:指定前缀标签，例 <font color="red">

post_tags: 指定后缀标签，例 </font>

fields: 指定哪几个Field以高亮形式返回

# filter查询
POST /sms-logs-index/sms-logs-type/_search
{
  "query": {
    "match": {
      "smsContent": "盒马"
    }
  },
  "highlight": {
    "fields": {
      "smsContent": {}
    },
    "pre_tags": "<font color='red'>",
    "post_tags": "</font>",
    "fragment_size": 10
  }
}

 @Test
    public void highlight() throws IOException {
        //1、SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2、指定查询条件(高亮)
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //2.1 指定查询条件
        builder.query(QueryBuilders.matchQuery("smsContent", "盒马"));
        //2.2 指定高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("smsContent", 10)
                .preTags("<font color='red'>")
                .postTags("</font>");
        builder.highlighter(highlightBuilder);

        request.source(builder);
        //3、执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、获取高亮数据，输出
        for (SearchHit hit : response.getHits().getHits()) {
            System.out.println(hit.getHighlightFields().get("smsContent"));
        }
    }

6.9 聚合查询

ES的聚合相称和MySQL的聚合查询类似，ES的聚合查询相比MySQL要强大的多， ES提供的统计数据的方式多种多样。

# ES聚合查询的RESTFull语法
POST /index/type/_search
{
    “aggs”: {
        "名字(agg)": {
            "agg_type": {
                "属性": "值"
            }
        }
    }
}

6.9.1 去重计数查询

去重计数，即cardinality, 第一步先将返回的文档中的一个指定的field进行去重，统计一共有多少条.

#去重计数，查询北京， 上海 武汉，山西
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "cardinality": {
        "field": "province"
      }
    }
  }
}

@Test
public void cardinality() throws IOException {
        //1.创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2.指定使用的聚合查询方式
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.cardinality("agg").field("province"));
        request.source(builder);
        //3.执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.获取返回结果
        Cardinality agg = response.getAggregations().get("agg");
        long value = agg.getValue();
        System.out.println(value);
}

6.9.2 范围统计

统计一定范围内出现的文档个数，比如，针对某一个Field的值在0-100, 100-200, 200-300之间文档出现的个数分别是多少。

范围统计可以针对普通的数值，针对时间类型，针对ip类型都可以做相应的统计。

range, date_range, ip_range

数值统计：

#对值方式范围统计
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "range": {
        "field": "fee",
        "ranges": [
          {
            "to": 5
          },
          {
            "from": 5,   #包含当前值
            "to": 10
          },
          {
            "from": 10
          }
        ]
      }
    }
 }
}

时间范围统计

#时间方式范围统计
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "date_range": {
        "field": "createDate",
        "format": "yyyy",
        "ranges": [
          {
            "to": 2000
          },
          {
            "from": "2000"
          }
        ]
      }
    }
  }
}

ip 范围统计

#ip 方式范围统计
POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "ip_range": {
        "field": "ipAddr",
        "ranges": [
          {
            "to": "10.126.2.9"
          },
          {
            "from": "10.126.2.9"
          }
        ]
      }
    }
  }
}

@Test 
public void range() throws IOException {
        //1.创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2.指定使用的聚合查询方式
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.range("agg").field("fee")
                                 .addUnboundedTo(5)
        .addRange(5, 10)
        .addUnboundedFrom(10));
        request.source(builder);
        //3.执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4.获取返回结果
        Range agg = response.getAggregations().get("agg");
        for (Range.Bucket bucket : agg.getBuckets()) {
            String key = bucket.getKeyAsString();
            Object from = bucket.getFrom();
            Object to = bucket.getTo();
            long docCount = bucket.getDocCount();
            System.out.println(String.format("Key: %s, from: %s, to: %s, docCount: %s", key, from, to, docCount));
        }
}

6.9.3 统计聚合查询

可以查询指定Field的最大值，最小值，平均值，平方和.... 使用: extends_stats

#统计聚合查询

POST /sms-logs-index/sms-logs-type/_search
{
  "aggs": {
    "agg": {
      "extended_stats": {
        "field": "fee"
      }
    }
  }
}

@Test
public void extended_stats() throws IOException {
        //1.创建SearchRequest
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //2.指定使用的聚合查询方式
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.extendedStats("agg").field("fee"));
        request.source(builder);
        //3.执行查询
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.获取返回结果
        ExtendedStats agg = response.getAggregations().get("agg");
       double max = agg.getMax();
       double min = agg.getMin();

        System.out.println("最大值为：" + max + ", 最小值： " + min);
}

其它的聚合查询方式查看官方文档：Elasticsearch Guide [6.5] | Elastic

6.10 地图经纬度搜索

ES中提供了一个数据类型geo_point, 这个类型就是用来存储经纬度。

创建一个带geo_point类型的索引，并添加测试数据

#创建一个索引，指定一个name， location
PUT /map
{
  "settings": {
    "number_of_shards": 5,
    "number_of_replicas": 1
  },
    "mappings": {
      "map": {
        "properties": {
          "name": {
            "type": "text"
          },
          "location": {
            "type": "geo_point"
          }
        }
      }
  }
}

#添加测试数据
PUT /map/map/10
{
  "name": "天安门",
  "location": {
    "lon": 116.404125,
    "lat": 39.915378
  }
}

#添加测试数据
PUT /map/map/12
{
  "name": "天坛",
  "location": {
    "lon": 116.416629,
    "lat": 39.885709
  }
}

#添加测试数据
PUT /map/map/13
{
  "name": "北京站",
  "location": {
    "lon": 116.433877,
    "lat": 39.910065
  }
}

6.10.1 ES的地图检索方式

geo_distance：查询距离检索方式

geo_bounding_box：以两个点确定一个矩形，获取在矩形内的全部数据

geo_polygon：以多个点，确定一个多边形，获取多边形内的全部数据

6.10.2 基于RESTful实现地图检索

geo_distance

#geo_distance
POST /map/map/_search
{
  "query": {
    "geo_distance": {
      "location": {              #确定一个点
        "lon": 116.433733,
        "lat": 39.908404
      },
      "distance": 4000,         #确定半径
      "distance_type": "arc"    #指定形状为圆形 
    }
  }
}

geo_bounding_box

#geo_bounding_box
POST /map/map/_search
{
  "query": {
    "geo_bounding_box": {
      "location": {
        "top_left": {                #左上角的坐标点
          "lon": 116.326943,
          "lat": 39.95499
        },
        "bottom_right": {            #右下角的坐标点
          "lon": 116.433446,
          "lat": 39.908737
        }
      }
    }
  }
}

geo_polygon

#geo_polygon
POST /map/map/_search
{
    "query": {
        "geo_polygon": {
            "location": {
                "points": {        #指定多个点确定一个多边形
                   {
                        "lon": 116.298916,
                        "lat": 39.99878
                   }，
                   {
                        "lon": 116.298916,
                        "lat": 39.99878
                   }，
                   {
                        "lon": 116.298916,
                        "lat": 39.99878
                   }
                }
            }
        }
    }
}

6.10.3 Java实现geo_polygon

@Test
public void extended_stats() throws IOException {
    //1.创建SearchRequest
    SearchRequest request = new SearchRequest(index);
    request.types(type);
    //2.指定使用的聚合查询方式
    SearchSourceBuilder builder = new SearchSourceBuilder();
    List<GeoPoint> points = new ArrayList<>();
    points.add(new GeoPoint(39.99878, 116.298916));
    points.add(new GeoPoint(39.972576, 116.29561));
    points.add(new GeoPoint(39.984739, 116.327661));
    builder.query(QueryBuilders.geoPolygonQuery("location", points));
    request.source(builder);
    //3.执行查询
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //4.获取返回结果
    for (SearchHit hit : response.getHits().getHits()) {
        System.out.println(hit.getSourceAsMap());
    }
}

freellf

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
ElasticSearch

1.在海量数据中执行搜索功能时，如果使用MySQL，效率太低。2.如果关键字输入的不准确，一样可以搜索到想要的数据。3.将搜索关键字，以红色的字体展示。ES是一个使用java语言并且基于Lucene编写的搜索引擎框架，提供了分布式的全文搜索功能，提供了一个统一的基于RESTful风格的WEB接口，官方客户端也对多种语言都提供了相应的API。Lucene: Lucene 本身就是一个一搜索引擎的底层。分布式：ES主要是为突出他的横向扩展能力。
复制链接

扫一扫