Elsaticsearch java基本操作

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量722 收藏 9
点赞数 12
文章标签： java 开发语言 elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62383709/article/details/140399073
版权
索引 基本操作
package com.orchids.elasticsearch.web.controller;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.json.JSONUtil;
import com.orchids.elasticsearch.web.po.User;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
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.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.elasticsearch.cluster.metadata.MappingMetadata;
import org.elasticsearch.common.xcontent.XContentType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

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

/**
 * @ Author qwh
 * @ Date 2024/7/12 19:18
 */
@Slf4j
@Api(tags = "索引")
@RestController
@RequestMapping("/elastic/index")
@RequiredArgsConstructor
public class ElasticIndexController {
    private final RestHighLevelClient client;
    static final String MAPPING_TEMPLATE = "{\n" +
    "  \"mappings\": {\n" +
    "    \"properties\": {\n" +
    "      \"name\":{\n" +
    "        \"type\": \"text\",\n" +
    "        \"analyzer\": \"ik_max_word\"\n" +
    "      },\n" +
    "      \"age\":{\n" +
    "        \"type\": \"integer\"\n" +
    "      },\n" +
    "      \"sex\":{\n" +
    "        \"type\": \"text\"\n" +
    "      }\n" +
    "    }\n" +
    "  }\n" +
    "}";
    @ApiOperation("添加索引")
    @PostMapping("/add")
    public String CreateIndex(@RequestParam("index") String index) throws IOException {
        CreateIndexRequest request = new CreateIndexRequest(index);
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        log.error("response{}",response);
        if (response!=null){
            return "add index success";
        }else {
            return "add index fail";
        }
    }
    @ApiOperation("获取索引")
    @GetMapping("/get")
    public Map<String, Object> GetIndex(@RequestParam("index") String index) throws IOException {
        //创建请求对象
        GetIndexRequest request = new GetIndexRequest(index);
        //发送请求
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        // todo 健壮性
        if (client.indices().exists(request,RequestOptions.DEFAULT)){
            MappingMetadata data = response.getMappings().get(index);
            return data.getSourceAsMap();
        }else {
            return null;
        }
    }
    /**
     * 查看指定索引的映射信息。
     * <p>
     * 通过该接口，可以获取Elasticsearch中指定索引的映射设置。映射（Mapping）定义了字段的类型和分析器等配置，
     * 对于查询和分析数据至关重要。此方法接收一个索引名称作为参数，返回该索引的映射配置。
     *
     * @param index 指定的索引名称，用于获取该索引的映射信息。
     * @return 包含指定索引映射配置的Map对象。
     * @throws IOException 如果获取映射信息时发生I/O错误。
     */
    @ApiOperation("查看映射")
    @GetMapping("/mapper")
    public Map<String, Object> Index(@RequestParam("index") String index) throws IOException {
        // todo 健壮性
        // 创建GetIndexRequest对象，指定要获取映射信息的索引。
        GetIndexRequest request = new GetIndexRequest(index);
        // 执行请求，获取索引的映射响应。
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        // 从响应中提取映射配置。
        Map<String, MappingMetadata> mappings = response.getMappings();
        // 获取指定索引的映射元数据。
        MappingMetadata metadata = mappings.get(index);
        // 从映射元数据中提取源映射配置。
        Map<String, Object> source = metadata.getSourceAsMap();
        // 返回源映射配置。
        return source;
    }
    @ApiOperation("删除索引")
    @DeleteMapping("/del")
    public String  DeleteIndex(@RequestParam("index") String index) throws IOException {
        //创建请求对象
        DeleteIndexRequest request = new DeleteIndexRequest(index);
        //发送请求
        return client.indices().delete(request, RequestOptions.DEFAULT)!=null ? index+"删除成功" : index+"删除失败";
    }

}
文档
package com.orchids.elasticsearch.web.controller;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.orchids.elasticsearch.web.po.User;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.ElasticsearchStatusException;
import org.elasticsearch.action.bulk.BulkRequest;
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.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.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.springframework.web.bind.annotation.*;

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

/**
 * @ Author qwh
 * @ Date 2024/7/12 21:31
 */
@Slf4j
@Api(tags = "文档")
@RestController
@RequestMapping("/elastic/doc")
@RequiredArgsConstructor
public class ElasticDocumentController {
    private final RestHighLevelClient client;
    @ApiOperation("添加文档")
    @PostMapping("/add")
    public String addDocument(@RequestParam("index") String index, @RequestBody User user) throws IOException {
        if (user==null) {
            throw new RuntimeException("非法参数");
        }
        String jsonUser = JSONUtil.toJsonStr(user);
        System.out.println(jsonUser);
        //准备请求对象
        IndexRequest request = new IndexRequest(index).id(user.getName());
        //准备json文档
        request.source(jsonUser, XContentType.JSON);
        //发送请求 put
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        if (response!=null){
            return "success";
        }else {
            return "fail";
        }
    }
    @ApiOperation("获取文档")
    @GetMapping("/get")
    public User getDocument(@RequestParam("id") String id,@RequestParam("index") String index) throws IOException {
        //准备请求对象 参数:索引库 文档id
        GetRequest request = new GetRequest(index).id(id);
        //发送请求 得到json格式响应
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        String jsonBean = response.getSourceAsString();
        log.error("响应response{}",jsonBean);
        User bean = JSONUtil.toBean(jsonBean, User.class);
        System.out.println(bean);
        return bean;
    }
    @ApiOperation("所有文档")
    @GetMapping("/all")
    public List<User> allDocument(@RequestParam String index) throws IOException {
        //准备请求对象 参数索引
        SearchRequest request = new SearchRequest(index);
        //请求参数
        request.source().query(QueryBuilders.matchAllQuery());
        //发送请求 并返回响应
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //解析响应
        return handleResponse(response);
    }

    private List<User> handleResponse(SearchResponse response) {
        SearchHits searchHits = response.getHits();
        //获取总条数
        long total = searchHits.getTotalHits().value;
        log.error("一共搜索到{}条数据",total);
        //遍历数组
        SearchHit[] hits = searchHits.getHits();
        List<User> users = new LinkedList<>();
        for (SearchHit hit : hits) {
            //得到每一个数组的_source 原始的json文档
            String source = hit.getSourceAsString();
            log.error("原始的json格式{}",source);
            //反序列化
            User user = JSONUtil.toBean(source, User.class);
            log.error("放序列化后json格式{}",user);
            users.add(user);
        }
        return users;
    }

    @ApiOperation("删除文档")
    @DeleteMapping("/del")
    public String updateDocument(@RequestParam("index") String index,@RequestParam("id")String id) throws IOException {
        //request
        DeleteRequest request = new DeleteRequest(index,id);
        //修改内容
        DeleteResponse delete = client.delete(request, RequestOptions.DEFAULT);
        if (delete!=null){
            return "success";
        }else {
            return "fail";
        }
    }
    @ApiOperation("修改文档")
    @PostMapping("/update")
   public String updateDocument(@RequestParam("index") String index,@RequestBody User user) throws IOException {
        if (user.getName()==null) {
            return "id参数非法";
        }
        //request
        UpdateRequest request = new UpdateRequest(index,user.getName());
        //修改内容
        request.doc("name",user.getName(),"age",user.getAge(),"sex",user.getSex());
        //发送请求
        //当es中没有对应的id 添加该id

        try {
            //修改
            client.update(request, RequestOptions.DEFAULT);
        } catch (ElasticsearchStatusException e) {
            //添加
            String jsonUser = JSONUtil.toJsonStr(user);
            System.out.println(jsonUser);
            //准备请求对象
            IndexRequest req = new IndexRequest(index).id(user.getName());
            //准备json文档
            req.source(jsonUser, XContentType.JSON);
            //添加
            client.index(req,RequestOptions.DEFAULT);
        }
        return "修改成功";
    }
    @ApiOperation("批量添加")
    @PutMapping("/adds")
    public String LoadDocument() throws IOException {
        return "todo";
//        int current = 1;
//        int size = 100;
//        while (true){
//            Page<User> page = new Page<>(current, size);
//            List<User> users = page.getRecords();
//            if (CollUtil.isEmpty(users)) {
//                return null;
//            }
//            log.info("加载第{}页数据共{}条", current, users.size());
//            //创建request
//            BulkRequest request = new BulkRequest("user");
//            //准备参数
//            for (User user : users) {
//
//    /*            IndexRequest indexRequest = new IndexRequest().id(user.getName());
//                indexRequest.source(JSONUtil.toJsonStr(user),XContentType.JSON);
//                request.add(indexRequest);*/
//
//                request.add(new IndexRequest().id(user.getName()).source(JSONUtil.toJsonStr(user), XContentType.JSON));
//            }
//            client.bulk(request, RequestOptions.DEFAULT);
//            current++;
//        }
    }
}
Java client
package com.orchids.elasticsearch.web.controller;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.json.JSONUtil;
import com.orchids.elasticsearch.web.po.User;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
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.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.web.bind.annotation.*;

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

/**
 * @ Author qwh
 * @ Date 2024/7/12 21:48
 */
@Slf4j
@Api(tags = "Restapi")
@RestController
@RequestMapping("/elastic/rest")
@RequiredArgsConstructor
public class ElasticRestController {
    private final RestHighLevelClient client;
//    @GetMapping()
    public void testAgg() throws IOException {
        // 1.创建Request
        SearchRequest request = new SearchRequest("items");
        // 2.准备请求参数
        BoolQueryBuilder bool = QueryBuilders.boolQuery()
                .filter(QueryBuilders.termQuery("category", "手机"))
                .filter(QueryBuilders.rangeQuery("price").gte(300000));
        request.source().query(bool).size(0);
        // 3.聚合参数
        request.source().aggregation(
                AggregationBuilders.terms("brand_agg").field("brand").size(5)
        );
        // 4.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 5.解析聚合结果
        Aggregations aggregations = response.getAggregations();
        // 5.1.获取品牌聚合
        Terms brandTerms = aggregations.get("brand_agg");
        // 5.2.获取聚合中的桶
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        // 5.3.遍历桶内数据
        for (Terms.Bucket bucket : buckets) {
            // 5.4.获取桶内key
            String brand = bucket.getKeyAsString();
            System.out.print("brand = " + brand);
            long count = bucket.getDocCount();
            System.out.println("; count = " + count);
        }
    }
    @ApiOperation("高亮查询")
    @GetMapping("/high") //high ok
    public List<User> HighlightQuery(
            @ApiParam(name = "index",value = "索引",required = true) @RequestParam("index")String index,
            @ApiParam(name = "high",value = "高亮条件",required = true)@RequestParam("high") String high ) throws IOException {
        // 1.创建Request
        SearchRequest request = new SearchRequest(index);
        // 2.组织请求参数
        // 2.1.query条件
        request.source().query(QueryBuilders.matchQuery("name", high));
        // 2.2.高亮条件
        request.source().highlighter(
                SearchSourceBuilder.highlight()
                        .field("name")
                        .preTags("<em>")
                        .postTags("</em>")
        );
        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        return hand(response);
    }
    private List<User> hand(SearchResponse response) {
        SearchHits searchHits = response.getHits();
        // 1.获取总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("共搜索到" + total + "条数据");
        // 2.遍历结果数组
        SearchHit[] hits = searchHits.getHits();
        List<User> result = new LinkedList<>();
        for (SearchHit hit : hits) {
            // 3.得到_source，也就是原始json文档
            String source = hit.getSourceAsString();
            // 4.反序列化
            User user = JSONUtil.toBean(source, User.class);
            // 5.获取高亮结果
            Map<String, HighlightField> hfs = hit.getHighlightFields();
            if (CollUtil.isNotEmpty(hfs)) {
                // 5.1.有高亮结果，获取name的高亮结果
                HighlightField hf = hfs.get("name");
                if (hf != null) {
                    // 5.2.获取第一个高亮结果片段，就是商品名称的高亮值
                    String hfName = hf.getFragments()[0].string();
                    user.setName(hfName);
                }
            }
            result.add(user);
        }
        return result;
    }
    @ApiOperation("分页查询")
    @GetMapping("/page")
    public List <User> pageQuery(
            @ApiParam(value = "索引",required = true)@RequestParam("index")String index,
            @ApiParam(value = "字段条件",required = true)@RequestParam("field") String field,
            @ApiParam(value = "当前页",required = true)@RequestParam("current")String current,
            @ApiParam(value = "页大小",required = true)@RequestParam("size")String size) throws IOException {

        // 1.创建Request
        SearchRequest request = new SearchRequest(index);
        // 2.组织请求参数
        // 2.1.搜索条件参数
        request.source().query(QueryBuilders.matchQuery("name", field));
        // 2.2.排序参数
        request.source().sort("age", SortOrder.ASC);
        // 2.3.分页参数
        request.source().from((Integer.valueOf(current) - 1) * Integer.valueOf(size)).size(Integer.valueOf(size));
        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        return handleResponse(response);

    }
    private List <User> handleResponse(SearchResponse response) {
        SearchHits searchHits = response.getHits();
        // 1.获取总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("共搜索到" + total + "条数据");
        // 2.遍历结果数组
        SearchHit[] hits = searchHits.getHits();
        List<User> result = new LinkedList<>();
        for (SearchHit hit : hits) {
            // 3.得到_source，也就是原始json文档
            String source = hit.getSourceAsString();
            // 4.反序列化并打印
            User user = JSONUtil.toBean(source, User.class);
            result.add(user);
        }
        return result;
    }
    @ApiOperation("复合条件")
    @GetMapping("/compare")
    public List<User> compareQuery(
            @ApiParam(value = "索引",required = true)@RequestParam("index") String index,
            @ApiParam(value = "名称",required = true)@RequestParam ("name")String name,
            @ApiParam(value = "性别",required = true)@RequestParam("sex") String sex,
            @ApiParam(value = "年龄",required = true)@RequestParam("age") String age)throws IOException {
        // 1.创建Request
        SearchRequest request = new SearchRequest(index);
        // 2.组织请求参数
        // 2.1.准备bool查询
        BoolQueryBuilder bool = QueryBuilders.boolQuery();
        // 2.2.关键字搜索
        if (name!=null){
            bool.must(QueryBuilders.matchQuery("name", name));
        }
        if (sex!=null){
            // 2.3.品牌过滤
            bool.filter(QueryBuilders.termQuery("sex", sex));
        }
        // 2.4.价格过滤  gt >
        if (age!=null){
            bool.filter(QueryBuilders.rangeQuery("age").gt(age));
        }
        request.source().query(bool);
        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        return handleResponse(response);
    }
    @ApiOperation("区间查询")
    @GetMapping("/term")//term
    public List<User> rangeQuery(
            @ApiParam(value = "索引",required = true)@RequestParam String index,
            @ApiParam(value = "左区间",required = true)@RequestParam("gt") String gt,
            @ApiParam(value = "右区间",required = true)@RequestParam("lt") String lt,
            @ApiParam(value = "支持排序的字段",required = true)@RequestParam("field") String field) throws IOException {
        //创建request
        SearchRequest request = new SearchRequest(index);
        //请求参数
        //todo 健壮性
        request.source().query(QueryBuilders.rangeQuery(field).gte(gt).lte(lt));
        //解析相应
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
       return handleResponse(response);
    }
    @ApiOperation("多条件查询")
    @GetMapping("/multi_match")//multi_match todo 待探讨
    public List<User> multi_matchQuery(@ApiParam(value = "包含条件1" ,required = true)@RequestParam("name1") String args1,
                                       @ApiParam(value = "包含条件2",required = true)@RequestParam("name2") String args2) throws IOException {
        //创建request
        SearchRequest request = new SearchRequest("user");
        //请求参数
        request.source().query(QueryBuilders.multiMatchQuery("name",args1,args2));
        //解析相应
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        return handleResponse(response);
    }
    @ApiOperation("match查询")
    @GetMapping("/match")//match ok
    public List<User> matchQuery(
            @ApiParam(value = "索引",name = "index",required = true) @RequestParam("index")String index,
            @ApiParam(value ="匹配字段",name = "field",required = true)@RequestParam("field") String field) throws IOException {
        //创建request
        SearchRequest request = new SearchRequest(index);
        //请求参数
        request.source().query(QueryBuilders.matchQuery("name",field));
        //解析相应
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        return handleResponse(response);
    }
    @ApiOperation("match-all查询")
    @GetMapping("/match-all")//match-all ok
    public List<User> SearchMatchAll(@ApiParam(value = "索引",name = "index",required = true) @RequestParam("index")String index) throws IOException {
        //创建request
        SearchRequest request = new SearchRequest(index);
        //请求参数
        request.source().query(QueryBuilders.matchAllQuery());
        //解析相应
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        return handleResponse(response);
    }
}
Bean
package com.orchids.elasticsearch.web.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;

/**
 * @ Author qwh
 * @ Date 2024/7/12 21:16
 */
@Configuration
public class RestClientConfiguration {
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        return new RestHighLevelClient(RestClient.builder(HttpHost.create("http://localhost:9200")));
    }
}
po
package com.orchids.elasticsearch.web.po;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import java.io.Serializable;

/**
 * @ Author qwh
 * @ Date 2024/7/12 20:20
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@ApiModel(description = "索引库实体")
public class User implements Serializable {
    @ApiModelProperty(value = "名字",name = "name",example = "二哈")
//    @NonNull
    private String name;
//    @NonNull
    @ApiModelProperty(value = "年龄",name = "age",example = "99")
    private Integer age;
//    @NonNull
    @ApiModelProperty(value = "性别",name = "sex",example = "男")
    private String sex;

}
app
package com.orchids.elasticsearch;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class ElasticsearchApplication {

    public static void main(String[] args) {
        SpringApplication.run(ElasticsearchApplication.class, args);
    }

}
配置类

server:
  port: 8080
logging:
  level:
    web: info
  pattern:
    dateformat: HH:mm:ss:SSS
  file:
    path: "logs"
knife4j:
  enable: true
  openapi:
    title: 接口文档
    description: "接口文档"
    email: 123123i@123.cn
    concat: erha
    url: https://www.orchids.love
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources: com.orchids.elasticsearch.web
依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.orchids</groupId>
  <artifactId>elasticsearch</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>elasticsearch</name>
  <description>elasticsearch</description>
  <properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.12.1</elasticsearch.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring-boot.version>2.7.12</spring-boot.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.elasticsearch</groupId>
      <artifactId>elasticsearch</artifactId>
      <version>${elasticsearch.version}</version>
    </dependency>
    <dependency>
      <groupId>org.elasticsearch.client</groupId>
      <artifactId>elasticsearch-rest-client</artifactId>
      <version>${elasticsearch.version}</version>
    </dependency>
    <dependency>
      <groupId>org.elasticsearch.client</groupId>
      <artifactId>elasticsearch-rest-high-level-client</artifactId>
      <version>${elasticsearch.version}</version>
    </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>
    </dependency>
    <dependency>
      <groupId>com.github.xiaoymin</groupId>
      <artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
      <version>4.1.0</version>
    </dependency>
    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-json</artifactId>
      <version>5.8.28</version>
    </dependency>
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.5.6</version>
    </dependency>
  </dependencies>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring-boot.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.orchids.elasticsearch.ElasticsearchApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
一橘Java小菜鸟
关注
【二十】springboot整合ElasticSearch实战（万字篇）
weixin_56995925的博客
04-01 1万+
学习springboot整合ElasticSearch7.X版本，实现小案例，springboot整合ElasticSearch实战（万字篇）
JAVA ik es_Elasticsearch入门和查询语法分析（ik中文分词）
weixin_30882521的博客
02-23 1072
全文搜索现在已经是很常见的功能了，当然你也可以用mysql加Sphinx实现。但开源的Elasticsearch(简称ES)目前是全文搜索引擎的首选。目前像GitHub、维基百科都使用的是ES，它可以快速的存储，搜索和分析数据。一、安装与启动ES的运行需要依赖java环境，可以在命令行运行java --version。如果出现说明已经安装了，否则你就需要安装下java环境。然后我们就可以开始装...
springboot集成Elasticsearch实现各种搜索功能
热门推荐
wangxudongx的专栏
02-14 9万+
环境准备： Elasticsearch服务器 ik中文分词器 Kibana服务 一个集成了ES的springboot项目 博主环境： es:6.2.2 Kibana:6.2.2 springboot:2.1.2 实现目标：建立学生数据索引，以学生姓名为搜索自动补全字段。 学生实体类： @Document(indexName = &quot;student_index&quot;,type=&quot;student&quot;) p...
es java 指定ik smart_Elasticsearch——04全文搜索服务器_ES集成ik分词器&类型文档映射...
weixin_42355387的博客
02-27 936
1.ES集成ik分词器lucene由于是jar工具包,如果要在使用lucene的环境下使用ik分词器,只需导入对应jar,做一些配置就行.以插件的方式集成ES服务器,客户端只需告诉我们某个字段要用这个分词器就行了。步骤:①服务端安装ik插件②客户端端指定字段用插件安装：2)maven打包：mvn package3)安装到es服务器解压到es/plugins4)配置5)重启测试：#测试ik分词器PO...
elasticSearch之java客户端开发，demo演示
我的兔子丢了的博客
07-27 1165
使用java操作es集群很简单，只需要在pom文件里引入es客户端的依赖即可，如下： <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</art...
Elasticsearch：使用最新的 Elasticsearch Java client 8.0 来创建索引并搜索
Elastic 中国社区官方博客
03-30 1万+
这篇文章，我来详细地描述如何使用最新的 Elasticsearch Java client 8.0 来创建索引并进行搜索。最新的 Elasticsearch Java client API 和之前的不同。在之前的一些教程中，我们使用 High Level API来进行操作。在官方文档中，已经显示为 deprecated。 前提条件 Java 8 及以后的版本 一个 JSON 对象映射库，允许你的应用程序类与 Elasticsearch API 无缝集成。 Java 客户端支持 Jackson 或像
从零学Elasticsearch系列——JAVA API操作
高興
01-09 6844
参考资料：https://spring.io/projects/spring-data-elasticsearch#overview 测试代码GitHub地址： 查询方式 Restful API 基于http协议，使用JSON为数据交换格式，通过9200端口的与Elasticsearch进行通信，您可使用HttpClient类库通过9200端口操作Elasticsearch。 JAVA A...
Elasticsearch基本概念
chwensrong的博客
03-09 4万+
本文主要是对ES基本概念进行整合，理论先行，夯实对ES的基本概念，在知道“是什么”，才能提高学习效率，保姆级学习教程请移步： ES入门笔记. 一、前文介绍 Elasticsearch（简称ES）是一个基于Apache Lucene™的开源搜索引擎，无论在开源还是专有领域，Lucene 可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。注意，Lucene 只是一个库。想要发挥其强大的作用，你需使用 Java 并要将其集成到你的应用中。 Lucene 非常复杂，你需要深入的了解检索相关知识来理解它
SpringBoot整合Elasticsearch详细步骤以及代码示例（附源码）
hys8298的博客
09-27 289
准备工作# 环境准备# JAVA版本 Copy java version "1.8.0_121" Java(TM) SE Runtime Environment (build 1.8.0_121-b13) Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode) ES版本 Copy { "na...
elsaticsearch-all-7.6.2.zip
06-28
Elasticsearch 7.6.2 是一个强大的开源搜索引擎和分析引擎，它是ELK（Elasticsearch、Logstash、Kibana）堆栈的核心组成部分。这个版本包含了完整的Elasticsearch、Kibana以及Logstash，这三者共同构成了数据收集、...
使用Java transportclient API 操作Elasticsearch-6.8.4
qq_37114789的博客
05-04 1359
使用Java操作Elasticsearch-6.8.4 1. 确定elasticsearch是否已经在本机运行 在浏览器中输入http://localhost:9200/查看elasticsearch是否成功运行 如果出现如上图结果，则说明elasticsearch成功运行在本机，如果 ...
SpringBoot ElasticSearch常用API
chuang777的博客
02-20 968
ElasticSearch常用APIElasticSearch常用API
【ES】Elasticsearch Java Rest Client （Document APIs）官方文档中文翻译
qq_44667083的博客
04-18 1929
这里写目录标题一、文档APIs1.单文档 APIIndex APIGet APIGet Source APIExists APIDelete APIUpdate APITerm Vectors API2.多文档 APIBulk APIMulti-Get APIReindex APIUpdate By Query APIDelete By Query APIRethrottle APIMulti Term Vectors API 官网连接 一、文档APIs Java 高级 REST 客户端支持以下文档 A
Java-网络
最新发布
2301_81543552的博客
09-14 443
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 485
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 599
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 796
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
elsaticsearch bucket_script
06-08
script参数指定计算指标的脚本，可以使用Java语言表达式或Painless脚本语言编写。 例如，以下是一个计算两个聚合桶中最小值的bucket_script示例： ``` { "aggs": { "sales_by_month": { "date_histogram": { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值