ES基础概念

1.倒排索引

倒排索引源于实际应用中需要根据属性的值来查找记录。由于不是由记录来确定属性值，而是由属性值来确定记录的位置，因此称为倒排索引。

倒排索引里有三个文件，索引词文件，词频文件，位置文件。

2.索引词

索引词是一个能够被索引的精确词。

3.文本

文本是一段普通的非结构化文字。

3.分析

分析是将文本转换为索引词的过程，分析的结果依赖于分词器。

4.集群

集群由一个或多个节点组成，对外提供服务，对外提供索引和搜索功能。在所有的节点，一个集群有一个唯一的名称默认为“ElasticSearch”，此名称很重要，因为每个节点只能是集群的一部分，当该节点被设置为相同的集群名称时，就会自动加入集群。当需要多个集群的时候，要确保每个集群的名称不能重复，否则，节点可能会加入错误的集群。

5.节点

一个节点是一个逻辑上独立的服务，它是集群的一部分，可以存储数据，并参与集群的索引和搜索功能。就像集群一样，节点也有唯一的名字，在启动时分配。一个节点只能加入一个集群。

6.路由

当存储一个文档的时候，它会存储在唯一的主分片中，具体哪个分片是通过散列值进行选择。

7.分片

分片是单个Lucene实例。分片有主分片和副分片。

8.索引

索引是具有相同结构的文档集合。相当于数据库的Datebase

9.类型

在索引中，可以定义一个或多个类型，类型是索引的逻辑分区。相当于数据库中的表。

10.文档

文档是存储在Elasticsearch中的一个JSON字符串，相当于数据库中表的一行。

11.映射

映射想关系数据库中的表结构，每一个索引都有一个映射。

12.字段

类似关系数据库的某一列，这是ES数据存储的最小单位。

13.主键ID

ID是一个未接的唯一标识，如果在库中没有提供ID,系统会自动生成一个ID。

14.Rest请求头

Http   数据处理

post   create

get     read

put     update

delete delete

15.文档的增删改查

put/post/get/delete http://ip:端口/索引名称/类型/主键

参数

16.文档的增删改查

package com.czy.demo;

import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.bulk.byscroll.BulkByScrollResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetItemResponse;
import org.elasticsearch.action.get.MultiGetResponse;
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.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.DeleteByQueryAction;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Date;

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;

/**
 * 索引的增删改查
 * Created by chenzhiyuan on 2017/8/29.
 */
public class OperationIndexDemo {
    private TransportClient client;

    @Before
    public void before() throws UnknownHostException {
        Settings settings = Settings.builder()
                .put("cluster.name", "elasticsearch")
                .put("client.transport.sniff", true)
                .build();
        client = new PreBuiltTransportClient(settings)
                .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
    }

    /**
     * 创建索引的第一步是把对象转换成字符串
     * 官方给出了四种创建JSON字符串的方法
     * 1.手写方式
     * 2.使用集合
     * 3.使用JACKSON序列化
     * 4.使用Elasticsearch帮助类，官方推荐
     * 可以调用response对象的方法获取返回信息：
     * // 索引名称
     * String _index = response.getIndex();
     * // 类型名称
     * String _type = response.getType();
     * // 文档id
     * String _id = response.getId();
     * // 版本(if it's the first time you index this document, you will get: 1)
     * long _version = response.getVersion();
     * // 是否被创建is true if the document is a new one, false if it has been updated
     * boolean created = response.isCreated();
     */
    @Test
    public void createIndex() throws IOException {
        IndexResponse response = client.prepareIndex("twitter", "tweet", "1")
                .setSource(jsonBuilder()
                        .startObject()
                        .field("user", "kimchy")
                        .field("postDate", new Date())
                        .field("message", "trying out Elasticsearch")
                        .endObject()
                )
                .get();
        //可以调用response对象的方法获取返回信息：
        // 索引名称
        String _index = response.getIndex();
        // 类型名称
        String _type = response.getType();
        // 文档id
        String _id = response.getId();
        // 版本(if it's the first time you index this document, you will get: 1)
        long _version = response.getVersion();
        // status has stored current instance statement.
        RestStatus status = response.status();
        System.out.println("index:" + _index + " type:" + _type + " id:" + _id + " version:" + _version);
        System.out.println("status:" + status);

    }

    @Test
    public  void getIndex() throws  Exception{
        GetResponse response = client.prepareGet("twitter","tweet","1")
                .setOperationThreaded(false)
                .get();
        System.out.println(response.getSource());
    }

    @Test
    public void deleteIndex() throws  Exception{
        DeleteResponse response = client.prepareDelete("twitter","tweet","1")
                .get();
        System.out.println(response.getResult());
    }

    @Test
    public  void updateIndex() throws  Exception{
        //注意更新不存在的索引会报错
        UpdateRequest updateRequest = new UpdateRequest();
        updateRequest.index("twitter");
        updateRequest.type("tweet");
        updateRequest.id("1");
        updateRequest.doc(jsonBuilder().startObject().field("user","cxy").endObject());
        UpdateResponse response = client.update(updateRequest).get();
        System.out.println(response.getResult());
    }

    @Test
    public  void upsertIndex() throws  Exception{
        IndexRequest indexRequest = new IndexRequest("twitter","tweet","2")
                .source(jsonBuilder().startObject()
                .field("user", "cxy")
                .field("postDate", new Date())
                .field("message", "trying")
                .endObject());
        UpdateRequest updateRequest = new UpdateRequest("twitter","tweet","2")
                .doc(jsonBuilder().startObject()
                .field("user","cxy")
                .endObject())
                .upsert(indexRequest);
       UpdateResponse response= client.update(updateRequest).get();
        System.out.println(response.getResult());
    }

    @Test
    public  void multiGetIndex() throws Exception{
        MultiGetResponse multiGetItemResponses = client.prepareMultiGet()
                .add("twitter","tweet","1")
                .add("twitter","tweet","2","3")
                .add("another","type","foo")
                .get();
        for (MultiGetItemResponse itemResponse :multiGetItemResponses){
            GetResponse response = itemResponse.getResponse();
            if(response!=null &&response.isExists()){
                System.out.println(response.getSourceAsString());
            }
        }
    }

    @Test
    public void deleteByQuery() throws  Exception{
        BulkByScrollResponse response = DeleteByQueryAction.INSTANCE.newRequestBuilder(client)
                .filter(QueryBuilders.matchQuery("user","czy"))
                .source("twitter")
                .get();
        long deleteNumber = response.getDeleted();
        System.out.println(deleteNumber);
    }

    @Test
    public void deleteByQueryAsynchronously() throws  Exception{
        DeleteByQueryAction.INSTANCE.newRequestBuilder(client)
                .filter(QueryBuilders.matchQuery("user","cxy"))
                .source("twitter")
                .execute(new ActionListener<BulkByScrollResponse>() {
                    @Override
                    public void onResponse(BulkByScrollResponse bulkByScrollResponse) {
                        System.out.println(bulkByScrollResponse.getDeleted());
                    }

                    @Override
                    public void onFailure(Exception e) {
                        System.out.println(e.getMessage());
                    }
                });
    }

    @Test
    public  void bulkIndex() throws Exception{
        BulkRequestBuilder bulkRequest = client.prepareBulk();
        bulkRequest.add(client.prepareIndex("twitter","tweet","4")
                        .setSource(jsonBuilder().startObject()
                        .field("user","czy")
                        .field("postDate",new Date())
                        .field("message","happy ending")
                        .endObject()
                        )
        );
        bulkRequest.add(client.prepareIndex("twitter","tweet","4")
                .setSource(jsonBuilder().startObject()
                        .field("user","cxy")
                        .field("postDate",new Date())
                        .field("message","happy ending")
                        .endObject()
                )
        );
        BulkResponse bulkResponse= bulkRequest.get();
        System.out.println(bulkResponse.getTook());
        if (bulkResponse.hasFailures()) {
            System.out.println(bulkResponse.getTook());
        }
    }
}