Elasticsearch的使用

1.排序

字段是creat_time 排序一直排不了，所有的成绩都一样

搜索的时候，不用 creat_time 用 createTime.keyword 成功了！！！

• 原来的语句

GET maimai-product/_search
{
  "query": {
    "multi_match": {
      "query": "头像",
      "fields": ["product_name","descript"]
    }
  },
  "from": 0,
  "size": 3,
  "sort": [
    {
      "creat_time": {"order": "desc"},   #这样查不行
      "price": {"order": "asc"}
    }
  ]
}

后来的语句

GET maimai-product/_search
{
  "query": {
    "multi_match": {
      "query": "头像",
      "fields": ["product_name","descript"]
    }
  },
  "from": 0,
  "size": 3,
  "sort": [
    {
      "createTime.keyword": {"order": "desc"},
      "price": {"order": "asc"}
    }
  ]
}

初级使用

下面是发送 GET请求，ip+9200端口+对应命令执行


GET /_cat/nodes：查看所有节点
GET /_cat/health：查看 es 健康状况
GET /_cat/master：查看主节点
GET /_cat/indices：查看所有索引  相当于show databases;


【添加索引！！！】
PUT /maimai-product   （maimai-product是索引名）


【新增数据】
PUT customer/external/1
{
    "name": "John Doe"
}
【在 customer 索引下的 external 类型下保存 1 号数据】
PUT 和 POST 都可以保存数据
POST 新增。如果不指定 id，会自动生成 id。指定 id 就会修改这个数据，并新增版本号
PUT  可以新增可以修改。PUT 必须指定 id；由于 PUT 需要指定 id，我们一般都用来做修改
操作，不指定 id 会报错。






【查询文档】（相当于查数据库记录）
GET customer/external/1
结果：
{
    "_index": "customer",    //在哪个索引
    "_type": "external",     //在哪个类型
    "_id": "1",              //记录 id
    "_version": 2,           //版本号
    "_seq_no": 1,            //并发控制字段，每次更新就会+1，用来做乐观锁
    "_primary_term": 1,      //同上，主分片重新分配，如重启，就会变化
    "found": true,
    "_source": {
        //真正的内容
        "name": "John Doe"
    }
}
更新携带 ?if_seq_no=0&if_primary_term=1




【更新文档】
（1.如果url带了_update，那么就要带doc。2.这个更新如果更新的数据和平时一样，就不会执行更新）
POST customer/external/1/_update
{
    "doc":{
        "name": "John Doew"
    }
}
（2.这里不会比较，直接更新）
POST customer/external/1
{
    "name": "John Doe2"
}
（3.这里不会比较，直接更新）
PUT customer/external/1
{
    "name": "John Doe"
}
（4.更新同时增加属性）
POST customer/external/1/_update
{
    "doc": {
         "name": "Jane Doe", "age": 20
    }
}
看场景；
    对于大并发更新，不带 update；
    对于大并发查询偶尔更新，带 update；对比更新，重新计算分配规则。
    
    
【删除文档&索引】（没有删除类型的方法，把一个类型下的文档都删除相当于删除类型）
DELETE customer/external/1
DELETE customer




【bulk 批量 API】【必须发post请求】
POST customer/external/_bulk
{"index":{"_id":"1"}}
{"name": "John Doe" }
{"index":{"_id":"2"}}
{"name": "Jane Doe" }


语法格式：
{ action: { metadata }}\n
{ request body }\n
{ action: { metadata }}\n
{ request body }\n


复杂实例：
POST /_bulk
{ "delete": { "_index": "website", "_type": "blog", "_id": "123" }}     #删除
{ "create": { "_index": "website", "_type": "blog", "_id": "123" }}     #创建    【如果已经有相同id的数据，不会覆盖】  
{ "title": "My first blog post" }                                       #创建的内容
{ "index": { "_index": "website", "_type": "blog" }}                    #保存    【如果已经有相同id的数据，覆盖掉】
{ "title": "My second blog post" }
{ "update": { "_index": "website", "_type": "blog", "_id": "123"} }     #更新
{ "doc" : {"title" : "My updated blog post"} }
bulk API 以此按顺序执行所有的 action（动作）。如果一个单个的动作因任何原因而失败，
它将继续处理它后面剩余的动作。当 bulk API 返回时，它将提供每个动作的状态（与发送
的顺序相同），所以您可以检查是否一个指定的动作是不是失败了

EL，Java里的使用【使用官方的连接数据库依赖】

导入依赖：
// 这行写在 <properties> 标签里面
<elasticsearch.version>7.4.2</elasticsearch.version>

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.4.2</version>
</dependency>


添加配置类：
@Configuration
public class ElasticSearchConfig {


    public static final RequestOptions COMMON_OPTIONS;
    static{


        RequestOptions.Builder builder  = RequestOptions.DEFAULT.toBuilder();
        //builder.addHeader("Authorization","Bearer " + TOKEN);
        //builder.setHttpAsyncResponseConsumerFactory(
        //        new HttpAsyncResponseConsumerFactory
        //                .HeapBufferedResponseConsumerFactory(30*1024*1024*1024));


        COMMON_OPTIONS =  builder.build();
    }


    @Bean
    RestHighLevelClient client() {
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.190.150", 9200,
                "http"));
        return new RestHighLevelClient(builder);
    }
}



增删改查也可以看这篇博客：http://t.csdn.cn/qoDjs


批量删除（其他地方没有记录）：
@RabbitHandler
@Override
public boolean deleteProduct(List<String> productIds) {

    BulkRequest request = new BulkRequest ();

    for (String productId : productIds) {
        request.add (new DeleteRequest ().index ("maimai-product").id (productId));
    }

    try {
        BulkResponse response = client.bulk (request, RequestOptions.DEFAULT);

        System.out.println (response);
    } catch (IOException e) {
        e.printStackTrace ();
    }

    return true;
}



测试代码：
@SpringBootTest
class GulimallSearchApplicationTests {


    @Autowired
    RestHighLevelClient client;


    @Test
    void contextLoads() {
        System.out.println(client);
    }




    @Data
    class User{
        private String userName;
        private String gender;
        private Integer age;
    }


    /**
     * 测试 储存数据到 es
     */
    @Test
    public void indexData() throws IOException {
        IndexRequest indexRequest = new IndexRequest("users");
        indexRequest.id("1");


        User user = new User();
        user.setUserName("小可爱");
        user.setGender("女生");
        user.setAge(18);
        String jsonString = JSON.toJSONString(user);
        indexRequest.source(jsonString, XContentType.JSON);


        IndexResponse index = client.index(indexRequest, ElasticSearchConfig.COMMON_OPTIONS);


        System.out.println(index);
    }




    /**
     * 测试检索
     */
    @Test
    public void searchData() throws IOException{
        // 1.创建检索请求
        SearchRequest searchRequest = new SearchRequest();
        // 指定索引
        searchRequest.indices("bank");
        // 指定DSL,检索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 1.1)、构造检索条件
        // 查询
        searchSourceBuilder.query(QueryBuilders.matchQuery("address","mill"));


        // 聚合
        TermsAggregationBuilder ageAgg = AggregationBuilders.terms("ageAgg").field("age").size(10);
        searchSourceBuilder.aggregation(ageAgg);


        AvgAggregationBuilder balanceAvg = AggregationBuilders.avg("balanceAvg").field("balance");
        searchSourceBuilder.aggregation(balanceAvg);


        // 打印检索条件
        //System.out.println(searchSourceBuilder.toString());




        searchRequest.source(searchSourceBuilder);


        // 2.执行检索
        SearchResponse searchResponse = client.search(searchRequest, ElasticSearchConfig.COMMON_OPTIONS);


        // 3.分析结果
        System.out.println(searchResponse.toString());
        // 获取所有查到的数据
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit searchHit : searchHits) {
            //searchHit.getIndex();
            //searchHit.getId();
            String string = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(string, Account.class));
        }


        // 获取所有的聚合
        Aggregations aggregations = searchResponse.getAggregations();
        Terms ageAgg1 = aggregations.get("ageAgg");
        for (Terms.Bucket bucket : ageAgg1.getBuckets()) {
            System.out.println("年龄："+bucket.getKeyAsNumber());
        }


        Avg balanceAvg1 = aggregations.get("balanceAvg");
        System.out.println("平均薪资："+balanceAvg1.getValue());
    }




    @ToString
    @Data
    static class Account
    {
        private int account_number;


        private int balance;


        private String firstname;


        private String lastname;


        private int age;


        private String gender;


        private String address;


        private String employer;


        private String email;


        private String city;


        private String state;
    }


}