自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

SpringBoot 整合 ElasticSearch 輕松搞定海量級數(shù)據(jù)搜索服務 (終極版)

作者：志哥聊技術
開發(fā) 前端
本文主要圍繞 SpringBoot 整合 ElasticSearch 接受數(shù)據(jù)的插入和搜索使用技巧，在實際的使用過程中，版本號尤其的重要，不同版本的 es，對應的 api 是不一樣的。

一、背景介紹

實際的項目開發(fā)過程中，我們通?；谀承┲髁骺蚣芷脚_進行技術開發(fā)，比如 SpringBoot，今天我們就以 SpringBoot 整合 ElasticSearch 為例，給大家詳細的介紹 ElasticSearch 的使用！

SpringBoot 連接 ElasticSearch，主流的方式有以下四種方式

  • 方式一：通過Elastic Transport Client客戶端連接 es 服務器，底層基于 TCP 協(xié)議通過 transport 模塊和遠程 ES 服務端通信，不過，從 V7.0 開始官方不建議使用，V8.0開始正式移除。
  • 方式二：通過Elastic Java Low Level Rest Client客戶端連接 es 服務器，底層基于 HTTP 協(xié)議通過 restful API 來和遠程 ES 服務端通信，只提供了最簡單最基本的 API，類似于上篇文章中給大家介紹的 API 操作邏輯
  • 方式三：通過Elastic Java High Level Rest Client客戶端連接 es 服務器，底層基于Elastic Java Low Level Rest Client客戶端做了一層封裝，提供了更高級得 API 且和Elastic Transport Client接口及參數(shù)保持一致，官方推薦的 es 客戶端。
  • 方式四：通過JestClient客戶端連接 es 服務器，這是開源社區(qū)基于 HTTP 協(xié)議開發(fā)的一款 es 客戶端，官方宣稱接口及代碼設計比 ES 官方提供的 Rest 客戶端更簡潔、更合理，更好用，具有一定的 ES 服務端版本兼容性，但是更新速度不是很快，目前 ES 版本已經出到 V7.9，但是JestClient只支持 V1.0~V6.X 版  本的 ES。

還有一個需要大家注意的地方，那就是版本號的兼容！

在開發(fā)過程中，大家尤其需要關注一下客戶端和服務端的版本號，要盡可能保持一致，比如服務端 es 的版本號是6.8.2，那么連接 es 的客戶端版本號，最好也是6.8.2，即使因項目的原因不能保持一致，客戶端的版本號必須在6.0.0 ～6.8.2，不要超過服務器的版本號，這樣客戶端才能保持正常工作，否則會出現(xiàn)很多意想不到的問題，假如客戶端是7.0.4的版本號，此時的程序會各種報錯，甚至沒辦法用！

為什么要這樣做呢？主要原因就是 es 的服務端，高版本不兼容低版本；es6 和 es7 的某些 API 請求參數(shù)結構有著很大的區(qū)別，所以客戶端和服務端版本號盡量保持一致。

廢話也不多說了，直接上代碼！

二、代碼實踐

本文采用的SpringBoot版本號是2.1.0.RELEASE，服務端 es 的版本號是6.8.2，客戶端采用的是官方推薦的Elastic Java High Level Rest Client版本號是6.4.2，方便與SpringBoot的版本兼容。

2.1、導入依賴

<!--elasticsearch-->
<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>6.4.2</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>6.4.2</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>6.4.2</version>
</dependency>

2.2、配置環(huán)境變量

在application.properties全局配置文件中，配置elasticsearch自定義環(huán)境變量

elasticsearch.scheme=http
elasticsearch.address=127.0.0.1:9200
elasticsearch.userName=
elasticsearch.userPwd=
elasticsearch.socketTimeout=5000
elasticsearch.connectTimeout=5000
elasticsearch.connectionRequestTimeout=5000

2.3、創(chuàng)建 elasticsearch 的 config 類

@Configuration
public class ElasticsearchConfiguration {

    private static final Logger log = LoggerFactory.getLogger(ElasticsearchConfiguration.class);


    private static final int ADDRESS_LENGTH = 2;

    @Value("${elasticsearch.scheme:http}")
    private String scheme;

    @Value("${elasticsearch.address}")
    private String address;

    @Value("${elasticsearch.userName}")
    private String userName;

    @Value("${elasticsearch.userPwd}")
    private String userPwd;

    @Value("${elasticsearch.socketTimeout:5000}")
    private Integer socketTimeout;

    @Value("${elasticsearch.connectTimeout:5000}")
    private Integer connectTimeout;

    @Value("${elasticsearch.connectionRequestTimeout:5000}")
    private Integer connectionRequestTimeout;

    /**
     * 初始化客戶端
     * @return
     */
    @Bean(name = "restHighLevelClient")
    public RestHighLevelClient restClientBuilder() {
        HttpHost[] hosts = Arrays.stream(address.split(","))
                .map(this::buildHttpHost)
                .filter(Objects::nonNull)
                .toArray(HttpHost[]::new);
        RestClientBuilder restClientBuilder = RestClient.builder(hosts);
        // 異步參數(shù)配置
        restClientBuilder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setDefaultCredentialsProvider(buildCredentialsProvider());
            return httpClientBuilder;
        });

        // 異步連接延時配置
        restClientBuilder.setRequestConfigCallback(requestConfigBuilder -> {
            requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeout);
            requestConfigBuilder.setSocketTimeout(socketTimeout);
            requestConfigBuilder.setConnectTimeout(connectTimeout);
            return requestConfigBuilder;
        });

        return new RestHighLevelClient(restClientBuilder);
    }


    /**
     * 根據(jù)配置創(chuàng)建HttpHost
     * @param s
     * @return
     */
    private HttpHost buildHttpHost(String s) {
        String[] address = s.split(":");
        if (address.length == ADDRESS_LENGTH) {
            String ip = address[0];
            int port = Integer.parseInt(address[1]);
            return new HttpHost(ip, port, scheme);
        } else {
            return null;
        }
    }

    /**
     * 構建認證服務
     * @return
     */
    private CredentialsProvider buildCredentialsProvider(){
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName,
                userPwd));
        return credentialsProvider;
    }
}

至此，客戶端配置完畢，項目啟動的時候，會自動注入到Spring的ioc容器里面。

2.4、索引管理

es 中最重要的就是索引庫，客戶端如何創(chuàng)建呢？請看下文！

  • 創(chuàng)建索引
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class IndexJunit {


    @Autowired
    private RestHighLevelClient client;

    /**
     * 創(chuàng)建索引（簡單模式）
     * @throws IOException
     */
    @Test
    public void createIndex() throws IOException {
        CreateIndexRequest request = new CreateIndexRequest("cs_index");
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }


    /**
     * 創(chuàng)建索引（復雜模式）
     * 可以直接把對應的文檔結構也一并初始化
     * @throws IOException
     */
    @Test
    public void createIndexComplete() throws IOException {
        CreateIndexRequest request = new CreateIndexRequest();
        //索引名稱
        request.index("cs_index");
        //索引配置
        Settings settings = Settings.builder()
                .put("index.number_of_shards", 3)
                .put("index.number_of_replicas", 1)
                .build();
        request.settings(settings);

        //映射結構字段
        Map<String, Object> properties = new HashMap();
        properties.put("id", ImmutableBiMap.of("type", "text"));
        properties.put("name", ImmutableBiMap.of("type", "text"));
        properties.put("sex", ImmutableBiMap.of("type", "text"));
        properties.put("age", ImmutableBiMap.of("type", "long"));
        properties.put("city", ImmutableBiMap.of("type", "text"));
        properties.put("createTime", ImmutableBiMap.of("type", "long"));
        Map<String, Object> mapping = new HashMap<>();
        mapping.put("properties", properties);
        //添加一個默認類型
        System.out.println(JSON.toJSONString(request));
        request.mapping("_doc",mapping);
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }

}
  • 刪除索引
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class IndexJunit {


    @Autowired
    private RestHighLevelClient client;

    /**
     * 刪除索引
     * @throws IOException
     */
    @Test
    public void deleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("cs_index1");
        AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }


}
  • 查詢索引
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class IndexJunit {


    @Autowired
    private RestHighLevelClient client;

    /**
     * 查詢索引
     * @throws IOException
     */
    @Test
    public void getIndex() throws IOException {
        // 創(chuàng)建請求
        GetIndexRequest request = new GetIndexRequest();
        request.indices("cs_index");
        // 執(zhí)行請求,獲取響應
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }

}
  • 查詢索引是否存在
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class IndexJunit {


    @Autowired
    private RestHighLevelClient client;

    /**
     * 檢查索引是否存在
     * @throws IOException
     */
    @Test
    public void exists() throws IOException {
        // 創(chuàng)建請求
        GetIndexRequest request = new GetIndexRequest();
        request.indices("cs_index");
        // 執(zhí)行請求,獲取響應
        boolean response = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(response);
    }

}
  • 查詢所有的索引名稱
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class IndexJunit {


    @Autowired
    private RestHighLevelClient client;

    /**
     * 查詢所有的索引名稱
     * @throws IOException
     */
    @Test
    public void getAllIndices() throws IOException {
        GetAliasesRequest request = new GetAliasesRequest();
        GetAliasesResponse response =  client.indices().getAlias(request,RequestOptions.DEFAULT);
        Map<String, Set<AliasMetaData>> map = response.getAliases();
        Set<String> indices = map.keySet();
        for (String key : indices) {
            System.out.println(key);
        }
    }

}
  • 查詢索引映射字段
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class IndexJunit {


    @Autowired
    private RestHighLevelClient client;

    /**
     * 查詢索引映射字段
     * @throws IOException
     */
    @Test
    public void getMapping() throws IOException {
        GetMappingsRequest request = new GetMappingsRequest();
        request.indices("cs_index");
        request.types("_doc");
        GetMappingsResponse response = client.indices().getMapping(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }


}
  • 添加索引映射字段
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class IndexJunit {


    @Autowired
    private RestHighLevelClient client;

    /**
     * 添加索引映射字段
     * @throws IOException
     */
    @Test
    public void addMapping() throws IOException {
        PutMappingRequest request = new PutMappingRequest();
        request.indices("cs_index");
        request.type("_doc");

        //添加字段
        Map<String, Object> properties = new HashMap();
        properties.put("accountName", ImmutableBiMap.of("type", "keyword"));
        Map<String, Object> mapping = new HashMap<>();
        mapping.put("properties", properties);
        request.source(mapping);
        PutMappingResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }


}

2.5、文檔管理

所謂文檔，就是向索引里面添加數(shù)據(jù)，方便進行數(shù)據(jù)查詢，詳細操作內容，請看下文！

  • 添加文檔
public class UserDocument {

    private String id;
    private String name;
    private String sex;
    private Integer age;
    private String city;
    private Date createTime;

    //省略get、set...
}
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class DocJunit {

    @Autowired
    private RestHighLevelClient client;


    /**
     * 添加文檔
     * @throws IOException
     */
    @Test
    public void addDocument() throws IOException {
        // 創(chuàng)建對象
        UserDocument user = new UserDocument();
        user.setId("1");
        user.setName("里斯");
        user.setCity("武漢");
        user.setSex("男");
        user.setAge(20);
        user.setCreateTime(new Date());

        // 創(chuàng)建索引,即獲取索引
        IndexRequest request = new IndexRequest();
        // 外層參數(shù)
        request.id("1");
        request.index("cs_index");
        request.type("_doc");
        request.timeout(TimeValue.timeValueSeconds(1));
        // 存入對象
        request.source(JSON.toJSONString(user), XContentType.JSON);
        // 發(fā)送請求
        System.out.println(request.toString());
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }

}
  • 更新文檔
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class DocJunit {

    @Autowired
    private RestHighLevelClient client;


    /**
     * 更新文檔（按需修改）
     * @throws IOException
     */
    @Test
    public void updateDocument() throws IOException {
        // 創(chuàng)建對象
        UserDocument user = new UserDocument();
        user.setId("2");
        user.setName("程咬金");
        user.setCreateTime(new Date());
        // 創(chuàng)建索引,即獲取索引
        UpdateRequest request = new UpdateRequest();
        // 外層參數(shù)
        request.id("2");
        request.index("cs_index");
        request.type("_doc");
        request.timeout(TimeValue.timeValueSeconds(1));
        // 存入對象
        request.doc(JSON.toJSONString(user), XContentType.JSON);
        // 發(fā)送請求
        System.out.println(request.toString());
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }


}
  • 刪除文檔
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class DocJunit {

    @Autowired
    private RestHighLevelClient client;


    /**
     * 刪除文檔
     * @throws IOException
     */
    @Test
    public void deleteDocument() throws IOException {
        // 創(chuàng)建索引,即獲取索引
        DeleteRequest request = new DeleteRequest();
        // 外層參數(shù)
        request.id("1");
        request.index("cs_index");
        request.type("_doc");
        request.timeout(TimeValue.timeValueSeconds(1));
        // 發(fā)送請求
        System.out.println(request.toString());
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }


}
  • 查詢文檔是不是存在
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class DocJunit {

    @Autowired
    private RestHighLevelClient client;


    /**
     * 查詢文檔是不是存在
     * @throws IOException
     */
    @Test
    public void exists() throws IOException {
        // 創(chuàng)建索引,即獲取索引
        GetRequest request = new GetRequest();
        // 外層參數(shù)
        request.id("3");
        request.index("cs_index");
        request.type("_doc");
        // 發(fā)送請求
        System.out.println(request.toString());
        boolean response = client.exists(request, RequestOptions.DEFAULT);
        System.out.println(response);
    }
}
  • 通過 ID 查詢指定文檔
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class DocJunit {

    @Autowired
    private RestHighLevelClient client;


    /**
     * 通過ID，查詢指定文檔
     * @throws IOException
     */
    @Test
    public void getById() throws IOException {
        // 創(chuàng)建索引,即獲取索引
        GetRequest request = new GetRequest();
        // 外層參數(shù)
        request.id("1");
        request.index("cs_index");
        request.type("_doc");
        // 發(fā)送請求
        System.out.println(request.toString());
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }
}
  • 批量添加文檔
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class DocJunit {

    @Autowired
    private RestHighLevelClient client;


    /**
     * 批量添加文檔
     * @throws IOException
     */
    @Test
    public void batchAddDocument() throws IOException {
        // 批量請求
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout(TimeValue.timeValueSeconds(10));
        // 創(chuàng)建對象
        List<UserDocument> userArrayList = new ArrayList<>();
        userArrayList.add(new UserDocument("張三", "男", 30, "武漢"));
        userArrayList.add(new UserDocument("里斯", "女", 31, "北京"));
        userArrayList.add(new UserDocument("王五", "男", 32, "武漢"));
        userArrayList.add(new UserDocument("趙六", "女", 33, "長沙"));
        userArrayList.add(new UserDocument("七七", "男", 34, "武漢"));
        // 添加請求
        for (int i = 0; i < userArrayList.size(); i++) {
            userArrayList.get(i).setId(String.valueOf(i));
            IndexRequest indexRequest = new IndexRequest();
            // 外層參數(shù)
            indexRequest.id(String.valueOf(i));
            indexRequest.index("cs_index");
            indexRequest.type("_doc");
            indexRequest.timeout(TimeValue.timeValueSeconds(1));
            indexRequest.source(JSON.toJSONString(userArrayList.get(i)), XContentType.JSON);
            bulkRequest.add(indexRequest);
        }
        // 執(zhí)行請求
        BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(response.status());
    }

}

2.6、高級查詢管理

es 最大的亮點就是查詢非常豐富，可以在上億的數(shù)據(jù)里面快速搜索出目標數(shù)據(jù)，查詢如果實現(xiàn)呢？請看下文

  • 單條件精確查詢
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 單條件精確查詢
     * @throws IOException
     */
    @Test
    public void search0() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.termsQuery("name", "趙里"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 多條件精確查詢，取并集
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 多條件精確查詢，取并集
     * @throws IOException
     */
    @Test
    public void search1() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.termsQuery("name", "張", "陳"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 范圍查詢
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 范圍查詢，包括from、to
     * @throws IOException
     */
    @Test
    public void search2() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.rangeQuery("age").from(20).to(32));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }


    /**
     * 范圍查詢，不包括from、to
     * @throws IOException
     */
    @Test
    public void search3() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.rangeQuery("age").from(20,false).to(30, false));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }


    /**
     * 范圍查詢, lt:小于，gt:大于
     * @throws IOException
     */
    @Test
    public void search4() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.rangeQuery("age").lt(30).gt(20));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 模糊查詢，支持通配符
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 模糊查詢，支持通配符
     * @throws IOException
     */
    @Test
    public void search5() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.wildcardQuery("name","張三"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 不使用通配符的模糊查詢，左右匹配
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 不使用通配符的模糊查詢，左右匹配
     * @throws IOException
     */
    @Test
    public void search6() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.queryStringQuery("張三").field("name"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 多字段模糊查詢
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 多字段模糊查詢
     * @throws IOException
     */
    @Test
    public void search7() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.multiMatchQuery("長", "name", "city"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 多字段模糊查詢
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 分頁搜索
     * @throws IOException
     */
    @Test
    public void search8() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .from(0).size(2);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 字段排序
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 排序，字段的類型必須是：integer、double、long或者keyword
     * @throws IOException
     */
    @Test
    public void search9() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .sort("createTime", SortOrder.ASC);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 精確統(tǒng)計篩選文檔數(shù)
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 精確統(tǒng)計篩選文檔數(shù),查詢性能有所降低
     * @throws IOException
     */
    @Test
    public void search10() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .trackTotalHits(true);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 設置源字段過濾返回
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 設置源字段過慮,第一個參數(shù)結果集包括哪些字段，第二個參數(shù)表示結果集不包括哪些字段
     * @throws IOException
     */
    @Test
    public void search11() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .fetchSource(new String[]{"name","age","city","createTime"},new String[]{});

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • 根據(jù) id 精確匹配
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 根據(jù)id精確匹配
     * @throws IOException
     */
    @Test
    public void search12() throws IOException {
        String[] ids = new String[]{"1","2"};
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.termsQuery("_id", ids));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }

}
  • matchAllQuery 搜索全部
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * matchAllQuery搜索全部
     * @throws IOException
     */
    @Test
    public void search21() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.matchAllQuery());

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • match 搜索匹配
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * match搜索匹配
     * @throws IOException
     */
    @Test
    public void search22() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.matchQuery("name", "張王"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • bool組合查詢
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * bool組合查詢
     * @throws IOException
     */
    @Test
    public void search23() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder();

        BoolQueryBuilder boolQueryBuilder=new BoolQueryBuilder();
        boolQueryBuilder.must(QueryBuilders.matchQuery("name", "張王"));
        boolQueryBuilder.must(QueryBuilders.rangeQuery("age").lte(30).gte(20));
        builder.query(boolQueryBuilder);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • nested 類型嵌套查詢
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * nested類型嵌套查詢
     * @throws IOException
     */
    @Test
    public void search24() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //條件查詢
        BoolQueryBuilder mainBool=new BoolQueryBuilder();
        mainBool.must(QueryBuilders.matchQuery("name", "趙六"));

        //nested類型嵌套查詢
        BoolQueryBuilder boolQueryBuilder=new BoolQueryBuilder();
        boolQueryBuilder.must(QueryBuilders.matchQuery("products.brand", "A"));
        boolQueryBuilder.must(QueryBuilders.matchQuery("products.title", "巧克力"));
        NestedQueryBuilder nested = QueryBuilders.nestedQuery("products",boolQueryBuilder, ScoreMode.None);
        mainBool.must(nested);

        builder.query(mainBool);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • 多條件查詢 + 排序 + 分頁
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 多條件查詢 + 排序 + 分頁
     * @throws IOException
     */
    @Test
    public void search29() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //條件搜索
        BoolQueryBuilder boolQueryBuilder=new BoolQueryBuilder();
        boolQueryBuilder.must(QueryBuilders.matchQuery("name", "張王"));
        boolQueryBuilder.must(QueryBuilders.rangeQuery("age").lte(30).gte(20));
        builder.query(boolQueryBuilder);

        //結果集合分頁
        builder.from(0).size(2);

        //排序
        builder.sort("createTime",SortOrder.ASC);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • 聚合查詢-求和
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 聚合查詢 sum
     * @throws IOException
     */
    @Test
    public void search30() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //條件搜索
        builder.query(QueryBuilders.matchAllQuery());
        //聚合查詢
        AggregationBuilder aggregation = AggregationBuilders.sum("sum_age").field("age");
        builder.aggregation(aggregation);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • 聚合查詢-求平均值
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 聚合查詢 avg
     * @throws IOException
     */
    @Test
    public void search31() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //條件搜索
        builder.query(QueryBuilders.matchAllQuery());
        //聚合查詢
        AggregationBuilder aggregation = AggregationBuilders.avg("avg_age").field("age");
        builder.aggregation(aggregation);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • 聚合查詢-計數(shù)
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 聚合查詢 count
     * @throws IOException
     */
    @Test
    public void search32() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //條件搜索
        builder.query(QueryBuilders.matchAllQuery());
        //聚合查詢
        AggregationBuilder aggregation = AggregationBuilders.count("count_age").field("age");
        builder.aggregation(aggregation);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}
  • 聚合查詢-分組
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class SearchJunit {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 聚合查詢 分組
     * @throws IOException
     */
    @Test
    public void search33() throws IOException {
        // 創(chuàng)建請求
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //條件搜索
        builder.query(QueryBuilders.matchAllQuery());
        //聚合查詢
        AggregationBuilder aggregation = AggregationBuilders.terms("tag_createTime").field("createTime")
                .subAggregation(AggregationBuilders.count("count_age").field("age")) //計數(shù)
                .subAggregation(AggregationBuilders.sum("sum_age").field("age")) //求和
                .subAggregation(AggregationBuilders.avg("avg_age").field("age")); //求平均值

        builder.aggregation(aggregation);

        //不輸出原始數(shù)據(jù)
        builder.size(0);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("cs_index");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 執(zhí)行請求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查詢結果
        System.out.println(response.toString());
    }
}

三、小結

本文主要圍繞 SpringBoot 整合 ElasticSearch 接受數(shù)據(jù)的插入和搜索使用技巧，在實際的使用過程中，版本號尤其的重要，不同版本的 es，對應的 api 是不一樣的。

責任編輯：武曉燕 來源： 潘志的研發(fā)筆記
Spring數(shù)據(jù)搜索服務
相關推薦

2022-05-30 07:31:38

SpringBoot搜索技巧

2016-06-16 10:52:25

IBM

2014-11-11 17:16:54

SSLStrip

2012-10-22 14:58:21

Office 2013

2024-08-29 08:58:30

JPA編寫數(shù)據(jù)操

2021-01-07 13:08:27

AI 數(shù)據(jù)人工智能

2025-03-03 08:00:00

SpringBootEasyExcel數(shù)據(jù)導出

2024-11-11 10:02:37

Spring搜索數(shù)據(jù)

2009-12-04 14:16:22

2024-11-19 09:15:40

搜索類型MySQL

2022-02-01 15:00:17

Windows 11Windows 10微軟

2024-03-27 07:55:58

SpringRedis海量

2018-11-19 15:06:57

華為云

2024-07-17 08:29:20

2020-06-10 08:23:44

JavaScript開發(fā)Web

2024-09-11 08:35:54

2010-07-14 10:53:05

MyEclipse 8漢化

2024-08-26 08:27:18

2023-07-03 15:55:05

語法jpa狀態(tài)

2023-11-10 08:17:01

分布式搜索引擎
點贊
收藏

51CTO技術棧公眾號