ES学习

最新推荐文章于 2022-12-01 19:30:00 发布
最新推荐文章于 2022-12-01 19:30:00 发布
阅读量146 收藏
点赞数 1
分类专栏： 笔记 文章标签： elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44100744/article/details/108569518
版权

ES学习

ES安装

jdk必须是1.8或以上

ES是基于java开发的 java核心的jar包必须一致

ES默认端口：9200

head默认端口：9300

kibana默认端口：5601

1.启动

cnpm install
npm run start

设置跨域:

http.cors.enabled: true
http.cors.allow-origin: "*"

ik分词器

ik_smart和ik_max_word,ik_smart是最少切分，ik_max_word是最细粒度划分。

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "中国共产党"
}
GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "中国共产党"
}

ik分词器增加自己的配置

在IKAnalyzer.cfg.xml中加入自己写的dic配置文件注意编码格式要是utf-8才会生效中文

Rest风格

基本Rest命令

methodurl地址描述
PUTlocalhost:9200/索引名字/类型名字/文档id创建文档（制定文档ID）
POSTlocalhost:9200/索引名称/类型名称创建文档（随机ID）
POSTlocalhost:9200/索引名称/类型名称/文档id/_Update修改文档
DELETElocalhost:9200/索引名称/类型名称/文档id删除文档
GETlocalhost:9200/索引名称/类型名称/文档id通过文档ID查询文档
POSTlocalhost:9200/索引名称/类型名称/_search查询所有数据

基本数据类型：

字符串类型：

text,keyword。

数值类型

long，integer，short，byte，double，float，half float，scaled float

日期类型

date

布尔类型

boolean

二进制类型

binart

等等

1.创建索引(新版以后type默认为_doc)

PUT /test1/type1/1
{
  "name":"高帆",
  "age":""
}

1.1指定字段类型创建索引规则

PUT /test2
{
  "mappings": {
    "properties": { 
    "name":{
      "type": "text"
    },
    "age":{
      "type": "integer"
    },
    "brith":{
      "type": "date"
    
    }
    }
  }
}

2.获得规则

GET请求获得索引信息

GET test2

//获取默认信息
GET _cat/indices?v

3.修改值第一种方法

PUT /test3/_doc/1
{
  "name":"123",
  "age":12,
  "birth": "1999-7-7"
}
## 修改后返回值
{
  "_index" : "test3",
  "_type" : "_doc",
  "_id" : "1",
    ##版本号增加了
  "_version" : 3,
    ##状态为update
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 2,
  "_primary_term" : 1
}

3.1修改值第二种方法

POST /test3/_doc/1/_update
{
  "doc":{
    "name":"李四"
  }
}

4.删除索引

DELETE /test1

关于文档的操作

基本操作：

简单查询

/_search 代表查询 q代表搜索 name代表字段,gf代表查询的值
GET gf/user/_search?q=name:gf

复杂操作查询（排序,分页,高亮,模糊查询,精准查询）：

查询

GET gf/user/_search
{
  //查询参数体 向mysql里的where
  "query":{
    "match": {
      "name": "高帆"
    }
  },
  //需要查询的列,mysql查询后跟上列名称
  "_source": ["name","desc"],
  //sort 进行排序 
  "sort":[{
      //排序字段
    "age":{
        //排序方式 desc降序,asc升序
      "order":"desc"
    }
  }
 ],
 //分页参数,form相当于index,size：一页多少条数据
 "from":0,
 "size":1
}



{
  "took" : 528,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.5884793,
      //hits 索引和文档信息，查询结果总数 ，和一些基本信息
    "hits" : [
      {
        "_index" : "gf",
        "_type" : "user",
        "_id" : "1",
           //score,匹配度越高分值越高 
        "_score" : 1.5884793,
        "_source" : {
          "name" : "高帆12"
        }
      },
      {
        "_index" : "gf",
        "_type" : "user",
        "_id" : "4",
        "_score" : 1.5884793,
        "_source" : {
          "name" : "高帆21"
        }
      }
    ]
  }
}

多条件查询

match and操作


GET gf/user/_search
{

  "query":{
  //多条件查询 must 相当于sql中的and  where name=“gf” and age=“1”
    "bool": {
      "must": [
        {
      "match": {
          "name": "高帆"
      }
        },
        {
          "match": {
            "age": 1
          }
        }
      ]
    }
  },
  "_source": ["name","desc","age"],
  "sort": [{
    "age":{
      "order":"desc"
    }
  }
  ]
}

should or操作


GET gf/user/_search
{

  "query":{
    "bool": {
      //多条件查询 must 相当于sql中的or  where name=“gf” or age=“1”
      "should": [
        {
      "match": {
          "name": "高帆"
      }
        },
        {
          "match": {
            "age": 1
          }
        }
      ]
    }
  },
  "_source": ["name","desc","age"],
  "sort": [{
    "age":{
      "order":"desc"
    }
  }
  ]
}

must_not 不等于


GET gf/user/_search
{

  "query":{
    "bool": {
        //不等于操作 where age <>1
      "must_not": [
        {
          "match": {
            "age": 1
          }
        }
      ]
    }
  },
  "_source": ["name","desc","age"],
  "sort": [{
    "age":{
      "order":"desc"
    }
  }
  ]
}

fiter 过滤器

GET gf/user/_search
{

  "query":{
    "bool": {
      "must": [
        {
          "match": {
            "name": "高帆"
          }
        }
      ],
        //过滤器 过滤 名字大于(gt)1并且小于(lt)10的数据
        //gt 大于,gte 大于等于，lt 小于,lte：小于等于
      "filter": [
        {
          "range": {
            "age": {
              "lt": 10,
              "gt": 1
            }
          }
        }
      ]
    }
  },
  "_source": ["name","desc","age"],
  "sort": [{
    "age":{
      "order":"desc"
    }
  }
  ]
}

匹配多个条件

GET gf/user/_search
{

  "query":{
  
          "match": {
              //多个条件用空格隔开只要满足其中一个结果就可以查询所有出来取分值最高的就可以了
            "tags": "大 游"
          }
  }
}

精确查找

term查询是直接通过倒排索引指定的词条进程精确查找

term,直接查询准确的不使用分词器，

match，会使用分词器解析

两个类型

text：会被拆开查询如like

keyWord：不会被拆开查询如=

GET testdb/_search
{
  "query": {
    "term": {
        //desc 为 keyWord查询的是精准的
      "desc":"张三在唱歌 desc"
    }
  }
}
//查询结果
{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 0.6931471,
    "hits" : [
      {
        "_index" : "testdb",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.6931471,
        "_source" : {
          "name" : "张三在唱歌 name",
          "desc" : "张三在唱歌 desc"
        }
      }
    ]
  }
}
//使用text查询
GET testdb/_search
{
  "query": {
    "term": {
      "name":"张"
    }
  }
}
//查询结果
{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 0.18232156,
    "hits" : [
      {
        "_index" : "testdb",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.18232156,
        "_source" : {
          "name" : "张三在唱歌 name",
          "desc" : "张三在唱歌 desc"
        }
      },
      {
        "_index" : "testdb",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.18232156,
        "_source" : {
          "name" : "张三在唱歌 name",
          "desc" : "张三在唱歌 desc2"
        }
      }
    ]
  }
}

精确查询多个值

GET testdb/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
            "desc":"张三在唱歌 desc"
          }
        },
        {
          "term": {
            "desc":"张三在唱歌 desc2"
          }
        }
      ]
    }
  }
}

高亮查询

GET testdb/_search
{
  "query": {
    "match": {
      "name":"张"
    }
  },
   //高亮查询
  "highlight": {
    //自定义高亮标签
    "pre_tags": "<p class='key' style='color:red'>", 
    //结束标签
    "post_tags": "</p>", 
    //高亮字段选择
    "fields": { 
    "name":{}
    }
  }
}

高级客户端索引api

配置es

@Configuration
public class ElasticSearchConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        return new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );
    }
}

创建索引（表）

//创建索引请求 
CreateIndexRequest gaofan = new CreateIndexRequest("gaofan");
//执行创建请求IndicesClient
CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(gaofan, RequestOptions.DEFAULT);
System.out.println(createIndexResponse);

判断索引是否存在

//获取索引是否存在
@Test
void testExistIndex() throws IOException {
    GetIndexRequest getIndexRequest = new GetIndexRequest("gaofan2");
    //判断索引是否存在
    boolean exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
    System.out.println(exists);
}

删除索引

//删除索引
@Test
void testDeleteIndex() throws IOException {
    DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("ilm-history-2-000001");
    AcknowledgedResponse delete = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
    System.out.println(delete.isAcknowledged());
}

添加文档

//添加文档
@Test
void testAddDocument() throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    //创建对象
    User user = new User("gf", 1);
    //创建请求
    IndexRequest request = new IndexRequest("gaofan");
    //创建规则 PUT/gaofan/_doc/1
    request.id("1");
    //过期时间1s
    request.timeout(TimeValue.timeValueSeconds(1));
    //放入我们的数据json格式
    request.source(objectMapper.writeValueAsString(user), XContentType.JSON);
    //客户端发送请求获取响应结果
    IndexResponse index = restHighLevelClient.index(request, RequestOptions.DEFAULT);
    System.out.println(index.toString());
    System.out.println(index.status());//对应我们命令返回的状态

}

判断文档是否存在

@Test
void testIsExists() throws IOException {
    GetRequest getRequest = new GetRequest("gaofan", "1");
    //不获取返回的_source的上下文
    getRequest.fetchSourceContext(new FetchSourceContext(false));
    getRequest.storedFields("_none_");
    boolean exists = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
    System.out.println(exists);
}

获取文档消息

//获取文档消息
@Test
void testGetDocument() throws IOException {
    GetRequest getRequest = new GetRequest("gaofan", "1");
    GetResponse documentFields = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
    //打印文档内容
    System.out.println(documentFields.getSourceAsString());
    //打印全部内容
    System.out.println(documentFields);
}

更新文档

@Test
void testUpdateDocument() throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    UpdateRequest updateRequest = new UpdateRequest("gaofan", "1");
    updateRequest.timeout(TimeValue.timeValueSeconds(1));
    User user = new User("张三", 12);
    updateRequest.doc(objectMapper.writeValueAsString(user), XContentType.JSON);
    UpdateResponse update = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
    System.out.println(update.status());
}

删除文档

//删除文档
@Test
void testDeleteDocument() throws IOException {
    DeleteRequest deleteRequest = new DeleteRequest("gaofan", "1");
    deleteRequest.timeout("1s");
    DeleteResponse delete = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
    System.out.println(delete.status());
}

批量插入

//批量插入
@Test
void testBulkRequest() throws IOException {
    //转换json使用
    ObjectMapper objectMapper = new ObjectMapper();
    BulkRequest bulkRequest = new BulkRequest();
    bulkRequest.timeout("10s");
    List<User> users = new ArrayList<>();
    users.add(new User("张三", 1));
    users.add(new User("李四", 2));
    users.add(new User("王五", 3));
    users.add(new User("刘六", 4));
    for (int i = 0; i < users.size(); i++) {
        //批量更新和批类删除一样的操作修改对应的请求
        bulkRequest.add(new IndexRequest("gaofan")
                .id(i + 1 + "").source(objectMapper.writeValueAsString(users.get(i)), XContentType.JSON));

    }
    BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
    //是否失败返回false代表成功
    System.out.println(bulk.hasFailures());
}

查询

//查询
@Test
void testSearch() throws IOException {
    ObjectMapper objectMapper=new ObjectMapper();
    SearchRequest searchRequest = new SearchRequest("gaofan");
    //构建搜索条件
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //构建查询(查询条件)
    //QueryBuilders 工具类
    //termQuery 精确查询
    //QueryBuilders.matchAllQuery() 匹配所有 加上.keyword避免搜索不到中文
    TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name.keyword", "张三");
    searchSourceBuilder.query(termQueryBuilder);
    //设置超时
    searchSourceBuilder.timeout(TimeValue.timeValueSeconds(60));
    //分页有默认值
    searchSourceBuilder.size();
    searchSourceBuilder.from();
    searchRequest.source(searchSourceBuilder);
    SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    //所有内容都在Hits里
    System.out.println(objectMapper.writeValueAsString(search.getHits()));
    System.out.println("-----------------------------");

    for (SearchHit hit : search.getHits().getHits()) {
        System.out.println(hit.getSourceAsMap());
    }
}

实战模仿jd搜索

爬虫

导入解析网页的包

 <!--解析网页-->
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.10.2</version>
        </dependency>

package com.gf.utils;

import com.gf.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.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * 解析网页
 *
 * @author Administrator
 */
@Component
public class HtmlParseUtil {
    public List<Content> parseJd(String keyWords) throws Exception {
        //获取请求 https://search.jd.com/Search?keyword=java
        String url = "https://search.jd.com/Search?keyword=" + keyWords;
        //解析网页  (document就是js页面对象)所有js中的方法都能用
        Document document = Jsoup.parse(new URL(url), 30000);
        Element element = document.getElementById("J_goodsList");
        //获取li元素
        Elements li = element.getElementsByTag("li");
        ArrayList<Content> goodsList = new ArrayList<>();
        //获取元素中的内容
        for (Element el : li) {
            Content content = new Content();
            //如果有懒加载模式就找到source-data-lazy-img 这个节点获取
            //图片
            String img = el.getElementsByTag("img").eq(0).attr("src");
            //价格
            String price = el.getElementsByClass("p-price").eq(0).text();
            //标题
            String title = el.getElementsByClass("p-name").eq(0).text();
            content.setImg(img);
            content.setTitle(title);
            content.setPrice(price);
            goodsList.add(content);
        }
        return goodsList;
    }
}

将爬虫爬到的数据放入ES并搜索

package com.gf.service;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.gf.pojo.Content;
import com.gf.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.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
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.springframework.stereotype.Service;

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

/**
 * @author Administrator
 */
@Service
public class ContentService {
    @Resource
    private RestHighLevelClient restHighLevelClient;
    @Resource
    private HtmlParseUtil htmlParseUtil;

    /**
     * 爬取jd数据放入es
     *
     * @param keyWords
     * @return
     * @throws Exception
     */
    public Boolean parseContent(String keyWords) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        List<Content> contents = htmlParseUtil.parseJd(keyWords);
        //批量插入es
        BulkRequest bulkRequest = new BulkRequest();
        //设置超时时间
        bulkRequest.timeout("2m");
        for (Content content : contents) {
            bulkRequest.add(new IndexRequest("jd-goods").source(objectMapper.writeValueAsString(content), XContentType.JSON));
        }
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        return !bulk.hasFailures();
    }

    /**
     * 查询
     *
     * @param keywords
     * @param pageNo
     * @param pageSize
     * @return
     * @throws IOException
     */
    public List<Map<String, Object>> searchPage(String keywords, int pageNo, int pageSize) throws IOException {
        if (pageNo <= 1) {
            pageNo = 1;
        }
        //条件搜索
        SearchRequest searchRequest = new SearchRequest("jd-goods");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //分页
        searchSourceBuilder.from(pageNo);
        searchSourceBuilder.size(pageSize);
        //精准匹配
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", keywords);
        searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        //构建高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        //要高亮的字段
        highlightBuilder.field("title");
        //是否多个高亮显示
        highlightBuilder.requireFieldMatch(false);
        //标签
        highlightBuilder.preTags("<span style='color:red'>");
        highlightBuilder.postTags("</span>");
        searchSourceBuilder.highlighter(highlightBuilder);
        //查询
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //解析结果
        ArrayList<Map<String, Object>> mapArrayList = new ArrayList<>();
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            //解析高亮的字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField title = highlightFields.get("title");
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            if (title != null) {
                Text[] fragments = title.fragments();
                StringBuilder newTitle = new StringBuilder();
                for (Text fragment : fragments) {
                    newTitle.append(fragment);
                }
                sourceAsMap.put("title", newTitle);
            }
            mapArrayList.add(hit.getSourceAsMap());
        }
        return mapArrayList;
    }
}
weixin_44100744
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch学习文档pdf
06-17
ElasticSearch是一个基于Lucene构建的开源，分布式，RESTful搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。支持通过HTTP使用 JSON 进行数据索引。 我们建立一个网站或应用程序，...
Elasticsearch学习总结
01-27
Elasticsearch学习总结 Elasticsearch是一个强大的分布式搜索引擎，它以文档为中心，允许存储和检索整个对象或文档。它的核心特性在于对文档内容进行索引，使得数据可以被快速搜索、排序和过滤。与传统的关系型...
Elasticsearch常用API与IK分词器
Sebastien23的博客
12-01 701
，需要给出所有的字段。如果新的PUT命令中只给出了要修改的字段（比如description），那么其他未明确给出的字段（name和title）都会被舍弃！可以看到，比起ES自带的standard analyzer的逐字拆分，IK分词器的拆分结果明显更贴合中文语法习惯，能够提升ES检索中文关键字的效率。通过Analyze API可以查看分词插件的效果。如果只需要更新document中的个别字段，可以使用。下载支持中文分词的IK插件（与ES版本一一对应）。可以看到，mappings中出现了新增的字段属性。
Elasticsearch初体验-创建Index，Document以及常见的ES查询
hundred_li_journey的博客
08-21 1342
Elasticsearch是一个基于Lucene库的搜索引擎。它提供了一个分布式、支持多租户的全文搜索引擎，具有HTTP Web接口和无模式JSON文档。
Elasticsearch的学习(-)
smileLs的博客
05-16 195
Elasticsearch的学习(-) 1.Elasticsearch的基本概念： Elasticsearch也是基于Lucene的全文检索库，本质也是存储数据，很多概念与MySQL类似的
Mysql面试题之关联查询
清晨的炸鸡啤酒花生米的博客
12-01 510
Mysql面试题之关联查询 有两张表，一张班级表（class）包含以下字段： 一张学生表（stu） 要求：查询每个班男生女生各有多少人？ SELECT cn,COUNT(*) FROM(SELECT c.name cn,s.name sn,s.sex FROM class c RIGHT JOIN stu s ON c.id=s.class_id WHERE s.sex='men') ca GROUP BY cn; 子查询结果为： 整条sql查询结果为： 有没有更优的查询呢？ ...
java不确定多条件筛选接口
weixin_34253539的博客
12-21 1520
有同学来信说看了数据持久层的实现之后还是不能正确的使用不确定多条件筛选来做项目，无法写出接口来，今天正好有点空闲我就把接口的代码也展现出来风向给大家 接口层其实有接注意的点： 1，对参数的处理（APP接口为例） 2，对经纬度和分页的处理 3，对筛选出无店铺数据的处理 总之掌握了以上的三点类容，就能够轻松的驾驭从数据持久层到接口层的应用 /** * 筛选店铺列表 ...
XSL开发文档系列
weixin_30512043的博客
04-23 286
XSL文档（一）——第一个XML文档 随着Internet的发展，越来越多的信息进入互联网，信息的交换、检索、保存及再利用等迫切的需求使HTML这种最常用的标记语言已越来越捉襟见肘。HTML将资料内容与表现融为一体，可修改性、资料可检索性差，而XML借鉴了HTML与数据库、程序语言的优点，将内容与表现分开，不仅使检索更为方便，更主要的是用户之间资料的交换更加方便，可重用性更强。 XML是...
Es-Search Api 详解
weixin_33726318的博客
01-13 770
URI-Search 通过url query参数来实现搜索,常用参数如下: q指定查询的语句,语法为Query String Syntax df q中不指定字段时默认查询的字段,如果不指定, es会查询所有字段 sort排序 timeout指定超时时间,默认不超时 from,size用于分页 Query String Syntax term与phrase alfred wa...
ElasticSearch学习笔记
10-29
ElasticSearch学习笔记 ElasticSearch是基于Apache Lucene的搜索和数据分析引擎，提供了RESTful API用于数据的索引、搜索和分析。本笔记将对ElasticSearch的基本概念、架构、应用场景和实现细节进行详细介绍。 一...
ElasticSearch学习文档
01-20
Elasticsearch 是一个强大的开源搜索引擎，基于 Lucene 库进行了高度封装，旨在提供简单易用的 RESTful API 和 Java API 接口。其设计目标是实现分布式、实时的搜索和分析功能，适用于处理大量非结构化数据。Elastic...
ElasticSearch全部学习资料
04-03
ElasticSearch全部学习资料，包含如何搭建、如何写脚本、java代码、如何查询及集群的配置
elasticsearch学习笔记.rar
03-20
在"elasticsearch学习笔记.pdf"中，你将详细学习这些概念，并通过实际案例来加深理解，包括如何安装配置ES，创建和管理索引，执行搜索，以及进行高级操作如数据导入导出、监控和报警等。这将是你掌握Elasticsearch...
ElasticSearch学习笔记1
08-08
ElasticSearch学习笔记1 ElasticSearch是基于Lucene的搜索服务器，它提供了高性能的全文搜索功能，支持开箱即用的集群化扩展。ElasticSearch可以通过标准的REST API或特定于编程语言的客户端库与之交互。 一、什么...
接口文档：第一章：简洁版接口文档
Java程序员廖志伟
04-29 3315
ApiAddressController|收货地址管理控制器 获取收货地址列表信息 接口说明:通过用户名获取地址列表信息 接口地址:/address/find 请求方式：GET 请求参数：无 添加或更新收货地址 接口说明:添加或更新收货地址，有addressID为更新，没有addressID为添加 接口地址:/address/save 请求方式：POST 请求参数： 参数名称...
安居客住房系统-基于Python-Django前后端分离开发（四）——户型、用户数据接口处理及其筛选
dcstempt_ping
09-09 521
户型、用户数据接口处理及其筛选 在前面的文档中，我已经完成了部分的数据接口，相信大家看了我的文档，已经能够明白如何书写序列化器、设置高级筛选条件、以及返回接口数据的视图函数，这里我将直接给大家房源的视图集和的相关代码： # 在api/views.py中添加房源视图集和房源标签是图集 @method_decorator(cache_page(timeout=86400, cache='default'), name='list') class TagViewSet(ModelViewSet): """
restful api编写规范
weixin_30828379的博客
03-14 159
Node.js除了用来编写WEB应用之外，还可以用来编写API服务，我们在本文中会介绍编写Node.js Rest API的最佳实践，包括如何命名路由、进行认证和测试等话题，内容摘要如下： 正确使用HTTP Method和路由 正确的使用HTTP状态码 使用HTTP Header来发送元数据 为REST API挑选合适的框架 ...
elasticsearch学习教程
最新发布
06-25
2022/08/07 13:54 6,050,399 1-尚硅谷项目课程系列之Elasticsearch.pdf 2022/09/01 17:50 1,885 ElasticSearch 注意问题.md 2022/08/29 09:47 <DIR> elasticsearch.assets 2022/09/15 16:49 8,712 elasticsearch.md ...
elasticsearch学习
08-25
关于学习Elasticsearch，我可以给你一些指导。Elasticsearch是一个开源的分布式搜索和分析引擎，主要用于快速、实时地存储、搜索和分析大量数据。下面是一些学习Elasticsearch的步骤： 1. 了解基本概念：开始学习...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值