elastic search下篇

最新推荐文章于 2022-07-03 09:45:46 发布
最新推荐文章于 2022-07-03 09:45:46 发布
阅读量118 收藏
点赞数
分类专栏： elastic search 文章标签： elasticsearch java es
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43525993/article/details/108804596
版权
1. 今日内容
1.java-client操作ES
2.sde操作ES
一、Java Rest Client

https://www.elastic.co/guide/en/elasticsearch/client/index.html

1.创建项目
		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
            <!-- fastjson-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.58</version>
            </dependency>
            <!--es 高级版本操作坐标-->
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>elasticsearch-rest-high-level-client</artifactId>
                <version>6.8.3</version>
            </dependency>
            <!--es依赖-->
            <dependency>
                <groupId>org.elasticsearch</groupId>
                <artifactId>elasticsearch</artifactId>
                <version>6.8.3</version>
            </dependency>
2. 文档代码操作
#语句
PUT /heima
{
  "mappings": {
    "product": {
      "properties": {
        "id": {
          "type": "keyword"
        },
        "title": {
          "type": "text",
          "analyzer": "ik_max_word"
        },
        "category": {
          "type": "keyword"
        },
        "brand": {
          "type": "keyword"
        },
        "images": {
          "type": "keyword",
          "index": false
        },
        "price": {
          "type": "double"
        }
      }
    }
  }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Product {

    private Long id;

    /**
     * 标题
     */
    private String title;

    /**
     * 分类
     */
    private String category;

    /**
     *    品牌
     */
    private String brand;

    /**
     *  价格
     */
    private Double price;

    /**
     * 图片地址
     */
    private String images;
   
}

Test01

import com.alibaba.fastjson.JSON;
import com.itheima.pojo.Product;
import org.apache.http.HttpHost;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
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.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

/**
 * <dl>
 * <dd>描述: ~ Test01</dd>
 * <dd>创建时间：  10:06 2020/9/25</dd>
 * <dd>创建人： guodong</dd>
 * <dt>版本历史: </dt>
 * <pre>
 * Date         Author         Version     Description
 * ------------------------------------------------------------------
 * 2020/9/25      guodong         1.0        1.0 Version
 * </pre>
 * </dl>
 */
public class Test01 {

    RestHighLevelClient client;

    //1.创建连接
    @Before
    public void initClient(){
         client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")/*,
                        new HttpHost("localhost", 9201, "http")*/));
    }

    /**
     * @Author: guodong 
     * @Date: 10:13 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 新增数据
    */
    @Test
    public void createDoc(){
        //1.创建发送数据---》json(产品json字符串)
        Product product = new Product(1l,"小米手机","手机","小米",2699.00,"http://www.baidu.com");
        String jsonString = JSON.toJSONString(product);
        //2.创建请求对象---》indexRequest指定索引库名称、类型名称、_id（可选）
        IndexRequest indexRequest = new IndexRequest("heima","product","1");
        //3.将数据封装到请求对象中
        indexRequest.source(jsonString, XContentType.JSON);
        //4.发送请求---》client
        try {
            IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);
            //5.打印响应结果
            System.out.println("响应结果： " + indexResponse);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * @Author: guodong 
     * @Date: 10:25 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 根据id查询文档
    */
    @Test
    public void getDocById(){
        //1.创建请求对象---》GetRequest 指定索引库名称、类型名称、_id
        GetRequest getRequest = new GetRequest("heima","product","1");
        //2.发送请求
        try {
            GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
            //3.打印结果
            System.out.println("响应结果： " + getResponse);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * @Author: guodong 
     * @Date: 10:30 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 根据id修改文档
    */
    @Test
    public void updateDocById(){
        //1.创建请求对象--》updateRequest 指定索引库名称、类型名称、_id
        UpdateRequest updateRequest = new UpdateRequest("heima","product","1");
        //2.创建发送数据---》json(产品json字符串)
        Product product = new Product(1l,"大米手机","手机","大米",19999.00,"http://www.baidu.com");
        String jsonString = JSON.toJSONString(product);
        //3.将修改数据添加至请求对象
        updateRequest.doc(jsonString, XContentType.JSON);
        //4.发送请求
        try {
            UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);
            //5.打印结果
            System.out.println("响应结果： " + updateResponse);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * @Author: guodong 
     * @Date: 10:35 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 根据id删除---》作业
    */
    @Test
    public void deleteById(){

    }
    
    /**
     * @Author: guodong 
     * @Date: 10:36 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 批量添加数据
    */
    @Test
    public void batchAddDoc(){
        //1.创建BulkRequest 批处理对象
        BulkRequest bulkRequest = new BulkRequest();
        for (long i = 2; i < 10; i++) {
            //2.创建发送数据---》json(产品json字符串)
            Product product = new Product(i,"小米手机" + i,"手机","小米",2699.00+i,"http://www.baidu.com");
            String jsonString = JSON.toJSONString(product);
            //3.创建请求对象---》indexRequest指定索引库名称、类型名称、_id（可选）
            IndexRequest indexRequest = new IndexRequest("heima","product",i+"");
            //4.将数据封装到请求对象中
            indexRequest.source(jsonString, XContentType.JSON);
            //5.将indexRequest对象封装到BulkRequest
            bulkRequest.add(indexRequest);
        }
        //6.发送请求
        try {
            BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    //2.释放资源
    @After
    public void closeClient(){
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Test02

import org.apache.http.HttpHost;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

/**
 * <dl>
 * <dd>描述: ~ Test01</dd>
 * <dd>创建时间：  10:06 2020/9/25</dd>
 * <dd>创建人： guodong</dd>
 * <dt>版本历史: </dt>
 * <pre>
 * Date         Author         Version     Description
 * ------------------------------------------------------------------
 * 2020/9/25      guodong         1.0        1.0 Version
 * </pre>
 * </dl>
 */
public class Test02 {

    RestHighLevelClient client;

    //1.创建连接
    @Before
    public void initClient(){
         client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")/*,
                        new HttpHost("localhost", 9201, "http")*/));
    }

    /**
     * @Author: guodong 
     * @Date: 11:08 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 根据条件查询
    */
   @Test
   public void matchDoc(){
       //3.创建QueryBuilder，需要使用工厂方法，并且需指定查询的字段和条件
       QueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "小米");
       commonQuery(queryBuilder);
   }

    /**
     * @Author: guodong
     * @Date: 11:19 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 查询所有
     */
    @Test
    public void matchAll(){
        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        commonQuery(queryBuilder);
    }

    /**
    * @Author: guodong 
    * @Date: 11:26 2020/9/25
    * @Parms [queryBuilder]
    * @ReturnType: void
    * @Description: 公共查询方法
   */
    private void commonQuery(QueryBuilder queryBuilder) {
        //1. 创建SearchRequest对象指定索引库名称
        SearchRequest searchRequest = new SearchRequest("heima");
        //2.创建SearchSourceBuilder
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //4.将QueryBuilder对象封装到SearchSourceBuilder
        sourceBuilder.query(queryBuilder);

        /*
            排序：
                1、排序字段
                2、排序规则(默认正排)
         */
        sourceBuilder.sort("id", SortOrder.DESC);

        /*
            分页：
                    from: 起始索引位置 int start = （pageNum - 1）*pageSize
                    size； 页大小
         */
        sourceBuilder.from(4);
            sourceBuilder.size(4);


        /*
            高亮：
                1.前置标签
                2.后置标签
                3.高亮字段
         */
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        //前置标签
        highlightBuilder.preTags("<span color='red'>");
        //后置标签
        highlightBuilder.postTags("<span>");
        //高亮字段
        highlightBuilder.field("title");
        sourceBuilder.highlighter(highlightBuilder);


        /*
            source过滤---》作业
         */

        //5.将SearchSourceBuilder封装到SearchRequest
        searchRequest.source(sourceBuilder);

        try {
            //6.发送请求
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
             //7.解析结果
            SearchHit[] hits = searchResponse.getHits().getHits();
            for (SearchHit hit : hits) {
                String sourceAsString = hit.getSourceAsString();
                System.out.println("查询结果： " + sourceAsString);

                /*
                    高亮结果解析
                 */
                //获取高亮结果
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                //根据高亮字段获取结果
                HighlightField title = highlightFields.get("title");
                //遍历数组
                Text[] fragments = title.getFragments();
                for (Text fragment : fragments) {
                    System.out.println("高亮结果： " + fragment);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //2.释放资源
    @After
    public void closeClient(){
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
三、Spring Date ES
1. 创建项目

步骤：

  1. 创建spring-data-es项目

    • web/lombok/elasticsearch

  2. 修改配置文件

    • 集群名称

    • 节点信息

      spring:
  data:
    elasticsearch:
      cluster-name: elasticsearch #集群名称
      cluster-nodes: 127.0.0.1:9300 #节点端口信息 127.0.0.1:9301,127.0.0.1:9302,127.0.0.1:9303

  3. 创建实体类

    @Data
@AllArgsConstructor
@NoArgsConstructor
//,shards = 5 分片数量，默认值为5(6.X，7.X--->3), replicas = 1副本数量，默认值为1
//indexName: 索引库名称 type： 类型
@Document(indexName = "goods",type = "goods")
public class Goods {

    /*
必须有id,这里的id是全局唯一的标识,等同于es中的“_id”
*/
    @Id
    private Long id;
    /**
     * 标题
     * type: 字段数据类型
     * analyzer: 分词器类型
     * index: 是否索引(默认值：true)
     * store: 是否独立存储(默认值：false)
     */
    @Field(type = FieldType.Text,analyzer = "ik_max_word")
    private String title;
    /**
     * 分类
     */
    @Field(type = FieldType.Keyword)
    private String category;
    /**
     * 品牌
     */
    @Field(type = FieldType.Keyword)
    private String brand;
    /**
     * 价格
     */
    @Field(type = FieldType.Double)
    private Double price;
    /**
     * 图片地址
     */
    @Field(type = FieldType.Keyword,index = false)
    private String images;
}

  4. 创建仓库

    public interface GoodsRepository extends ElasticsearchRepository<Goods, Long> {
}
2. 代码实现

GoodRepository.class

import com.itheima.pojo.Goods;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

import java.util.List;

/**
 * <dl>
 * <dd>描述: ~节点业务逻辑实现</dd>
 * <dd>创建时间：  15:38 2020/7/25</dd>
 * <dd>创建人： zz</dd>
 * <dt>版本历史: </dt>
 * <pre>
 * Date         Author      Version     Description
 * ------------------------------------------------------------------
 * 2020/7/25      guodong       1.0        1.0 Version
 * </pre>
 * </dl>
 */
public interface GoodRepository extends ElasticsearchRepository<Goods,Long> {
	
    List<Goods> findByPriceBetween(Double fromPrice, Double toPrice);
}

application.yml

server:
  port: 8081
spring:
  application:
    name: spring-boot-es
  #配置es连接信息
  data:
    elasticsearch:
      cluster-name: elasticsearch #集群名称
      cluster-nodes: 127.0.0.1:9300 #节点信息 tcp端口
      #192.168.200.128:9301,192.168.200.128:9302,192.168.200.128:9303

以上服务搭建好以后可以直接运行项目，项目在启动时springboot会自动检测当前索引库是否存在，不存在则自动创建

测试类

import com.itheima.pojo.Goods;
import com.itheima.repository.GoodsRepository;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringDataEsApplicationTests {

    @Autowired
    private GoodsRepository goodsRepository;

    /**
     * @Author: guodong 
     * @Date: 12:25 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 新增文档
    */
    @Test
    public void createDoc(){
        //1.准备新增数据
        Goods goods = new Goods(1l,"小米手机","手机","小米", 2699.00, "http://www.baidu.com");
        //2.调用仓库保存
        Goods save = goodsRepository.save(goods);
    }

    /**
     * @Author: guodong
     * @Date: 14:33 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 批量新增
    */
    @Test
    public void batchAddDoc(){
        //1.准备新增数据
        List<Goods> goodsList = new ArrayList<>();
        for (long i = 2; i < 10; i++) {
            Goods goods = new Goods(i,"小米手机" + i,"手机","小米", 2699.00 + i, "http://www.baidu.com");
            goodsList.add(goods);
        }
        //2.调用仓库保存
        Iterable<Goods> goods = goodsRepository.saveAll(goodsList);
        for (Goods good : goods) {
            System.out.println("批量新增结果： " + good);
        }
    }
    
    /**
     * @Author: guodong 
     * @Date: 14:39 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 根据id查询
    */
    @Test
    public void queryById(){
        Optional<Goods> optional = goodsRepository.findById(1l);
        //Iterable<Goods> all = goodsRepository.findAll(); //作业findAll
        if(optional.isPresent()){ //true--->表示查询结果有值
            Goods goods = optional.get();
            System.out.println("查询结果： " + goods);
        }
    }
    
    /**
     * @Author: guodong 
     * @Date: 14:43 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 使用queryBuilder
    */
    @Test
    public void queryBuilder(){
        QueryBuilder queryBuilder = QueryBuilders.termQuery("title", "小米");
        Iterable<Goods> search = goodsRepository.search(queryBuilder);
        for (Goods goods : search) {
            System.out.println("查询结果：" + goods);
        }
    }

    /**
     * @Author: guodong 
     * @Date: 14:55 2020/9/25
     * @Parms []
     * @ReturnType: void
     * @Description: 自定义查询(了解)
     *
     * 格式：
     *  findBy + 字段名称 + 关键字(And or between ....) + 字段名称 (参数列表)
     *  参数列表需要注意必须与字段名顺序一致
     *
     *  between： 范围查询包含首位。
    */
    @Test
    public void findByPrice(){
        List<Goods> byPriceBetween = goodsRepository.findByPriceBetween(2699.00, 2703.00);
        for (Goods goods : byPriceBetween) {
            System.out.println("查询结果" + goods);
        }
    }

}
娃娃 哈哈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python elasticsearch环境搭建详解
09-18
在本篇文章里小编给大家整理的是关于python elasticsearch环境搭建的相关知识点内容，有需要的朋友们可以参考下。
【ElasticSearch实战】——封装java操作es基础架构
热门推荐
Jack 架构师之路
12-31 17万+
创建ES专栏很久了，但是写的文章非常的少，实在是项目比较忙，2018年最后一天了也该总结一下对es的封装的东西了，这篇博客我们通过java对es批量插入为主流程，来介绍一下java对接es 的全部过程； 需求处理流程：  从mysql中插入手机号7位所有的组合，然后通过程序处理补充后四位所有的可能，然后组成一个庞大的手机号码库，然后在讲手机号加密，为其他的应用提供 手机号明密文转换服务； 1...
ES学习记录3——ES中Search接口
jacksonary的博客
09-27 9486
5. 搜索  ES提供了2中搜索方式： REST风格的请求URI，直接将参数带过去； 封装到request body中，这种方式可以定义更加易读的JSON格式；  通过REST风格URI搜索的案例如下： curl -X GET &amp;amp;quot;localhost:9200/bank/_search?q=*&amp;amp;amp;amp;sort=account_number:asc&amp;amp;amp;amp;pretty&amp;amp;quot;
《Spring Boot 实战派》--13.集成NoSQL数据库，实现Elasticsearch和Solr搜索引擎
tumu6889的博客
05-28 1624
第13章 集成NoSQL数据库，实现Elasticsearch和Solr搜索引擎 关于搜索引擎 我们很难实现 Elasticseach 和 Solr两大搜索框架的效果； 所以本章针对两大搜索框架，非常详细地讲解 它们的原理和具体使用方法， 首先介绍什么是搜索引擎 、如何用 MySQL实现简单的搜索引擎，以及Elasticseach 的 概念和 接口类； 然后介绍Elasticseach精准、模糊、范围、组合、分页、聚合查询； 最后介绍 Solr的概念、安装、配置和使用，并对两大搜索框架进行比较。..
spring boot动态获取@Document中的indexName
weixin_42889142的博客
08-30 1万+
spring boot动态获取@Document中的indexName 本身是这样的 @Document(indexName = "xxx", type = "xxx", shards = 1,replicas = 0, refreshInterval = "-1") 但是这样是固定值，不可动态更改 后来改成这样 @Document(indexName = "#{@indexName}", ty...
spring.data.elasticsearch.cluster-nodes、cluster-name过时
weixin_43871142的博客
07-24 1万+
这个在高版本中已经废弃，官方建议我们使用：High Level REST Client @Configuration public class ElasticsearchConfig { /** * localhost:9300 写在配置文件中就可以了 */ @Bean RestHighLevelClient elasticsearchClient() { ClientConfiguration configuration = ClientCo
Elasticsearch顶尖高手系列（两套）
10-11
Elasticsearch顶尖高手系列（两套） 【中华石杉】Elasticsearch顶尖高手系列-高手进阶篇（87个视频 + 资料） 【中华石杉】Elasticsearch顶尖高手系列课程-核心知识篇（74个视频 + 资料）
PHP ElasticSearch做搜索实例讲解
10-15
在本篇文章里小编给大家整理了关于PHP基于ElasticSearch做搜索的相关知识点，需要的朋友们可以参考下。
Python 操作 ElasticSearch的完整代码
09-18
python提供了操作ElasticSearch 接口，因此要用python来操作ElasticSearch，这篇文章主要介绍了Python 操作 ElasticSearch,需要的朋友可以参考下
详解Docker下使用Elasticsearch可视化Kibana
09-30
本篇文章主要介绍了详解Docker下使用Elasticsearch可视化Kibana，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Elastic search入门到集群实战操作详解(原生API操作、springboot整合操作)-step2
qq_45441466的博客
09-05 1175
上一篇详细讲解了使用kibana RestFul风格操作es，接下来就是ES集群、操作原生API 以及SpringDataElasticsearch https://blog.csdn.net/qq_45441466/article/details/120110968 1.Elasticsearch集群 单点的elasticsearch存在哪些可能出现的问题呢？ 单台机器存储容量有限，无法实现高存储 单服务器容易出现单点故障，无法实现高可用 单服务的并发处理能力有限，无法实现高并发 所以，为
记录使用spring-data-elasticsearch过程中遇到的问题。增加通用自定义接口
woyyazj的博客
05-18 462
公司有业务需求APP端坐标需要不停的上传，根据业务量，每个月可能会产生大概20G的数据，现有的解决方案是直接存储在oracle中根据每月进行分表存储。但是不可避免的随着时间的拉长，处理起来越来越不方便，于是便想到了使用es来存储，后面查询时也比较方便。 为了让操作方式与以前存储保持一致，保持增删查改分页查询等的需求。直接使用的spring-data-elasticsearch，只要继承ElasticsearchRepository，就可以实现简单的CURD操作，因为p...
springboot整合elasticsearch
qq_15901351的博客
01-05 475
一、ES简介 ElasticSearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多员工能力的全文搜索引擎，基于 RESTful web 接口。Elasticsearch 是用 Java 语言开发的，并作为 Apache 许可条款下的开放源码发布，是一种流行的企业级搜索引擎。 ElasticSearch 用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。 特点： 分布式的文档存储引擎 分布式的搜索引擎和分析引擎 分布式，支持PB级数据 使用场景： 搜索领域： 如百度、谷歌
动态的为ElasticSearch的@Document指定index
蜀山小师叔
06-23 2万+
前言 由于项目定义了配置中心，分了开发库，测试库，预生产，每次发布都需要改项目中所定义的常量，希望动态为Document指定IndexName，找了好久，终于找到。 第一种，直接定义一个实体类 @Value("${etrali.indexname}") private String indexName; @Bean public String indexName(){ retur...
初识ElasticSearch的使用
袁小懒
05-29 704
一 . 基本概念 1.介绍 Elasticsearch 是一个分布式可扩展的实时搜索和分析引擎,一个建立在全文搜索引擎 Apache Lucene(TM) 基础上的搜索引擎 2.主要作用 分布式实时文件存储，并将每一个字段都编入索引，使其可以被搜索。 实时分析的分布式搜索引擎。 可以扩展到上百台服务器，处理PB级别的结构化或非结构化数据。 3.理解模型图 Elastics...
spring boot 集成 elasticsearch cr(u)d 、分页聚合查询
qq_39504520的博客
06-24 513
文章目录1 添加maven依赖2. 在yml文件中增加配置3. spring elasticsearch具体使用 1 添加maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
Spring Boot Elasticsearch 入门
weixin_42073629的博客
04-28 452
1. 概述 如果胖友之前有用过 Elasticsearch 的话，可能有过被使用的 Elasticsearch 客户端版本搞死搞活。如果有，那么一起握个抓。所以，我们在文章的开始，先一起理一理这块。 Elasticsearch（ES）提供了两种连接方式： transport ：通过 TCP 方式访问 ES 。 对应的库是org.elasticsearch.client.tran...
ElasticSearch（八）关于document的一些知识点
weixin_30256505的博客
01-17 265
先查看一条数据： GET /ecommerce/product/5 { "_index" : "ecommerce", "_type" : "product", "_id" : "5", "_version" : 1, "found" : true, "_source" : { "name" : "gaolujie yagao2", ...
spring data elasticsearch：复杂查询指南
55555的博客
07-03 2191
因为es非关系型数据库的特性，我们常常需要在实际业务中实现复杂查询，从而来查询到我们想要的数据。很多同学刚接触java client不知道如何实现各类复杂查询操作。今天我们就来讲讲一些常见的复杂查询如何实现下文演示基于如下环境 开始讲解之前，先声明我们的索引结构，方便大家后续理解我们的案例 测试数据，供大家跟练 如果不知道springboot如何整合spring-data-elasticsearch的，可以参考我之前的文章从零搭建springboot+spring data elasticsearch4.2
elasticsearch入门篇
最新发布
11-03
ElasticSearch是一个基于Lucene的搜索服务器，它提供了一个分布式、多租户的全文搜索引擎，具有RESTful Web接口和基于JSON的查询语言。下面是elasticsearch入门的几个步骤： 1.安装ElasticSearch：可以通过官网下载...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

娃娃 哈哈

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

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

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

打赏作者

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

抵扣说明：

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

余额充值