二、springboot整合elasticsearch+hanlp（7.16.2）----附完整测试用例

最新推荐文章于 2024-08-01 21:02:03 发布
最新推荐文章于 2024-08-01 21:02:03 发布
阅读量7.6k 收藏 2
点赞数 1
分类专栏： 功能点汇总 文章标签： elasticsearch spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51706962/article/details/129079562
版权
本文介绍了如何在SpringBoot项目中整合Elasticsearch7.16.2版本和HanLP分词器，实现了基本的数据操作、关键字搜索、时间排序和高亮显示。还提供了Gitee上的测试用例链接以及部分关键代码示例，包括配置信息和工具类。此外，提到了部署Elasticsearch服务器的拓展内容，特别是通过docker-compose进行部署的方法。
摘要由CSDN通过智能技术生成

目录

一、实现效果图：

请添加图片描述

二、主要实现以下几点：

1、springboot整合elasticsearch+hanlp分词器 (7.16.2) 。

2、实现基本的增删改查功能、关键字分页搜索、时间排序、关键字高亮等操作 。

建议elastic用7.16.2版本，（即使是用了其他比7.16更高的版本，基本语法是不会改变的，所以降到7.16并不会有非常大的影响）而且插件也只支持到7.16.2。)

三、gitee测试用例（推荐）：

链接: https://gitee.com/muyangrenOvo/elastic-boot

四、部分实现代码

1、添加pom依赖

<!--elasticsearch7.16.2依赖包-->
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>7.16.2</version>
</dependency>
<dependency>
<groupId>co.elastic.clients</groupId>
<artifactId>elasticsearch-java</artifactId>
<version>7.16.2</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>
<dependency>
    <groupId>jakarta.json</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>2.0.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.12.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.12.3</version>
</dependency>

2、配置appllication.yml

#elasticsearch-ip-端口-索引-分词器(如下)-是否需要账号密码
#hanlp: hanlp默认分词
#hanlp_standard: 标准分词
#hanlp_index: 索引分词
#hanlp_n_short: N-最短路分词
#hanlp_dijkstra: 最短路分词
#hanlp_speed: 极速词典分词
elasticsearch:
  ip: 192.168.xxx.xxx:9200       
  index: transfer 
  analyzer: hanlp_index
  isNeedAccount: false

3、配置ES信息

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author muyangren
 * @Auther: muyangren
 * @Date: 2022/6/30
 * @Description: @Configuration 类似 xml-bean
 * @Version: 1.0
 */
  @Configuration
  public class ElasticSearchClientConfig {
      @Value("${elasticsearch.ip}")
      private String ip;
      @Value("${elasticsearch.isNeedAccount}")
      private boolean isNeedAccount;
      @Bean
      public ElasticsearchClient elasticsearchClient() {
          ElasticsearchClient client;
          //是否需要账号密码
          if (isNeedAccount){
              CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
              credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("elastic", "admin@123456"));
              RestClient restClient = RestClient.builder(this.getElasticSearchHttpHosts()).setHttpClientConfigCallback(httpAsyncClientBuilder -> {
                  httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                  return httpAsyncClientBuilder;
              }).build();
              ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
              client = new ElasticsearchClient(transport);
          }else {
              // Create the low-level client
              RestClient restClient = RestClient.builder(this.getElasticSearchHttpHosts()).build();
              // Create the transport with a Jackson mapper
              ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
              // And create the API client
              client = new ElasticsearchClient(transport);
          }
          return client;
      }
      /**
       * ElasticSearch 连接地址
       * 多个逗号分隔
       * 示例：127.0.0.1:9201,127.0.0.1:9202,127.0.0.1:9203
       */
      private HttpHost[] getElasticSearchHttpHosts() {
          String[] hosts = ip.split(",");
          HttpHost[] httpHosts = new HttpHost[hosts.length];
          for (int i = 0; i < httpHosts.length; i++) {
              String host = hosts[i];
              httpHosts[i] = new HttpHost(host.split(":")[0], Integer.parseInt(host.split(":")[1]));
          }
          return httpHosts;
      }
  }

4、集成工具类ElasticSearchUtils

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.ElasticsearchException;
import co.elastic.clients.elasticsearch._types.Result;
import co.elastic.clients.elasticsearch._types.mapping.Property;
import co.elastic.clients.elasticsearch._types.mapping.TextProperty;
import co.elastic.clients.elasticsearch._types.mapping.TypeMapping;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkOperation;
import co.elastic.clients.elasticsearch.core.bulk.BulkResponseItem;
import co.elastic.clients.elasticsearch.indices.CreateIndexRequest;
import co.elastic.clients.elasticsearch.indices.CreateIndexResponse;
import co.elastic.clients.elasticsearch.indices.IndexSettings;
import co.elastic.clients.transport.endpoints.BooleanResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.tool.utils.Func;
import org.springblade.modules.talk.entity.TransEsContent;
import org.springframework.stereotype.Component;

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

/**
 * @author guangsheng
 * @Date: 2022/7/14
 * @Description: 重构ES方法，解决代码重复问题 方法大致如此，细节需要自己去打磨
 * @Version: 1.0
 */
@Component
public class ElasticSearchUtils {

    private static final Logger logger = LoggerFactory.getLogger(ElasticSearchUtils.class);


    /**
     * 判断索引(index)是否存在
     */
    public static Boolean whetherIndex(ElasticsearchClient esClient,String index){
        BooleanResponse getIndexResponse;
        boolean whetherIndex = false;
        try {
            getIndexResponse = esClient.indices().exists(e -> e.index(index));
            whetherIndex = getIndexResponse.value();
        } catch (IOException e) {
            logger.info("es服务器超时,【{}】索引查询失败,请检查es服务器是否启动,该功能不影响后续代码执行。",index);
        }
        return whetherIndex;
    }

    /**
     * 添加索引
     * 分析器主要有两种情况会被使用：
     * 第一种是插入文档时，将text类型的字段做分词然后插入倒排索引，
     * 第二种就是在查询时，先对要查询的text类型的输入做分词，再去倒排索引搜索
     * analyzer: 分词器
     * searchAnalyzer： 查询分词器
     */
    public static Boolean addIndex(ElasticsearchClient esClient,String index,String analyzer){
        boolean whetherTrue =false;
        try {
            // 配置索引
            Map<String, Property> property = new HashMap<>(1);
            property.put("onlyOneBest", new Property(new TextProperty.Builder()
                    .analyzer(analyzer)
                    .searchAnalyzer(analyzer)
                    .index(true)
                    .store(true)
                    .build()));
            TypeMapping typeMapping = new TypeMapping.Builder()
                    .properties(property)
                    .build();
            IndexSettings indexSettings  = new IndexSettings.Builder()
                    .numberOfShards("5")
                    .build();
            CreateIndexRequest createIndexRequest = new CreateIndexRequest.Builder()
                    .index(index)
                    .mappings(typeMapping)
                    .settings(indexSettings)
                    .build();
            CreateIndexResponse createIndexResponse = esClient.indices().create(createIndexRequest);
            whetherTrue = Boolean.TRUE.equals(createIndexResponse.acknowledged());
        } catch (IOException e) {
            logger.info("es服务器超时，请检查es服务器是否启动，该功能不影响后续代码执行");
        } catch (ElasticsearchException e) {
            logger.info("同步服务器--es服务器未启用，或者版本错误导致");
        }
        return whetherTrue;
    }

    /**
     * ES添加方法
     */
    public static void addEsTransfer(ElasticsearchClient esClient, TransEsContent transEsContent , String index) {
        //存储到ES中
        try {
            CreateResponse createResponse = esClient.create(e -> e
                    .index(index)
                    .id(String.valueOf(transEsContent.getId()))
                    .document(transEsContent));
            Result result = createResponse.result();
            if (Func.isNotEmpty(result)) {
                logger.info("【id】：{},es添加数据：{}", transEsContent.getId(), result);
            }
        } catch (IOException e) {
            logger.info("【id】：{}未添加到es服务器,es服务器超时，请检查es服务器是否启动，该功能不影响后续代码执行", transEsContent.getId());
        } catch (ElasticsearchException e) {
            logger.info("添加---es服务器未启用，或者版本错误导致");
        }
    }

    /**
     * 同步所有数据
     * 批量超过一万条会超时，这里使用分页解决，每次插入五百条
     */
    public static void addAllEsTransfer(ElasticsearchClient esClient,List<TransEsContent> transList,String index) {
        BulkRequest.Builder builder = new BulkRequest.Builder();
        for (TransEsContent trans : transList) {
            builder.operations(op -> op
                    .index(idx -> idx
                            .index(index)
                            .id(String.valueOf(trans.getId()))
                            .document(trans)));
        }
        BulkResponse result;
        try {
            result = esClient.bulk(builder.build());
            if (Func.isNotEmpty(result)) {
                logger.info("数据同步到es服务器,数量为：" + result.took());
            }
        } catch (IOException e) {
            logger.info("es服务器超时，请检查es服务器是否启动，该功能不影响后续代码执行");
        } catch (ElasticsearchException e) {
            logger.info("同步服务器--es服务器未启用，或者版本错误导致");
        }
    }
    /**
     * ES更新方法
     */
    public static void updateEsTransfer(TransEsContent transEsContent, ElasticsearchClient esClient, String index) {
        try {
            //先查看是否存在ES服务中
            GetRequest.Builder builder = new GetRequest.Builder();
            GetRequest transfer = builder.index(index).id(String.valueOf(transEsContent.getId())).build();
            GetResponse<TransEsContent> getResponse = esClient.get(transfer, TransEsContent.class);
            TransEsContent source = null;
            if (Func.isNotEmpty(getResponse)) {
                source = getResponse.source();
            }
            //先根据id查询是否存在该数据
            if (Func.isEmpty(source)) {
                CreateResponse createResponse = esClient.create(e -> e
                        .index(index)
                        .id(String.valueOf(transEsContent.getId()))
                        .document(transEsContent));
                Result result = createResponse.result();
                if (Func.isNotEmpty(result)) {
                    logger.info("【id】：{},es添加数据：{}", transEsContent.getId(), result);
                }
            } else {
                //更新到es服务器中
                UpdateResponse<TransEsContent> updateResponse;
                updateResponse = esClient.update(e -> e
                                .index(index)
                                .id(String.valueOf(transEsContent.getId()))
                                .doc(transEsContent)
                        , TransEsContent.class);
                Result result = updateResponse.result();
                if (Func.isNotEmpty(result)) {
                    logger.info("【id】：{},es更新数据：{}", transEsContent.getId(), result);
                }
            }
        } catch (IOException e) {
            logger.info("【id】：{}未更新到es服务器,es服务器超时，请检查es服务器是否启动，该功能不影响后续代码执行", transEsContent.getId());
        } catch (ElasticsearchException e) {
            logger.info("更新---es服务器未启用，或者版本错误导致");
        }
    }

    /**
     * 异步删除ES服务器中的数据
     */
    public static void asyncDeleteEsTrans(List<TransEsContent> list, ElasticsearchClient esClient, String index) {
        new Thread(() -> {
            try {
                ArrayList<BulkOperation> bulkOperations = new ArrayList<>();
                for (TransEsContent trans : list) {
                    bulkOperations.add(new BulkOperation.Builder()
                            .delete(d -> d
                                    .id(String.valueOf(trans.getId()))
                                    .index(index))
                            .build());
                }
                BulkResponse bulkResponse = esClient.bulk(e -> e.index(index).operations(bulkOperations));
                List<BulkResponseItem> items = bulkResponse.items();
                if (Func.isNotEmpty(items)) {
                    logger.info("【id】:{},调用ES批量删除返回数据:{}", list.get(0).getId(), items);
                }
            } catch (IOException e) {
                logger.info("es服务器超时，【id】：{}未同步到es服务器，请检查es服务器是否启动，该功能不影响后续代码执行。", list.get(0).getId());
            } catch (ElasticsearchException e) {
                logger.info("删除---es服务器未启用，或者版本错误导致");
            }
        }).start();
    }
}

5、测试用例

在这里插入图片描述

	@Value("${elasticsearch.analyzer}")
	private String analyzer;
	@Value("${elasticsearch.index}")
	private String index;
	@Autowired
	private ElasticsearchClient esClient;


  /**
     * 初始化数据
     * @return
  */
	@Override
	public Boolean initEsData() {
		//1、查询索引是否存在
		Boolean whetherTrue = ElasticSearchUtils.whetherIndex(esClient, index);

		if (!whetherTrue) {
			//2、不存在先添加索引在同步数据
			whetherTrue = ElasticSearchUtils.addIndex(esClient, index, analyzer);
		}
		//3、获取需要添加的总数(select count(1) from table where ... )
		Integer transCount =500;

  	//4、用框架自带的分页方法
		Query query = new Query();
  	//4.1、每次查询500
		query.setSize(500);
		long pages = transCount / query.getSize();
		if (transCount % query.getSize() != 0L) {
			++pages;
		}
		for (int i = 1; i <= pages; i++) {
			query.setCurrent(i);
			List<xxxx> transList = baseMapper.selectPage(Condition.getPage(query));
			if (Func.isNotEmpty(transList)) {
				ElasticSearchUtils.addAllEsTransfer(esClient, esTransList, index);
			}
		}
		return whetherTrue;
	}


    /**
     * 分页(细节方面需要自己打磨,这里只是展示如何使用到hanlp)
     * @param transEsSearchVo
     * @return
     */
	@Override
	public EsTransMap selectEsTransPage(TransEsSearchVo transEsSearchVo) {
		StopWatch sw = new StopWatch();
		sw.start();
		int current;
		if (transEsSearchVo.getPageNo() < 1) {
			transEsSearchVo.setPageNo(1);
		}
		if (transEsSearchVo.getPageSize() < 1) {
			transEsSearchVo.setPageSize(10);
		}
		if (transEsSearchVo.getPageNo() == 1) {
			current = transEsSearchVo.getPageNo() - 1;
		} else {
			current = (transEsSearchVo.getPageNo() - 1) * transEsSearchVo.getPageSize();
		}

		//1、过滤关键字的特殊符号
		String regEx="[\n`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。， 、？]";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(transEsSearchVo.getKeyword());
		transEsSearchVo.setKeyword(m.replaceAll("").trim());

    //2、构造过滤请求
		SearchRequest.Builder builder = new SearchRequest.Builder();
		SearchRequest specificContent;

		specificContent = builder
			.index(index)
			.query(q -> q
					.bool(b -> {
						//3、查询关键字(对应字段)
						b.must( t-> t.match(v -> v.field("onlyOneBest").query(FieldValue.of(transEsSearchVo.getKeyword()))));
						return b;
					})
			)
       //4、命中关键字高亮
			.highlight(h ->h.fields("onlyOneBest",f->f.preTags("<font color='red'>").postTags("</font>")))
       //5、排序
			.sort(sort -> sort.field(f->f.field(EsConstant.SORT_FILED_TALK_CREATE_TIME).order(SortOrder.Desc)))
			//从第from开始每次查询size个(第一条数据下标为0)
			.from(current)
			.size(transEsSearchVo.getPageSize())
			.build();

		SearchResponse<TransEsContent> searchResponse;
		EsTransMap esTransMap = new EsTransMap();
		try {
			searchResponse = esClient.search(specificContent, TransEsContent.class);
			List<TransEsContent> transEsList = new ArrayList<>();
            //6、获取高亮部分
			List<Hit<TransEsContent>> hits = searchResponse.hits().hits();

			if (Func.isNotEmpty(hits)) {
				hits.forEach( h -> {
					assert h.source() != null;
      	 //7、处理高亮部分
					transEsList.add(handleContentAndTitle(h.source(),h.highlight()));
				});
			}
			sw.stop();
			esTransMap.setRecords(transEsList);
			esTransMap.setQueryTime(sw.getTotalTimeMillis());
			esTransMap.setTotal(searchResponse.hits().total().value());
		} catch (IOException e) {
			throw new ServiceException("ES服务器未启用，无法使用搜索功能");
		}
		return esTransMap;
	}

以上就是部分代码，如果想更好看实现效果、可以拉下代码到本地跑。

五、拓展内容(部署es服务器)

没有部署es服务器的可以参考下该篇文章 链接: docker-compose部署elasticsearch+hanlp分词器

牧羊人Ovo
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ElasticSearch的学习笔记并整合SpringBoot做测试
weixin_43197640的博客
03-01 485
ElasticSearch的学习 简介 ElasticSearch是一个分布式的开源搜索和分析引擎，MySQL专攻于数据的持久化存储与管理（即CRUD），在真正要处理海量数据的检索与分析时，ElasticSearch是更胜一筹的，可以秒级地从海量数据中检索出需要需要的数据，而MySQL如果单表达到百万以上的数据再进行检索是非常慢的。 ElasticSearch功能有很多，包括各种检索功能（应用程序搜索、网站搜索、企业搜索）、对检索来的数据做处理分析（特别是日志处理和分析）、应用指标的监控、数据的分析和可视化
最新版linux elasticsearch-7.16.2-linux-x86_64.tar.gz
12-20
命令通常为`tar -zxvf elasticsearch-7.16.2.tar.gz`，这会创建一个名为`elasticsearch-7.16.2`的目录。 3. **配置**：进入解压后的目录，如`cd elasticsearch-7.16.2`。你需要编辑`config/elasticsearch.yml`配置...
springboot整合elastic-search完整版代码
07-20
springboot整合elastic-search完整版代码，下载解压后需要在yml配置文件中填上你的elasticsearch安装的地址信息，就可以使用了
Elasticsearch集成HanLP分词器-个人学习
cheqi0010的博客
02-13 339
1、通过git下载分词器代码。 连接如下：https://gitee.com/hualongdata/hanlp-ext hanlp官网如下：http://hanlp.linrunsoft.com/ 2、下载gradle,如果本机有，就可以略过此步骤。通过gradle官方网站下载，...
ElasticSearch工具类 - ESUtils
最新发布
Kurumi
08-01 434
1、引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> <dependency> <groupId>org.elasticsearch.client</gro
Elasticsearch 学习第5篇—elasticsearch与hanlp插件的集成
李小白的博客
09-10 3356
HanLP HanLP是一系列模型与算法组成的NLP工具包，由大快搜索主导并完全开源，目标是普及自然语言处理在生产环境中的应用。HanLP具备功能完善、性能高效、架构清晰、语料时新、可自定义的特点。 根据测试hanlp比ik具有更好的分词效果，因此想使用hanlp作为elasticsearch中的分词插件，接下来介绍hanlp插件和elasticsearch的集成安装过程。 插件安装 ...
Elasticsearch集成HanLP分词器
weixin_33860147的博客
10-08 189
1、通过git下载分词器代码。连接如下：https://gitee.com/hualongdata/hanlp-exthanlp官网如下：http://hanlp.linrunsoft.com/2、下载gradle,如果本机有，就可以略过此步骤。通过gradle官方网站下载，解压，配置环境即可。官方安装配置说明：https://gradle.org/install/3、按本地...
自然语言处理工具包 HanLP在 Spring Boot中的应用
weixin_34000916的博客
10-31 553
本文共 782字，阅读大约需要 2分钟 ！ 概 述 HanLP 是基于 Java开发的 NLP工具包，由一系列模型与算法组成，目标是普及自然语言处理在生产环境中的应用。而且 HanLP具备功能完善、性能高效、架构清晰、语料时新、可自定义的特点，因此十分好上手，本文就结合 Spring Boot来将 HanLP用起来！ 注： 本文首发于 My Personal Blog：CodeSheep...
Elasticsearch（elasticsearch-7.16.2-linux-x86_64.tar.gz)
01-10
Elasticsearch（elasticsearch-7.16.2-linux-x86_64.tar.gz适用于Linux x86_64）是一个高度可扩展的开源全文本搜索和分析引擎。它使您可以快速，近乎实时地存储，搜索和分析大量数据。它通常用作支持具有复杂搜索...
最新版windows elasticsearch-7.16.2-windows-x86_64.zip
12-20
在Windows平台上部署Elasticsearch 7.16.2，可以帮助用户快速构建高性能的数据检索和分析系统。以下是关于这个版本的一些关键知识点： 1. **版本更新**：Elasticsearch 7.16.2是该软件的一个稳定版本，包含了对前一...
最新版linux elasticsearch-7.16.1-linux-x86_64.tar.gz
12-16
在Linux环境下，安装和配置Elasticsearch是IT领域中常见的任务，尤其是在版本7.16.1这样的新版本上。本文将深入探讨Elasticsearch 7.16.1在Linux系统上的安装、配置、使用和优化。 首先，我们需要了解Elasticsearch...
word源码java-datiba:基于springboot的在线答题系统，使用HanLP分词器分词，结合mysql自带的全文搜索功能实现问题
06-05
word源码java 答题吧 介绍 一个基于springboot搭建的项目，项目包括完整的前后台，前台部分功能需要用户登录后才能使用，比如提问、积分兑换、举报等等，前台的问题搜索功能，使用HanLP分词器分词，搭配MySQL自带的全文搜索功能，实现问题的全文搜索，大大提高搜索准确度，提问的时候，可以邀约指定的人员帮助解答，通过邮箱通知被邀约的人员及时帮助解答，自己的提问有人解答后，以邮箱的方式告知自己，如果问题已得到解决或者不想再接收邮箱提醒，可关闭问题，以后的解答就不会再发邮件通知自己。前台的前端框架主要使用了Layui、bootstrap、bootstrap-select、viewer、vue； 软件架构 +---java | \---com | \---dtb | +---admin 后台管理系统相关 | | +---controller 控制器相关类 | | +---dao Mapper的接口类 | | \---service Service接口类 | | \---impl Service接口实现类 | +---common | | \---controller 公共控制器相关
pyhanlp依赖包hanlp-1.7.4-release.zip
09-11
安装pyhanlp后，import pyhanlp时报错：FileNotFoundError:[Errno 2] No such file or director:'D:\\proframData\Anaconda2\envs\py3\lib\site-package\pyhanlp\static\hanlp-1.7.4-release.zip'，网上下载hanlp-1.7.4-release.zip，资源不好一直没下载下来，分享给大家。
最新版linux elasticsearch-7.16.3-linux-x86_64.tar.gz
01-14
最新版linux elasticsearch-7.16.3-linux-x86_64.tar.gz
SpringBoot Hanlp的集成
weixin_44126491的博客
04-04 3081
本小白打算开始搞知识图谱惹，今天第一步打算干掉hanlp，MARK一下步骤怕以后忘了 1. 添加Maven依赖 以下代码块中是此刻的依赖写法，最新的依赖写法可以从hanlp的GitHub的README文件里直接复制： https://github.com/hankcs/HanLP/tree/1.x <!-- hanlp--> <dependency> ...
springboot集成Elasticsearch7.16,使用https方式连接并忽略SSL证书
qq_40310480的博客
09-06 1885
千万万苦利用科学上网找到了，记录一下。
使用HanLP增强Elasticsearch分词功能
chuanmi6070的博客
10-09 121
hanlp-ext 插件源码地址：http://git.oschina.net/hualongdata/hanlp-ext或https://github.com/hualongdata/hanlp-ext Elasticsearch默认对中文分词是按“字”进行分词的，这是肯定不能达到我...
Springboot集成hanlp快速入门demo
HBLOG
04-03 1322
HanLP是一系列模型与算法组成的NLP工具包，目标是普及自然语言处理在生产环境中的应用。HanLP具备功能完善、性能高效、架构清晰、语料时新、可自定义的特点。内部算法经过工业界和学术界考验，配套书籍《自然语言处理入门》已经出版。目前，基于深度学习的HanLP 2.x已正式发布，次世代最先进的NLP技术，支持包括简繁中英日俄法德在内的104种语言上的联合任务。中文分词HMM-Bigram（速度与精度最佳平衡；一百兆内存）最短路分词N-最短路分词由字构词（侧重精度，全世界最大语料库，可识别新词；
spring boot对接hanlp的对接示例（推荐的一种实践方式）
天草二十六
05-06 971
先验证分词” -H “Content-Type:application/json” -d “你是个傻逼还是杂种细胞呢” “http://localhost:8085/hanlp/split”返回结果是：[“你”,“是”,“个”,“傻逼”,“还是”,“杂种细胞”,“呢”证明自定义的单词生效了。再删掉自定义单词再去切割上一句话，则是如下结果再新增自定义单词第三次去验证分词，又和最初一样，证明新增的自定义单词生效。
elasticsearch7.16.2安装
12-24
以下是elasticsearch 7.16.2的安装步骤： 1. 下载elasticsearch安装包： ```shell wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.16.2-linux-x86_64.tar.gz ``` 2. 解压安装包： ```shell tar -zxvf elasticsearch-7.16.2-linux-x86_64.tar.gz ``` 3. 进入elasticsearch目录： ```shell cd elasticsearch-7.16.2 ``` 4. 创建一个新的用户用于运行elasticsearch： ```shell useradd elasticsearch ``` 5. 切换到elasticsearch用户： ```shell su - elasticsearch ``` 6. 修改elasticsearch配置文件`config/elasticsearch.yml`，设置以下参数： ```shell cluster.name: my-elasticsearch-cluster node.name: my-elasticsearch-node network.host: 0.0.0.0 ``` 7. 启动elasticsearch： ```shell ./bin/elasticsearch ``` 8. 验证elasticsearch是否成功启动，可以使用curl命令发送GET请求到elasticsearch的健康检查接口： ```shell curl -X GET http://localhost:9200/_cat/health ``` 以上是elasticsearch 7.16.2的安装步骤。请注意，这只是一个简单的安装示例，实际安装过程可能因操作系统和环境而有所不同。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

牧羊人Ovo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值