听忆.

Java整合ElasticSearch教程全网独一份（保姆级）

一、ES概述

1.1 ES的介绍

二、Java操作ElasticSearch【重点】

2.0 导入数据

2.1 Java连接ES

2.2 Java操作索引

2.2.1 创建索引

2.2.2 检查索引是否存在

2.2.3 删除索引

2.3 Java操作文档

2.3.1 添加文档操作

2.3.2 修改文档

2.3.3 删除文档

2.4 Java批量操作文档

2.4.1 批量添加

2.4.2 批量删除

三、 ElasticSearch的各种查询

3.1 term&terms查询【重点】

3.1.1 term查询

3.1.2 terms查询

3.2 match查询【重点】

3.2.1 match_all查询

3.2.2 match查询

3.2.3 布尔match查询

3.2.4 multi_match查询

3.3 其他查询

3.3.1 id查询

3.3.2 ids查询

3.3.3 prefix查询

3.3.4 fuzzy查询

3.3.5 wildcard查询

3.3.6 range查询

3.3.7 regexp查询

3.4 深分页Scroll

3.5 复合查询

3.5.1 bool查询

3.5.2. 相关度排序排查

3.5.2.1. 相关度算法:TF/IDF

3.5.2.2. 查询

3.6 filter查询

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

3.8 聚合查询【重点】

3.8.1 去重计数查询

3.8.2 范围统计

3.8.3 统计聚合查询

3.9 delete-by-query删除文档

3.10 地图经纬度搜索

3.10.1 ES的地图检索方式

3.10.2 基于RESTful实现地图检索

3.10.3 Java实现geo_polygon

一、ES概述

1.1 ES的介绍

ES是一个使用Java语言并且基于Lucene编写的搜索引擎框架，他提供了分布式的全文搜索功能，提供了一个统一的基于RESTful风格的WEB接口，官方客户端也对多种语言都提供了相应的API。

Lucene：Lucene本身就是一个搜索引擎的底层。

分布式：ES主要是为了突出他的横向扩展能力。

全文检索：将一段词语进行分词，并且将分出的单个词语统一的放到一个分词库中，在搜索时，根据关键字去分词库中检索，找到匹配的内容。（倒排索引）

RESTful风格的WEB接口：操作ES很简单，只需要发送一个HTTP请求，并且根据请求方式的不同，携带参数的同，执行相应的功能。

应用广泛：Github.com，WIKI，Gold Man用ES每天维护将近10TB的数据。

二、Java操作ElasticSearch【`重点`】

2.0 导入数据

方便代码查询操作 :

PUT /book/_doc/1
{
  "name": "红楼梦",
  "auth": "曹雪芹",
  "count": 4353453,
  "createtime": "1985-01-01",
  "desc": "一个是阆苑仙葩，一个是美玉无瑕"
}

PUT /book/_doc/2
{
  "name": "金瓶梅",
  "auth": "古人",
  "count": 1353453,
  "createtime": "1650-01-01",
  "desc": "讲述潘金莲, 李瓶, 春梅三人的爱情故事!"
}

PUT /book/_doc/3
{
  "name": "佛本是道",
  "auth": "天蚕土豆",
  "count": 153453,
  "createtime": "2016-01-01",
  "desc": "讲述佛教起源...."
}

PUT /book/_doc/4
{
  "name": "凡人修仙传",
  "auth": "我吃西红柿",
  "count": 14353453,
  "createtime": "2018-01-01",
  "desc": "讲述一个凡人, 一步一步努力修炼成仙的故事!"
}

PUT /book/_doc/5
{
  "name": "java编程思想",
  "auth": "高斯林",
  "count": 534530,
  "createtime": "1995-01-01",
  "desc": "学习java的圣经, 一书在手, 代码我有!"
}

PUT /book/_doc/6
{
  "name": "盘龙",
  "auth": "我吃西红柿",
  "count": 14353453,
  "createtime": "2021-01-01",
  "desc": "讲述龙如何盘它的故事!"
}

PUT /book/_doc/7
{
  "name": "诛仙",
  "auth": "萧鼎",
  "count": 353453,
  "createtime": "2005-01-01",
  "desc": "讲述如何弑神逆仙!"
}

PUT /book/_doc/8
{
  "name": "鬼吹灯之精绝古城",
  "auth": "天下霸唱",
  "count": 853453,
  "createtime": "2010-01-01",
  "desc": "惊觉古城在哪里呢!"
}

PUT /book/_doc/9
{
  "name": "鬼吹灯之龙岭迷窟",
  "auth": "天下霸唱",
  "count": 353453,
  "createtime": "2003-01-01",
  "desc": "讲述在黑龙江深山龙岭中的盗墓故事"
}

PUT /book/_doc/10
{
  "name": "鬼吹灯之云南虫谷",
  "auth": "天下霸唱",
  "count": 153453,
  "createtime": "2000-01-01",
  "desc": "讲述在云南虫谷的盗墓故事"
}

PUT /book/_doc/11
{
  "name": "鬼吹灯之混轮神宫",
  "auth": "天下霸唱",
  "count": 1153453,
  "createtime": "1998-01-01",
  "desc": "讲述在昆仑山下有古墓, 盗墓故事!"
}

PUT /book/_doc/12
{
  "name": "鬼吹灯之南海归墟",
  "auth": "天下霸唱",
  "count": 853453,
  "createtime": "2019-01-01",
  "desc": "南海下面有个坟, 坟中有个海王, 挖海王坟的故事!"
}

2.1 Java连接ES

创建Maven工程

导入依赖


    UTF-8
    1.8
    1.8


    
        org.elasticsearch
        elasticsearch
        7.6.2
    
    
        org.elasticsearch.client
        elasticsearch-rest-high-level-client
        7.6.2
    
    
        junit
        junit
        4.12
    
    
        com.fasterxml.jackson.core
        jackson-databind
        2.10.3
    
    
    
        com.alibaba
        fastjson
        1.2.47
    
    
        org.projectlombok
        lombok
        1.18.12
    
    
        org.apache.logging.log4j
        log4j-core
        2.14.1
    
    
        org.apache.logging.log4j
        log4j-api
        2.14.1

创建工具类，连接ES

package com.tingyi.utils;

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

/**
 * @author 听忆
 */
public class EsClient {

    /**
     * 获取和ES服务器的连接
     * @return
     */
    public static RestHighLevelClient getClient() {
        //1. 创建和服务器的连接
        HttpHost httpHost = new HttpHost("192.168.200.129", 9200);
        //2. 创建RestClient对象
        RestClientBuilder builder = RestClient.builder(httpHost);
        //3. 创建返回可以使用的连接对象
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(builder);
        return restHighLevelClient;
    }
}

针对索引结构创建实体类

package pojo;

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;

/**
 * @author 听忆
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    //json转换的时候忽略这个id
    @JsonIgnore
    private String id;
    
    //姓名
    private String name;
    
    //年龄
    private Integer age;

    //出生日期, 日期格式必须和ES中这个索引字段的日期格式保持一致
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

}

2.2 Java操作索引

2.2.1 创建索引

代码如下

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.json.JsonXContent;
import org.junit.Test;

/**
 * @author 听忆
 */
public class TestIndexManage {

    private RestHighLevelClient client = EsClient.getClient();
    
    //索引库名字
    private String index = "person";

    /**
     * 创建分片, 索引以及索引结构
     * @throws Exception
     */
    @Test
    public void testCreateIndex() throws Exception {
        //1. 创建主分片和备份分片
        Settings.Builder settings = Settings.builder()
                .put("number_of_shards", 5)
                .put("number_of_replicas", 1);

        //2. 创建索引结构
        XContentBuilder mapping = 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. 将分片和索引结构封装成一个Request对象
        CreateIndexRequest request = new CreateIndexRequest(index)
                .settings(settings)
                .mapping(mapping);

        //4. 发送请求执行创建并返回响应
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println("========" + response);
    }

}

2.2.2 检查索引是否存在

代码如下

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.json.JsonXContent;
import org.junit.Test;

import java.io.IOException;

/**
 * @author 听忆
 */
public class TestIndexManage {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "person";

    /**
     * 查看索引是否存在
     * @throws IOException
     */
    @Test
    public void testIndexExists() throws IOException {
        //1. 准备Get请求对象
        GetAliasesRequest request = new GetAliasesRequest();
        //将索引名字加入到请求对象中
        request.indices(index);

        //2. 通过client去操作
        boolean exists = client.indices().existsAlias(request, RequestOptions.DEFAULT);

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

}

2.2.3 删除索引

代码如下

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.json.JsonXContent;
import org.junit.Test;

/**
 * @author 听忆
 */
public class TestIndexManage {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "person";

    /**
     * 删除索引
     * @throws Exception
     */
    @Test
    public void testDeleteIndex() throws Exception{
        //1. 准备删除索引请求对象
        DeleteIndexRequest request = new DeleteIndexRequest();
        //将需要删除的索引名字加入到请求对象中
        request.indices(index);

        //2. 通过client对象执行
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);

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

}

2.3 Java操作文档

查询所有文档命令

GET book/_search
{
  "query": {
    "match_all": {}
  }
}

2.3.1 添加文档操作

代码如下

package com.tingyi.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tingyi.utils.EsClient;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import pojo.Person;

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

/**
 * @author 听忆
 */
public class TestSimple {

    //json转换工具对象
    private ObjectMapper mapper = new ObjectMapper();

    //es连接
    private RestHighLevelClient client = EsClient.getClient();

    //索引名字
    private String index = "person";

    /**
     * 添加文档, 存入数据
     * @throws IOException
     */
    @Test
    public void testCreateDoc() throws IOException {
        //1. 准备一个person数据
        Person person = new Person("1", "张三", 23, new Date());
        //2. 将person实体转换成json格式
        String json = mapper.writeValueAsString(person);

        //3. 准备一个request对象, 指定索引名字（手动指定id）
        IndexRequest request = new IndexRequest(index);

        //4. 手动指定id, 将json数据存入请求对象中, XContentType.JSON为存入数据类型
        request.id(person.getId()).source(json, XContentType.JSON);

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

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

2.3.2 修改文档

代码如下

package com.tingyi.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tingyi.utils.EsClient;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import pojo.Person;

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

/**
 * @author 听忆
 */
public class TestSimple {

    //json转换工具对象
    private ObjectMapper mapper = new ObjectMapper();

    //es连接
    private RestHighLevelClient client = EsClient.getClient();

    //索引名字
    private String index = "person";

    /**
     * 修改文档数据
     */
    @Test
    public void testUpdateDoc() throws Exception {
        //1. 准备一个person数据
        Person person = new Person("1", "青龙", 23, new Date());
        //2. 将person实体转换成json格式
        String json = mapper.writeValueAsString(person);

        //2. 创建修改请求对象, 第一个参数: 索引名字, 第二个参数:修改的文档id
        UpdateRequest request = new UpdateRequest(index, person.getId());
        //设置修改后的内容, 第二个参数: 文档数据类型
        request.doc(json, XContentType.JSON);

        //3. 通过client对象执行
        UpdateResponse update = client.update(request, RequestOptions.DEFAULT);

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

    }
}

2.3.3 删除文档

代码如下

package com.tingyi.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tingyi.utils.EsClient;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import pojo.Person;

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

/**
 * @author 听忆
 */
public class TestSimple {

    //json转换工具对象
    private ObjectMapper mapper = new ObjectMapper();

    //es连接
    private RestHighLevelClient client = EsClient.getClient();

    //索引名字
    private String index = "person";

    /**
     * 根据id删除文档
     * @throws IOException
     */
    @Test
    public void testDeleteDoc() throws Exception {
        //1. 封装用于删除的请求对象, 第一参数:索引名字, 第二参数:文档id
        DeleteRequest request = new DeleteRequest(index, "1");

        //2. client执行
        DeleteResponse resp = client.delete(request, RequestOptions.DEFAULT);

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

2.4 Java批量操作文档

2.4.1 批量添加

代码如下

package com.tingyi.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tingyi.utils.EsClient;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import pojo.Person;

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

/**
 * @author 听忆
 */
public class TestSimple {

    //json转换工具对象
    private ObjectMapper mapper = new ObjectMapper();

    //es连接
    private RestHighLevelClient client = EsClient.getClient();

    //索引名字
    private String index = "person";

    /**
     * 批量添加数据
     * @throws IOException
     */
    @Test
    public void testBulkCreateDoc() throws IOException {
        //1. 准备多个person实体数据
        Person p1 = new Person("1", "张三", 23, new Date());
        Person p2 = new Person("2", "李四", 24, new Date());
        Person p3 = new Person("3", "王五", 25, new Date());

        //2. 将实体数据转换成json格式
        String json1 = mapper.writeValueAsString(p1);
        String json2 = mapper.writeValueAsString(p2);
        String json3 = mapper.writeValueAsString(p3);

        //3. 创建批量执行请求对象，将准备好的数据封装进去
        BulkRequest request = new BulkRequest();
        request.add(new IndexRequest(index).id(p1.getId()).source(json1, XContentType.JSON));
        request.add(new IndexRequest(index).id(p2.getId()).source(json2, XContentType.JSON));
        request.add(new IndexRequest(index).id(p3.getId()).source(json3, XContentType.JSON));

        //4. 用client执行
        BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);

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

2.4.2 批量删除

代码如下

package com.tingyi.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tingyi.utils.EsClient;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import pojo.Person;

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

/**
 * @author 听忆
 */
public class TestSimple {

    //json转换工具对象
    private ObjectMapper mapper = new ObjectMapper();

    //es连接
    private RestHighLevelClient client = EsClient.getClient();

    //索引名字
    private String index = "person";

    /**
     * 批量删除文档数据
     * @throws IOException
     */
    @Test
    public void bulkDeleteDoc() throws IOException {
        //1. 封装Request对象
        BulkRequest request = new BulkRequest();
        request.add(new DeleteRequest(index,"1"));
        request.add(new DeleteRequest(index,"2"));
        request.add(new DeleteRequest(index,"3"));

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

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

三、 ElasticSearch的各种查询

在查询前添加实体类 : 然后为了演示查询, 自己往书这个索引中多添加些数据.

package pojo;

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;

/**
 * @author 听忆
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {

    @JsonIgnore
    private String id;

    //书名
    private String name;

    //作者
    private String auth;

    //总字数
    private Long count;
     
    //出版日期
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date createtime;

    //简介
    private String desc;
}

3.1 term&terms查询【`重点`】

3.1.1 term查询

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

# term查询
POST /book/_search
{
  "from": 0,    
  "size": 5,      
  "query": {
    "term": {
      "name": {
        "value": "java"
      }
    }
  }
}

代码实现方式

package com.tingyi.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tingyi.utils.EsClient;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;

/**
 * @author 听忆
 */
public class TestTermQuery {

    //json转换工具对象
    private ObjectMapper mapper = new ObjectMapper();

    //es连接
    private RestHighLevelClient client = EsClient.getClient();

    //索引名字
    private String index = "book";

    /**
     * 根据词元查询
     * @throws IOException
     */
    @Test
    public void testTermQuery() throws IOException {
        //1. 创建Request对象
        SearchRequest request = new SearchRequest(index);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //从第几条开始查询
        builder.from(0);
        //每页显示条数
        builder.size(5);
        builder.query(QueryBuilders.termQuery("name","金瓶梅"));
        
        //3. 将查询条件对象放入查询请求对象中
        request.source(builder);

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

        //5. 获取到_source中的数据，并展示
        for (SearchHit hit : resp.getHits().getHits()) {
            Map result = hit.getSourceAsMap();
            System.out.println(result);
        }
    }
}

3.1.2 terms查询

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

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

term：where province = 北京；

terms：where province = 北京 or province = ？or province = ？

# terms查询
POST /book/_search
{
  "from": 0,    
  "size": 5,      
  "query": {
    "terms": {
      "name": [
        "java", "金瓶梅"
      ]
    }
  }
}

代码实现方式

package com.tingyi.test;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tingyi.utils.EsClient;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;

/**
 * @author 听忆
 */
public class TestTermQuery {

    //json转换工具对象
    private ObjectMapper mapper = new ObjectMapper();

    //es连接
    private RestHighLevelClient client = EsClient.getClient();

    //索引名字
    private String index = "book";

    /**
     * 根据多个词元查询
     * @throws IOException
     */
    @Test
    public void termsQuery() throws IOException {
        //1. 创建request
        SearchRequest request = new SearchRequest(index);

        //2. 封装查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.termsQuery("name","java","金瓶梅"));

        //3. 将查询条件放入查询请求对象中
        request.source(builder);

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

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

3.2 match查询【`重点`】

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

查询的是日期或者是数值的话，他会将你基于的字符串查询内容转换为日期或者数值对待。

如果查询的内容是一个不能被分词的内容（keyword），match查询不会对你指定的查询关键字进行分词。

如果查询的内容是一个可以被分词的内容（text），match会将你指定的查询内容根据一定的方式去分词，去分词库中匹配指定的内容。

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

3.2.1 match_all查询

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

# match_all查询
GET book/_search
{
  "query": {
    "match_all": {}
  }
}

代码实现方式

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;

import java.io.IOException;

/**
 * @author 听忆
 */
public class TestMathQuery {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "book";

    /**
     * 查询所有
     * @throws IOException
     */
    @Test
    public void testMatchAllQuery() throws IOException {
        //1. 创建Request
        SearchRequest request = new SearchRequest(index);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //设置查询所有
        builder.query(QueryBuilders.matchAllQuery());
        //ES默认每页查询10条, 这里设置每页查询20条数据
        builder.size(20);
        //将查询对象放入请求对象中
        request.source(builder);

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

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

3.2.2 match查询

指定一个Field作为筛选的条件

# match查询
GET book/_search
{
  "query": {
    "match": {
      "name": "金瓶梅"
    }
  }
}

代码实现方式

/**
  * 根据指定字段内容查询
  * @throws IOException
  */
@Test
public void testMatchQuery() throws IOException {
    //1. 创建Request
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // 设置查询条件: 查询的字段和内容
    builder.query(QueryBuilders.matchQuery("name","金瓶梅"));
    //将查询条件放入请求对象
    request.source(builder);

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

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

3.2.3 布尔match查询

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

# 布尔match查询, 名字中包含金瓶梅 或者 描述中包含李瓶
POST book/_search
{
  "query": {
    "match": {
      "desc": "java 李瓶"
    }
  }
}

代码实现方式

/**
  * 多条件查询
  * @throws IOException
  */
@Test
public void testBooleanMatchQuery() throws IOException {
    //1. 创建Request
    SearchRequest request = new SearchRequest(index);

    //2. 创建查询条件对象
    SearchSourceBuilder builder = new SearchSourceBuilder();

    //将多条件查询对象放入查询对象中
    builder.query(QueryBuilders.matchQuery("desc","java 李瓶").operator(Operator.OR));
    //将查询对象放入请求对象中
    request.source(builder);

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

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

3.2.4 multi_match查询

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

# multi_match 查询
POST book/_search
{
  "query": {
    "multi_match": {
      "query": "李瓶",
      "fields": ["name", "desc"]
    }
  }
}

代码实现方式

/**
  * 多字段查询
  * @throws IOException
  */
@Test
public void testMultiMatchQuery() throws IOException {
    //1. 创建Request
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //设置条件: 从名字字段和描述字段中查询含有java关键字的
    builder.query(QueryBuilders.multiMatchQuery("java","name","desc"));
    //将条件放入请求对象中
    request.source(builder);

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

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

3.3 其他查询

3.3.1 id查询

根据id查询 where id = ?

# id查询
GET book/_doc/1

代码实现方式

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.Test;

import java.io.IOException;

/**
 * @author 听忆
 */
public class TestOtherQuery {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "book";

    /**
     * 根据id查询
     * @throws IOException
     */
    @Test
    public void testFindById() throws IOException {
        //1. 创建GetRequest
        GetRequest request = new GetRequest(index,"1");

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

        //3. 输出结果
        System.out.println(resp.getSourceAsMap());
    }
}

3.3.2 ids查询

根据多个id查询，类似MySQL中的where id in（id1，id2，id2...）

# ids查询
POST book/_search
{
  "query": {
    "ids": {
      "values": ["1", "2"]
    }
  }
}

代码实现方式

/**
  * 根据多个id查询
  * 相当于sql语句中的 where 字段名 in(值1, 值2, 值3)
  * @throws IOException
  */
@Test
public void testFindByIds() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //设置查询条件 : 根据多个id查询
    builder.query(QueryBuilders.idsQuery().addIds("1","2","3"));
    //将查询条件放入请求对象中
    request.source(builder);

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

3.3.3 prefix查询

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

#prefix 查询
POST book/_search
{
  "query": {
    "prefix": {
      "name": {
        "value": "金"
      }
    }
  }
}

代码实现方式

/**
  * 前缀查询
  * @throws IOException
  */
@Test
public void testFindByPrefix() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //----------------------------------------------------------
    builder.query(QueryBuilders.prefixQuery("desc","java"));
    //----------------------------------------------------------
    request.source(builder);

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

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

3.3.4 fuzzy查询

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

# fuzzy查询, 
POST book/_search
{
  "query": {
    "fuzzy": {
      "desc": {
        "value": "jaa",
        "prefix_length": 2     # 指定前面几个字符是不允许出现错误的
      }
    }
  }
}

代码实现方式

/**
  * 模糊查询
  * @throws IOException
  */
@Test
public void testFindByFuzzy() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //----------------------------------------------------------
    builder.query(QueryBuilders.fuzzyQuery("name","jaa").prefixLength(2));
    //----------------------------------------------------------
    request.source(builder);

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

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

3.3.5 wildcard查询

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

# wildcard 查询
POST book/_search
{
  "query": {
    "wildcard": {
      "desc": {
        "value": "李*"      # 可以使用*和？指定通配符和占位符
      }
    }
  }
}

代码实现方式

/**
  * 通配符匹配查询
  * 相当于sql语句中的like 后面加通配符*或者?
  * @throws IOException
  */
@Test
public void testFindByWildCard() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

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

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

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

3.3.6 range查询

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

# range 查询, 可以使用 gt：>      gte：>=     lt：<     lte：<=
POST book/_search
{
  "query": {
    "range": {
      "count": {
        "gte": 1000000,
        "lte": 2000000
      }
    }
  }
}

代码实现方式

/**
  * 数值范围查询
  * @throws IOException
  */
@Test
public void testFindByRange() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //----------------------------------------------------------
    builder.query(QueryBuilders.rangeQuery("count").lte(2000000).gte(1000000));
    //----------------------------------------------------------
    request.source(builder);

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

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

3.3.7 regexp查询

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

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

# regexp 查询, 编写正则
 POST book/_search
 {
   "query": {
     "regexp": {
       "desc": "[a-z]{4}"
     }
   }
 }

代码实现方式

/**
  * 正则表达式匹配查询
  * @throws IOException
  */
@Test
public void testFindByRegexp() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //----------------------------------------------------------
    builder.query(QueryBuilders.regexpQuery("name","[a-z]{4}"));
    //---------------------------------------------------------- 
  
  
  
  
  
    request.source(builder);

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

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

3.4 深分页Scroll

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

原理：

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

第一步现将用户指定的关键进行分词。

第二步将词汇去分词库中进行检索，得到多个文档的id。

第三步去各个分片中去拉取指定的数据。耗时较长。

第四步将数据根据score进行排序。耗时较长。

第五步根据from的值，将查询到的数据舍弃一部分。

第六步返回结果。

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

第一步现将用户指定的关键进行分词。

第二步将词汇去分词库中进行检索，得到多个文档的id。

第三步将文档的id存放在一个ES的上下文中。

第四步根据你指定的size的个数去ES中检索指定个数的数据，拿完数据的文档id，会从上下文中移除。

第五步如果需要下一页数据，直接去ES的上下文中，找后续内容。

第六步循环第四步和第五步

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

# 执行scroll查询，返回第一页数据，并且将文档id信息存放在ES上下文中，指定生存时间1m
POST book/_search?scroll=1m
{
  "query": {
    "match_all": {}
  },
  "size": 2, 
  "sort": [
    {
      "count": {
        "order": "desc"
      }
    }
  ]
}

# 根据scroll查询下一页数据
POST /_search/scroll
{
  "scroll_id": "<根据第一步得到的scorll_id去指定>",
  "scroll": ""
}
#例如: 分页滚动显示查询结果
POST _search/scroll
{
  "scroll":"1m",
  "scroll_id":"DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAC0bFnp0ZDV0V1J3UWN1NHI1dnhHSjladkEAAAAAAAAtHhZ6dGQ1dFdSd1FjdTRyNXZ4R0o5WnZBAAAAAAAALR0WenRkNXRXUndRY3U0cjV2eEdKOVp2QQAAAAAAAC0aFnp0ZDV0V1J3UWN1NHI1dnhHSjladkEAAAAAAAAtHBZ6dGQ1dFdSd1FjdTRyNXZ4R0o5WnZB"
}

# 删除scroll在ES上下文中的数据
DELETE _search/scroll/<根据第一步得到的scorll_id去指定>

代码实现方式

/**
  * 查询所有, 深分页
  * @throws IOException
  */
@Test
public void testScrollQuery() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定scroll信息, scrollId的生存时间一分钟
    request.scroll(TimeValue.timeValueMinutes(1L));

    //3. 指定查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //每页显示2条数据
    builder.size(2);
    //按照count字段排序
    builder.sort("count", SortOrder.DESC);
    //查询条件: 查询所有内容
    builder.query(QueryBuilders.matchAllQuery());

    request.source(builder);

    //4. 获取返回结果scrollId，source
    SearchResponse resp = client.search(request, RequestOptions.DEFAULT);

    String scrollId = resp.getScrollId();
    System.out.println("----------首页---------");
    for (SearchHit hit : resp.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 scrollResp = client.scroll(scrollRequest, RequestOptions.DEFAULT);

        //8. 判断是否查询到了数据，输出
        SearchHit[] hits = scrollResp.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());

}

3.5 复合查询

3.5.1 bool查询

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

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

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

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

# 布尔match查询, 名字中包含金瓶梅 并且 描述中包含李瓶
POST book/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "金瓶梅"
          }
        },{
          "match": {
            "desc": "李瓶"
          }
        }
      ]
    }
  }
}

# 布尔match查询 名字中包含java   或者   描述中包含李瓶
POST book/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "name": "java"
          }
        },{
          "match": {
            "desc": "李瓶"
          }
        }
      ]
    }
  }
}

代码实现方式

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;

import java.io.IOException;

/**
 * @author 听忆
 */
public class TestBooleanQuery {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "book";

    /**
     * 多条件查询
     * @throws IOException
     */
    @Test
    public void testBooleanMatchQuery() throws IOException {
        //1. 创建Request
        SearchRequest request = new SearchRequest(index);

        //2. 创建查询条件对象
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //3. 创建多条件查询对象
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        //设置查询条件, 根据名字字段查询
        boolQuery.should().add(QueryBuilders.matchQuery("name","java"));
        //设置查询条件, 根据描述字段查询
        boolQuery.should().add(QueryBuilders.matchQuery("desc","李瓶"));
        //将多条件查询对象放入查询对象中
        builder.query(boolQuery);
        //将查询对象放入请求对象中
        request.source(builder);

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

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

3.5.2. 相关度排序排查

3.5.2.1. 相关度算法:TF/IDF

在对搜索条件进行分词后，Elasticsearch会根据TF/IDF算法，依托于index内所有document中，计算每一个(不可拆分的)词条的相关度分数。

TF/IDF算法可以被拆分成TF算法，IDF算法以及length norm算法:

TF： term frequency，词频算法。对搜索条件进行分词后，各词条在整个index的所有document中出现的次数越多，则权重越高。
IDF： inverse document frequency，逆文本频率指数算法。对搜索条件进行分词后，统计各词条在所有(已过滤的)document中出现的次数，出现的次数越多，词条的特性越弱，该词条在后续用于评定相关度分数时，起到的作用也越低。
length norm: 长度规范。对已匹配目标词条的document而言，document的长度越长，则相关度分数越大。

3.5.2.2. 查询

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

positive(相当于TF)：当查询命中positive指定的关键字会提高相关度分数

negative(相当于IDF)：当查询命中negative指定的关键字, 那么原有相关度分数则乘以negative_boost系数, 降低相关度分数.

negative_boost()：指定系数，必须小于1.0 , 当查询命中negative的时候, 乘以这个系数, 可以降低相关度分数.

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

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

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

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

# 使用默认相关度排序查询
POST book/_search
{
  "query": {
    "match": {
      "desc": "讲述"
    }
  }
}

# boosting查询, 通过desc字段的内容李瓶降低相关度分数
POST book/_search
{
  "query": {
    "boosting": {
      "positive": {
        "match": {
          "desc": "讲述"
        }
      }, 
      "negative": {
        "match": {
          "desc": "李瓶"
        }
      },
      "negative_boost": 0.2
    }
  }
}

代码实现方式

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.BoostingQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;

import java.io.IOException;

/**
 * @author 听忆
 */
public class TestBooleanQuery {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "book";

    /**
     * 相关度排序查询
     * @throws IOException
     */
    @Test
    public void testBoostingQuery() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);

        //2. 指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoostingQueryBuilder boostingQuery = QueryBuilders.boostingQuery(
                //设置positiveQuery, 正向词频算法影响的查询内容
                QueryBuilders.matchQuery("desc", "讲述"),
                //设置negativeQuery, 逆向词频算法影响的查询内容
                QueryBuilders.matchQuery("desc", "李瓶")
                //设置逆向词频算法命中后, 乘以的系数, 以降低相关度分数
        ).negativeBoost(0.2f);

        builder.query(boostingQuery);
        request.source(builder);

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

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

3.6 filter查询

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

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

# filter查询, 在bool组合查询中, must是并且的意思, 查询desc字段中含有李瓶的数据集合, 
# filter是在查询出来的结果集合中进行按条件过滤
POST book/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "desc": "李瓶"
          }
        }
      ], 
      "filter": [
        {
          "range": {
            "count": {
              "gte": 1,
              "lte": 4000000
            }
          }
        },{
          "term": {
            "auth": "古人"
          }
        }
      
      ]
    }
  }
}

代码实现方式

/**
  * 过滤查询
  * @throws IOException
  */
@Test
public void testFilter() throws IOException {
    //1. SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 查询条件
    SearchSourceBuilder builder = new SearchSourceBuilder();
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    //设置查询条件
    boolQuery.must().add(QueryBuilders.matchQuery("desc", "李瓶"));
    //设置过滤条件
    boolQuery.filter(QueryBuilders.termQuery("auth","古人"));
    //设置过滤条件
    boolQuery.filter(QueryBuilders.rangeQuery("count").lte(4000000).gte(1));

    builder.query(boolQuery);
    request.source(builder);

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

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

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

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

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

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

pre_tags：指定前缀标签，举个栗子< font color="red" >

post_tags：指定后缀标签，举个栗子< /font >

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

RESTful实现

# highlight查询
POST book/_search
{
  "query": {
    "match": {
      "desc": "java 讲述"
    }
  },
  "highlight": {
    "fields": {
      "desc": {}
    },
    "pre_tags": "",
    "post_tags": "",
    "number_of_fragments": 10
  }
}

代码实现方式

/**
  * 高亮查询
  * @throws IOException
  */
@Test
public void testHighLightQuery() throws IOException {
    //1. SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定查询条件（高亮）
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //2.1 指定查询条件
    builder.query(QueryBuilders.matchQuery("desc","java 讲述"));
    //2.2 指定高亮
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.field("desc",10)
        .preTags("")
        .postTags("");
    builder.highlighter(highlightBuilder);

    request.source(builder);

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

    //4. 获取高亮数据，输出
    for (SearchHit hit : resp.getHits().getHits()) {
        System.out.println(hit.getHighlightFields().get("desc"));
    }
}

3.8 聚合查询【`重点`】

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

注意 : text(可以分词)类型的域名不支持聚合统计. keyword(不可以分词)类型的域名可以.

# ES聚合查询的RESTful语法
POST /index/_search
{
    "aggs": {
        "名字（agg）": {
            "agg_type": {
                "属性": "值1
            }
        }
    }
}

3.8.1 去重计数查询

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

# 去重计数查询
POST book/_search
{
  "aggs": {
    "agg_name": {
      "cardinality": {
        "field": "count"
      }
    }
  }
}

代码实现方式

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.metrics.Cardinality;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;

import java.io.IOException;

/**
 * 聚合统计查询
 * @author 听忆
 */
public class TestAggQuery {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "book";

    /**
     * 去重统计查询, 按照count字段去重, 统计共有多少条数据
     * @throws IOException
     */
    @Test
    public void TestCardinality() throws IOException {
        //1. 创建SearchRequest
        SearchRequest request = new SearchRequest(index);

        //2. 指定使用的聚合查询方式
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.aggregation(AggregationBuilders.cardinality("agg_name").field("count"));

        request.source(builder);

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

        //4. 获取返回结果
        Cardinality agg_name = resp.getAggregations().get("agg_name");
        long value = agg_name.getValue();
        System.out.println(value);  
    }
}

3.8.2 范围统计

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

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

range，date_range，ip_range

数值统计

# 数值方式范围统计
POST book/_search
{
  "aggs": {
    "agg": {
      "range": {
        "field": "count",
        "ranges": [
          {
            "from": 50,
            "to": 100000
          },
          {
            "from": 100001,
            "to": 2000000
          }
        ]
      }
    }
  }
}

时间范围统计

# 时间方式范围统计
POST book/_search
{
  "aggs": {
    "agg": {
      "date_range": {
        "field": "createtime",
        "format": "yyyy", 
        "ranges": [
          {
            "from": "1900",
            "to": "2000"
          },
          {
            "from": "2001",
            "to": "2021"
          }
        ]
      }
    }
  }
}

ip统计方式

# ip方式 范围统计
POST book/_search
{
  "aggs": {
    "agg": {
      "ip_range": {
        "field": "ipAddr",
        "ranges": [
          {
            "from": "10.0.0.5",
            "to": "10.0.0.10"
          }
        ]
      }
    }
  }
}

代码实现方式

/**
  * 数值 范围统计
  * @throws IOException
  */
@Test
public void testRange() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定使用的聚合查询方式
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //---------------------------------------------
    builder.aggregation(AggregationBuilders.range("agg").field("count")
                        .addUnboundedTo(100000)
                        .addRange(100000,2000000)
                        .addUnboundedFrom(2000000));
    //---------------------------------------------
    request.source(builder);

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

    //4. 获取返回结果
    Range agg = resp.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));
    }
}

3.8.3 统计聚合查询

他可以帮你查询指定Field的最大值，最小值，平均值，平方和等

使用：extended_stats

# 统计聚合查询
POST book/_search
{
  "aggs": {
    "agg": {
      "extended_stats": {
        "field": "count"
      }
    }
  }
}

代码实现方式

/**
  * 聚合查询
  * 统计: 最小值, 最大值
  * @throws IOException
  */
@Test
public void testExtendedStats() throws IOException {
    //1. 创建SearchRequest
    SearchRequest request = new SearchRequest(index);

    //2. 指定使用的聚合查询方式
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //---------------------------------------------
    builder.aggregation(AggregationBuilders.extendedStats("agg").field("count"));
    //---------------------------------------------
    request.source(builder);

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

    //4. 获取返回结果
    ExtendedStats agg = resp.getAggregations().get("agg");
    double max = agg.getMax();
    double min = agg.getMin();
    System.out.println("fee的最大值为：" + max + "，最小值为：" + min);
}

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

3.9 delete-by-query删除文档

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

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

# delete-by-query
POST book/_delete_by_query
{
  "query":{
    "match_all":{}
  }
}

代码实现方式

/**
  * 根据查询条件批量删除文档
  * @throws IOException
  */
@Test
public void testDeleteByQuery() throws IOException {
    //1. 创建DeleteByQueryRequest
    DeleteByQueryRequest request = new DeleteByQueryRequest(index);

    //2. 指定检索的条件和SearchRequest指定Query的方式不一样
    request.setQuery(QueryBuilders.matchAllQuery());

    //3. 执行删除
    BulkByScrollResponse resp = client.deleteByQuery(request, RequestOptions.DEFAULT);

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

}

3.10 地图经纬度搜索

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

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

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


# 添加测试数据
PUT /map/_doc/1
{
  "name": "天安门",
  "location": {
    "lon": 116.403981,
    "lat": 39.914492 
  }
}


PUT /map/_doc/2
{
  "name": "海淀公园",
  "location": {
    "lon": 116.302509,
    "lat": 39.991152 
  }
}

PUT /map/_doc/3
{
  "name": "北京动物园",
  "location": {
    "lon": 116.343184,
    "lat": 39.947468 
  }
}

PUT /map/_doc/4
{
  "name": "北科",
  "location": {
    "lat": 40.12255,
    "lon": 116.25776
  }
}
  
PUT /map/_doc/5
{
  "name": "生命科学院",
  "location": "40.10106,116.300654"
}

PUT /map/_doc/6
{
  "text": "巩华城",
  "location": [116.300407,40.137286] 
}

# 查询所有map数据, 测试添加结果
POST map/_search
{
  "query": {
    "match_all": {}
  }
}

3.10.1 ES的地图检索方式

语法	说明
geo_distance	直线距离检索方式
geo_bounding_box	以两个点确定一个矩形，获取在矩形内的全部数据
geo_polygon	以多个点，确定一个多边形，获取多边形内的全部数据
lat	纬度
lon	经度

3.10.2 基于RESTful实现地图检索

geo_distance : 指定一个点和一个距离(半径), 确定一个圆

# geo_distance, 指定半径5公里, 以当前坐标为圆点查询.
POST map/_search
{
  "query": {
    "geo_distance": {
      "location": {
        "lat": 40.12255,
        "lon": 116.25776
      },
      "distance": "5km"
    }
  }
}

geo_bounding_box : 指定两个点，确定一个矩形查询

# geo_bounding_box, 指定左上角坐标点 和 右下角坐标点
POST map/_search
{
  "query": {
    "geo_bounding_box": {
      "location": {
        "top_left": {
          "lat": 40.136596,
          "lon": 116.227716
        },
        "bottom_right": {
          "lat": 40.100236,
          "lon": 116.308491
        }
      }  
    }
  }
}

geo_polygon : 指定多个点，确定以后个多边形查询

# geo_polygon
POST map/_search
{
  "query": {
    "geo_polygon": {
      "location": {
        "points": [
          {"lon": 116.255559, "lat": 40.120736},
          {"lon": 116.263069, "lat": 40.120901},
          {"lon": 116.258748, "lat": 40.127089},
          {"lon": 116.251471, "lat": 40.126999}
        ]
      }
    }
  }
}

3.10.3 Java实现geo_polygon

package com.tingyi.test;

import com.tingyi.utils.EsClient;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * 地图经纬度查询
 * @author 听忆
 */
public class TestMapQuery {

    private RestHighLevelClient client = EsClient.getClient();
    //索引库名字
    private String index = "map";

    /**
     * 多边形经纬度查询
     * @throws IOException
     */
    @Test
    public void TestGeoPolygon() throws IOException {
        //1. SearchRequest
        SearchRequest request = new SearchRequest(index);

        //2. 指定检索方式
        SearchSourceBuilder builder = new SearchSourceBuilder();
        List points = new ArrayList<>();
        //第一个参数lat: 纬度, 第二个参数lon: 经度
        points.add(new GeoPoint(40.120736, 116.255559));
        points.add(new GeoPoint(40.120901, 116.263069));
        points.add(new GeoPoint(40.127089, 116.258748));
        points.add(new GeoPoint(40.126999, 116.251471));
        builder.query(QueryBuilders.geoPolygonQuery("location",points));

        request.source(builder);

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

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

你可能感兴趣的:(elasticsearch,java,intellij-idea,java-ee)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
ES聚合分析原理与代码实例讲解光剑书架上的书大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM Java Python 架构设计 Agent 程序员实现财富自由
ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
SQL的各种连接查询 xieke90 UNION ALL UNION 外连接内连接 JOIN
一、内连接概念：内连接就是使用比较运算符根据每个表共有的列的值匹配两个表中的行。内连接（join 或者inner join ） SQL语法： select * fron
java编程思想--复用类百合不是茶 java 继承代理组合 final类
复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书一:组合语法:就是将对象的引用放到新类中即可代码: package com.wj.reuse; /** * * @author Administrator 组
[开源与生态系统]国产CPU的生态系统 comsci cpu
计算机要从娃娃抓起...而孩子最喜欢玩游戏.... 要让国产CPU在国内市场形成自己的生态系统和产业链,国家和企业就不能够忘记游戏这个非常关键的环节.... 投入一些资金和资源,人力和政策,让游
JVM内存区域划分Eden Space、Survivor Space、Tenured Gen，Perm Gen解释商人shang jvm内存
jvm区域总体分两类，heap区和非heap区。heap区又分：Eden Space（伊甸园）、Survivor Space(幸存者区)、Tenured Gen（老年代-养老区）。非heap区又分：Code Cache(代码缓存区)、Perm Gen（永久代）、Jvm Stack(java虚拟机栈)、Local Method Statck(本地方法栈)。 HotSpot虚拟机GC算法采用分代收
页面上调用 QQ oloz qq
<A href="tencent://message/?uin=707321921&Site=有事Q我&Menu=yes"> <img style="border:0px;" src=http://wpa.qq.com/pa?p=1:707321921:1></a>
一些问题文强chu 问题
1.eclipse 导出 doc 出现“The Javadoc command does not exist.” javadoc command 选择 jdk/bin/javadoc.exe 2.tomcate 配置 web 项目 ..... SQL:3.mysql * 必须得放前面否则 select&nbs
生活没有安全感小桔子生活孤独安全感
圈子好小，身边朋友没几个，交心的更是少之又少。在深圳，除了男朋友，没几个亲密的人。不知不觉男朋友成了唯一的依靠，毫不夸张的说，业余生活的全部。现在感情好，也很幸福的。但是说不准难免人心会变嘛，不发生什么大家都乐融融，发生什么很难处理。我想说如果不幸被分手(无论原因如何)，生活难免变化很大，在深圳，我没交心的朋友。明
php 基础语法 aichenglong php 基本语法
1 .1 php变量必须以$开头 <?php $a=” b”; echo ?> 1 .2 php基本数据库类型 Integer float/double Boolean string 1 .3 复合数据类型数组array和对象 object 1 .4 特殊数据类型 null 资源类型(resource) $co
mybatis tools 配置详解 AILIKES mybatis
MyBatis Generator中文文档 MyBatis Generator中文文档地址： http://generator.sturgeon.mopaas.com/ 该中文文档由于尽可能和原文内容一致，所以有些地方如果不熟悉，看中文版的文档的也会有一定的障碍，所以本章根据该中文文档以及实际应用，使用通俗的语言来讲解详细的配置。本文使用Markdown进行编辑，但是博客显示效
继承与多态的探讨百合不是茶 JAVA面向对象继承对象
继承 extends 多态继承是面向对象最经常使用的特征之一：继承语法是通过继承发、基类的域和方法 //继承就是从现有的类中生成一个新的类，这个新类拥有现有类的所有extends是使用继承的关键字：在A类中定义属性和方法； class A{ //定义属性 int age； //定义方法 public void go
JS的undefined与null的实例 bijian1013 JavaScript JavaScript
<form name="theform" id="theform"> </form> <script language="javascript"> var a alert(typeof(b)); //这里提示undefined if(theform.datas
TDD实践（一） bijian1013 java 敏捷 TDD
一.TDD概述 TDD：测试驱动开发，它的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。
[Maven学习笔记十]Maven Profile与资源文件过滤器 bit1129 maven
什么是Maven Profile Maven Profile的含义是针对编译打包环境和编译打包目的配置定制，可以在不同的环境上选择相应的配置，例如DB信息，可以根据是为开发环境编译打包，还是为生产环境编译打包，动态的选择正确的DB配置信息 Profile的激活机制 1.Profile可以手工激活，比如在Intellij Idea的Maven Project视图中可以选择一个P
【Hive八】Hive用户自定义生成表函数(UDTF) bit1129 hive
1. 什么是UDTF UDTF，是User Defined Table-Generating Functions，一眼看上去，貌似是用户自定义生成表函数，这个生成表不应该理解为生成了一个HQL Table，貌似更应该理解为生成了类似关系表的二维行数据集 2. 如何实现UDTF 继承org.apache.hadoop.hive.ql.udf.generic
tfs restful api 加auth 2.0认计 ronin47
　　目前思考如何给tfs的ngx-tfs api增加安全性。有如下两点：　　一是基于客户端的ip设置。这个比较容易实现。　　二是基于OAuth2.0认证，这个需要lua，实现起来相对于一来说，有些难度。　　现在重点介绍第二种方法实现思路。　　前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGe
jdk环境变量配置 byalias java jdk
进行java开发，首先要安装jdk，安装了jdk后还要进行环境变量配置： 1、下载jdk（http://java.sun.com/javase/downloads/index.jsp），我下载的版本是：jdk-7u79-windows-x64.exe 2、安装jdk-7u79-windows-x64.exe 3、配置环境变量：右击"计算机"-->&quo
《代码大全》表驱动法-Table Driven Approach-2 bylijinnan java
package com.ljn.base; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.uti
SQL 数值四舍五入小数点后保留2位 chicony 四舍五入
1.round() 函数是四舍五入用，第一个参数是我们要被操作的数据，第二个参数是设置我们四舍五入之后小数点后显示几位。 2.numeric 函数的2个参数，第一个表示数据长度，第二个参数表示小数点后位数。例如：　　select cast(round(12.5,2) as numeric(5,2))
c++运算符重载 CrazyMizzz C++
一、加+，减-，乘*，除/ 的运算符重载 Rational operator*(const Rational &x) const{ return Rational(x.a * this->a); } 在这里只写乘法的，加减除的写法类似二、<<输出,>>输入的运算符重载 &nb
hive DDL语法汇总 daizj hive 修改列 DDL 修改表
hive DDL语法汇总１、对表重命名 hive> ALTER TABLE table_name RENAME TO new_table_name; 2、修改表备注 hive> ALTER TABLE table_name SET TBLPROPERTIES ('comment' = new_comm
jbox使用说明 dcj3sjt126com Web
参考网址：http://www.kudystudio.com/jbox/jbox-demo.html jBox v2.3 beta [ 点击下载] 技术交流QQGroup：172543951 100521167 [2011-11-11] jBox v2.3 正式版 - [调整&修复] IE6下有iframe或页面有active、applet控件
UISegmentedControl 开发笔记 dcj3sjt126com
// typedef NS_ENUM(NSInteger, UISegmentedControlStyle) { // UISegmentedControlStylePlain, // large plain &
Slick生成表映射文件 ekian scala
Scala添加SLICK进行数据库操作，需在sbt文件上添加slick-codegen包 "com.typesafe.slick" %% "slick-codegen" % slickVersion 因为我是连接SQL Server数据库，还需添加slick-extensions，jtds包 "com.typesa
ES-TEST gengzg test
package com.MarkNum; import java.io.IOException; import java.util.Date; import java.util.HashMap; import java.util.Map; import javax.servlet.ServletException; import javax.servlet.annotation
为何外键不再推荐使用 hugh.wang mysql DB
表的关联，是一种逻辑关系，并不需要进行物理上的“硬关联”，而且你所期望的关联，其实只是其数据上存在一定的联系而已，而这种联系实际上是在设计之初就定义好的固有逻辑。在业务代码中实现的时候，只要按照设计之初的这种固有关联逻辑来处理数据即可，并不需要在数据库层面进行“硬关联”，因为在数据库层面通过使用外键的方式进行“硬关联”，会带来很多额外的资源消耗来进行一致性和完整性校验，即使很多时候我们并不
领域驱动设计 julyflame VO DAO 设计模式 DTO po
概念： VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对
单例设计模式 hm4123660 java Singleton 单例设计模式懒汉式饿汉式
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。 &nb
logback zhb8015 log logback
一、logback的介绍 Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个改良版本。此外logback-class
整合Kafka到Spark Streaming——代码示例和挑战 Stark_Summer spark storm zookeeper PARALLELISM processing
作者Michael G. Noll是瑞士的一位工程师和研究员，效力于Verisign，是Verisign实验室的大规模数据分析基础设施（基础Hadoop）的技术主管。本文，Michael详细的演示了如何将Kafka整合到Spark Streaming中。期间， Michael还提到了将Kafka整合到 Spark Streaming中的一些现状，非常值得阅读，虽然有一些信息在Spark 1.2版
spring-master-slave-commondao 王新春 DAO spring dataSource slave master
互联网的web项目，都有个特点：请求的并发量高，其中请求最耗时的db操作，又是系统优化的重中之重。为此，往往搭建 db的一主多从库的数据库架构。作为web的DAO层，要保证针对主库进行写操作，对多个从库进行读操作。当然在一些请求中，为了避免主从复制的延迟导致的数据不一致性，部分的读操作也要到主库上。（这种需求一般通过业务垂直分开，比如下单业务的代码所部署的机器，读去应该也要从主库读取数