SpringBoot集成ElasticSearch

最新推荐文章于 2022-04-05 16:52:43 发布
最新推荐文章于 2022-04-05 16:52:43 发布
阅读量312 收藏
点赞数
分类专栏： java 文章标签： elasticsearch es
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42998267/article/details/105366042
版权

引入依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

编写配置类Config

package com.hzy.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// Spring两步骤
//1.找对象
//2.放到Spring中选用
//3.如果是SpringBoot 就先分析源码！
@Configuration
public class ElasticsearchConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client=new RestHighLevelClient(
                RestClient.builder(new HttpHost("127.0.0.1",9200,"http"))
        );
        return client;
    }
}

具体的API操作

  1. 创建索引
  2. 判断索引是否存在
  3. 删除索引
  4. 创建文档
  5. crud文档
package com.hzy;

import com.alibaba.fastjson.JSON;
import com.hzy.pojo.User;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
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.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

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

/*
* es7.6高级客户端测试API
* */
@SpringBootTest
class HzyEsApiApplicationTests {
    //面向对象操作
    @Autowired
    @Qualifier(value = "restHighLevelClient")//指定ID
    private RestHighLevelClient client;

    //测试索引的创建，Request
    @Test
    void testCreateIndex() throws IOException {
        //1.创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("hzy_index");
        //2.客户端执行请求IndicesClient,请求后获得响应
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);

    }
    //测试获取索引,判断是否存在
    @Test
    void testExistIndex() throws IOException {
//        GetIndexRequest request=new GetIndexRequest("hzy_index");
//        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
//        System.out.println(exists);
    }
    //测试删除索引
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request=new DeleteIndexRequest("hzy_index");
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());//判断是否删除成功
    }
    //创建文档
    @Test
    void testAddDocument() throws IOException {
        User user=new User("hzy",3);
        IndexRequest request=new IndexRequest("hzy_index");
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");

        //request.type("text");//新版本es不需要
        //将我们的数据放入请求 json
        request.source(JSON.toJSONString(user), XContentType.JSON);
        //客户端发送请求,获取响应结果
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
        System.out.println(indexResponse.toString());//插入成功返回信息
        System.out.println(indexResponse.status());//对应我们命令返回的状态  CREATED
    }
    //获取文档，判断是否存在
    @Test
    void testIsExists() throws IOException {
        GetRequest getRequest = new GetRequest("hzy_index","text","1");
        //不获取返回的_source的上下文了
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        getRequest.storedFields("_none_");
        boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
    }
    //获取文档的信息
    @Test
    void testGetDocument() throws IOException {
        GetRequest getRequest=new GetRequest("hzy_index","text","1");
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        System.out.println(getResponse.getSourceAsString());//打印文档的内容
        System.out.println(getResponse);//返回的全部内容和命令是一样的
    }
    //更新文档的信息
    @Test
    void testUpdateDocument() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest("hzy_index", "text", "1");
        updateRequest.timeout("1s");
        User user=new User("hzy",18);
        updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
        client.update(updateRequest,RequestOptions.DEFAULT);

    }
    //删除文档的信息
    @Test
    void testDeleteDocument() throws IOException {
        DeleteRequest deleteRequest=new DeleteRequest("hzy_index","text","3");
        deleteRequest.timeout("1s");
        DeleteResponse delete = client.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(delete.toString());
        System.out.println(delete.status());
    }
    //特殊的，真的项目中一般会批量插入数据
    @Test
    void testBulkRequest() throws IOException {
        BulkRequest bulkRequest=new BulkRequest();
        bulkRequest.timeout("10s");
        List<User> userList=new ArrayList<>();
        userList.add(new User("A",3));
        userList.add(new User("A1",3));
        userList.add(new User("A2",3));
        userList.add(new User("A3",3));
        userList.add(new User("A4",3));
        //批量处理请求
        for (int i = 0; i < userList.size(); i++) {
            //批量更新和删除，就在这里修改对应的请求就可以了！
            bulkRequest.add(new IndexRequest("hzy_index")
                    .id(""+(i+1))
                    .source(JSON.toJSONString(userList.get(i)),XContentType.JSON)
            );
        }
        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk.hasFailures());//成功false还是失败true
    }
    //查询
    /*
    * SearchRequest 搜索请求
    * SearchSourceBuilder 条件构造
    * xxx QueryBuilder 对应我们刚才看到的API
    * */
    @Test
    void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("hzy_index");
        //构建搜索的条件
        SearchSourceBuilder sourceBuilder=new SearchSourceBuilder();
        //查询条件，我们可以使用QueryBuilders工具类来实现,需要什么查询直接点
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "hzy");
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        SearchRequest source = searchRequest.source(sourceBuilder);
        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(search.getHits());
        for (SearchHit documentFields:search.getHits()) {
            System.out.println(documentFields.getSourceAsMap());
        }

    }
}

数据从哪里来(爬虫)

爬取数据：(获取请求返回的页面信息，筛选出我们想要的数据就可以了！)
jsoup包
引入依赖

<!--		解析网页jSoup-->
		<dependency>
			<groupId>org.jsoup</groupId>
			<artifactId>jsoup</artifactId>
			<version>1.10.2</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.58</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

项目实战
基本目录结构
在这里插入图片描述配置类

package com.hzy.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ESConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client=new RestHighLevelClient(
                RestClient.builder(new HttpHost("127.0.0.1",9200,"http"))
        );
        return client;
    }
}

配置文件

server.port=9090
# \u5173\u95EDthymeleaf\u7F13\u5B58
spring.thymeleaf.cache=false

编写pojo保存爬取的数据

package com.hzy.pojo;

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

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Content {
    private String title;
    private String img;
    private String price;
}

编写爬取的工具类

package com.hzy.utils;

import com.hzy.pojo.Content;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

@Component
public class HtmlParseUtil {
//    public static void main(String[] args) throws Exception {
//        new HtmlParseUtil().parseJD("java").forEach(System.out::println);
//    }
    public List<Content> parseJD(String keywords) throws Exception {
        String url="https://search.jd.com/Search?keyword="+keywords;
        //解析网页:{返回的document就是页面对象}
        Document document = Jsoup.parse(new URL(url), 30000);
        //所有在js中用的都可以用
        Element element = document.getElementById("J_goodsList");
        //获取所有的li元素
        Elements elements = element.getElementsByTag("li");
        ArrayList<Content> goodsList = new ArrayList<>();
        for (Element el:elements) {
            String img=el.getElementsByTag("img").eq(0).attr("source-data-lazy-img");
            String price=el.getElementsByClass("p-price").eq(0).text();
            String title=el.getElementsByClass("p-name").eq(0).text();
            Content content=new Content();
            content.setTitle(title);
            content.setImg(img);
            content.setPrice(price);
            goodsList.add(content);
        }
        return goodsList;
    }
}

编写业务service(实现爬取数据放入es，查询和高亮查询)

package com.hzy.service;

import com.alibaba.fastjson.JSON;
import com.hzy.pojo.Content;
import com.hzy.utils.HtmlParseUtil;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
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.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Service
public class ContentService {
    @Autowired
    private RestHighLevelClient restHighLevelClient;
    //1.解析数据放入es索引中
    public Boolean parseContent(String keywords) throws Exception {
        List<Content> contents = new HtmlParseUtil().parseJD(keywords);
        //把查询到的数据放入es中
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("2m");

        for (int i = 0; i < contents.size(); i++) {
            bulkRequest.add(new IndexRequest("jd_goods").type(keywords)
                    .source(JSON.toJSONString(contents.get(i)), XContentType.JSON));
        }
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        return !bulk.hasFailures();
    }
    //2.获取这些数据实现搜索功能
    public List<Map<String,Object>> searchPage(String keyword,int pageNo,int pageSize) throws IOException {
        if(pageNo<=1){
            pageNo=1;
        }
        //条件搜索
        SearchRequest searchRequest=new SearchRequest("jd_goods").types(keyword);
        SearchSourceBuilder sourceBuilder=new SearchSourceBuilder();
        //分页
        sourceBuilder.from(pageNo);
        sourceBuilder.size(pageSize);
        //精准匹配
        TermQueryBuilder termQueryBuilder=new TermQueryBuilder("title",keyword);
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        searchRequest.source(sourceBuilder);
        SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = search.getHits();
        List<Map<String,Object>> list=new ArrayList<>();
        for (SearchHit hit:hits) {
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            list.add(sourceAsMap);
        }
        return list;
    }
    //3.实现搜索高亮功能
    public List<Map<String,Object>> searchPageHighlight(String keyword,int pageNo,int pageSize) throws IOException {
        if(pageNo<=1){
            pageNo=1;
        }
        //条件搜索
        SearchRequest searchRequest=new SearchRequest("jd_goods").types(keyword);
        SearchSourceBuilder sourceBuilder=new SearchSourceBuilder();
        //分页
        sourceBuilder.from(pageNo);
        sourceBuilder.size(pageSize);
        //精准匹配
        TermQueryBuilder termQueryBuilder=new TermQueryBuilder("title",keyword);
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        //高亮
        HighlightBuilder highlightBuilder=new HighlightBuilder();
        highlightBuilder.field("title");
        highlightBuilder.requireFieldMatch(false);//一句话中是否高亮多个词
        highlightBuilder.preTags("<i style='color:red;'>");
        highlightBuilder.postTags("</i>");
        sourceBuilder.highlighter(highlightBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = search.getHits();
        List<Map<String,Object>> list=new ArrayList<>();
        for (SearchHit hit:hits) {
            //解析高亮的字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField title = highlightFields.get("title");//高亮的字段

            Map<String, Object> sourceAsMap = hit.getSourceAsMap();//原来的结果
            //解析高亮的字段，将原来的字段转换为高亮的字段
            Text[] fragments = title.fragments();
            String newtitle="";
            for (int i = 0; i < fragments.length; i++) {
                newtitle+=fragments[i];
            }
            sourceAsMap.put("title",newtitle);//替换原来的title
            list.add(sourceAsMap);
        }
        return list;
    }
}

编写访问搜索页面的controller

package com.hzy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class IndexController {
    @RequestMapping({"/","/index"})
    public String index(){
        return "index";
    }
}

编写和业务层对应的RestController实现(爬取数据放入es，查询和高亮查询)

package com.hzy.controller;

import com.hzy.service.ContentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
public class ContentController {
    @Autowired
    private ContentService contentService;

    @GetMapping("/parse/{keyword}")
    public Boolean parse(@PathVariable("keyword") String keyword) throws Exception {
        return contentService.parseContent(keyword);
    }

    //@GetMapping("/search/{keyword}/{pageNo}/{pageSize}")
    @GetMapping("/searchPageHighlight/{keyword}/{pageNo}/{pageSize}")
    public List<Map<String,Object>> search(@PathVariable("keyword") String keyword,@PathVariable("pageNo") Integer pageNo,@PathVariable("pageSize") Integer pageSize){
        try {
            return contentService.searchPageHighlight(keyword, pageNo, pageSize);
        } catch (IOException e) {
            return null;
        }
    }
}

前端再进行渲染就可以了！

程序员之窝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最新版本springboot集成elasticsearch
05-25
一、概述 一般来说我们开发Elasticsearch会选择使用集成springboot，在网上找的springboot集成elasticsearch文章几乎都是extends ElasticsearchRepository的方式来实现。但是新版本ElasticsearchRepository里的方法基本上已经过时了。 我们去spring官网去看下， 可以看到，官方的github上的示例改成extends CrudRepository p.s. 写此文章出于以下几点考虑 目前网上找到的elasticsearch教程都比较旧 ElasticsearchRepository方法在新版本基本过时了 基于springdata的CrudRepository操作ES封装的比较完善，但网上的教程比较少 二、准备工作 1、下载elasticsearch 2、elasticsearch-head (方便查看ES中的索引及数据) 3、Kibana(方便开发通过rest api 调试ES，有代码提示) 4、中文分词elasticsearch-analysis-ik （ik） 1、下载ela
Springboot整合elasticsearch
qq_43801398的博客
07-21 436
springboot 整合elasticsearch 的两种实现方式 先引入es的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> <version>2.3.0.REL
SpringBoot学习-part66 整合ElasticSearch操作
Ezerbel的博客
07-17 171
加载依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> SpringBoot整合代码位置
SpringBoot整合ElasticSearch 入门级-简单易学
qq_42137703的博客
09-07 499
SpringBoot整合ElasticSearch
Elasticsearch-01.初识Elasticsearch【废弃】
努力推石头的西西弗斯
05-24 589
Elasticsearch-01.初识Elasticsearch 本系列博客基于Elasticsearch 7.0进行编写，旨在对自己的所学进行结构化输出，查漏补缺。 什么是Elasticsearch Elasticsearch是一个搜索、存储和数据分析引擎，具有分布式、高性能、高可用、可伸缩、易维护的特点。 Elasticsearch并非从零起步，而是站在巨人的肩膀上。Elasticsearch基于Java编写，其内部使用Lucene做索引与搜索。通过进一步封装Lucene，向开发人员屏蔽了Luce
ElasticSearch学习（三）
mumu95406的博客
09-01 307
ElasticSearch实战学习 一、Spring Boot集成 学习方法 可以去官网找文档查看如何集成。 首先构建一个项目，构建完成后，在将找到的引入语句放到pom.xml中，之后是更新maven，完成后就是构建ES高级客户端对象。完成后就已经完成了ES到springboot的整合。 package com.mumu.esapi.config; import org.apache.http.HttpHost; import org.elasticsearch.client.RestCli
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用）
04-18
本实例属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、关键字查询、...
springboot 集成elasticsearch ,api的使用
08-02
在本文中，我们将深入探讨如何将Spring Boot与Elasticsearch集成，并使用其API进行数据操作。Elasticsearch是一个流行的开源搜索引擎，它提供了实时、分布式、容错能力的搜索和数据分析功能。Spring Boot则是一个...
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用
11-12
本实例为博主原创，属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、...
SpringBoot集成Elasticsearch过程实例
08-19
SpringBoot集成Elasticsearch过程实例 在本文中，我们将详细介绍如何使用SpringBoot集成Elasticsearch，包括准备工作、Maven配置、实体类设计、访问接口设计和测试用例等步骤。同时，我们还将对可能出现的异常进行...
kubernetes集群elasticsearch日志查询--java客户端开发
xingyuzhe的博客
07-18 1357
目标：基于elasticsearch api开发客户端，结合EFK日志框架，实现指定容器的日志收集 环境：IntelliJ IDEA 步骤：Elasticsearch概述-&gt;项目依赖pom.xml-&gt;elasticsearch api服务开发-&gt;运行测试 1.Elasticsearch概述 Elasticsearch是一个基于Lucene构建的开源、分布式、RESTful...
ElasticSearch
一条没有梦想的闲鱼的博客
04-05 1692
目录​​​​​​​ 概述 安装 可视化界面 ELK 安装Kibana ES核心概念 关系型数据库和elasticsearch的对比 文档 类型 索引 物理设计：节点和分片如何工作 倒排索引 elasticsearch的索引和lucene索引对比 IK分词器 安装 自定义分词 Rest风格说明 创建一个索引 基本类型 指定字段类型 扩展 修改索引 删除索引 复杂操作搜索 布尔值查询 精确查询 高亮 自定义高亮 集成SpringBoot...
elasticsearch 常见操作
weixin_33748818的博客
03-11 943
package com.topwalk.analysis.es.operation.impl; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import ja...
ElasticSearch 实战
一舫的博客
02-08 2259
1. 背景 Lucene 是一套信息检索工具包（jar包），不包含搜索引擎系统。包含：索引结构，排序，搜索规则… ElasticSearch 基于 Lucene库 做了一些封装和增强，是一个分布式全文搜索引擎（全文搜索、结构化搜索、分析），可以通过简单的RESTful API来隐藏Lucene的复杂性，从而让全局搜索变得更简单。 2.ElasticSearch安装 JDK1.8，最低要求 ElasticSearch下载 ElasticSearch Head 插件下载 ElasticSearch IK分词
ElasticSearch学习笔记
ls_wifi的博客
11-24 325
elasticsearch是面向文档 数据库对应索引 表对应types(慢慢会被弃用！) 行对应documents(文档) 字段对应fields elasticsearch在后台把每个索引划分成多个分片，每分分片可以在集群中的不同服务器间迁移 一个人就是一个集群！ 默认的集群名称就是elasticsearch 文档就是一条条记录 倒排索引：采用Lucene倒排索引作为底层，这种结构适用于快速的全文搜索，一个索引由文档中所有不重复的列表构成，对于每一个词，都有一个包含它的文档列表。 IK...
Elasticsearch系列(五)----JAVA客户端之TransportClient操作详解
热门推荐
fendo
09-05 5万+
Elasticsearch JAVA操作有三种客户端: 1、TransportClient 2、JestClient 3、RestClient 还有种是2.3中有的NodeClient,在5.5.1中好像没有了。这里先以TransportClient来讲解CRUD，详细代码如下: package com.fendo.temp; import java.io.Bu
Elasticsearch 2.3.3 JAVA api说明文档
dht91597的博客
07-27 411
原文地址：https://www.blog-china.cn/template\documentHtml\1484101683485.html翻译作者：@青山常在人不老 加入翻译：cdcnsuper@blog-china.cn 版权所有：@码上中国博客(https://blog-china.cn) 1前言 本节介绍elasticsearch...
ElasticSearch7.6.1入门到整合，就看这9个关键点
qq_43097201的博客
04-28 1456
1、Elasticsearch是什么？ Elasticsearch是基于Lucence的一款分布式实时搜索引擎（ 仅支持JDK1.8以上 ），其跟Lucence一样是基于Java开发的，并以Lucence作为核心包来实现索引和搜索的功能。但是由于Lucence在开发使用时稍偏复杂，所以Elasticsearch通过Restful API的方式进行调用，直接隐藏了Lucence的复杂性。 2、Elasticsearch对比Solr、Lucence有什么区别？ Elasticsearch、Solr都是基于
SpringBoot整合ElasticSearch
王景清的博客
02-17 948
依赖 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.4.2</version> </dependency> 由于SringBoot对一些依赖有统一的版本管理 这里不使用默认的e
springboot集成elasticsearch
最新发布
04-09
好的，关于springboot集成elasticsearch，你可以参考以下步骤： 1. 在pom.xml中添加elasticsearch和spring-boot-starter-data-elasticsearch的依赖 2. 在application.properties中配置elasticsearch的连接地址和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值