史上最全面的Elasticsearch使用指南

wget https://download.elastic.co/elasticsearch/release/org/elasticsearch/distribution/tar/elasticsearch/2.4.1/elasticsearch-2.4.1.tar.gz

tar -zxvf elasticsearch-2.4.1.tar.gz

# ======================== Elasticsearch Configuration =========================
#
# NOTE: Elasticsearch comes with reasonable defaults for most settings.
#       Before you set out to tweak and tune the configuration, make sure you
#       understand what are you trying to accomplish and the consequences.
#
# The primary way of configuring a node is via this file. This template lists
# the most important settings you may want to configure for a production cluster.
#
# Please see the documentation for further information on configuration options:
# 
#
# ---------------------------------- Cluster -----------------------------------
#
# Use a descriptive name for your cluster:
# 集群名称，默认为elasticsearch
cluster.name: my-application
#
# ------------------------------------ Node ------------------------------------
#
# Use a descriptive name for the node:
# 节点名称，es启动时会自动创建节点名称，但你也可进行配置
node.name: node-1
#
# Add custom attributes to the node:
#
# 是否作为主节点，每个节点都可以被配置成为主节点，默认值为true：
# node.master: true
#
# node.rack: r1
#
# ----------------------------------- Paths ------------------------------------
#
# Path to directory where to store the data (separate multiple locations by comma):
# 分配给当前节点的索引数据所在的位置
# path.data: /path/to/data
#
# Path to log files:
# 日志文件所在位置
# path.logs: /path/to/logs
#
# ----------------------------------- Memory -----------------------------------
#
# Lock the memory on startup:
#
# bootstrap.memory_lock: true
#
# Make sure that the `ES_HEAP_SIZE` environment variable is set to about half the memory
# available on the system and that the owner of the process is allowed to use this limit.
#
# Elasticsearch performs poorly when the system is swapping the memory.
#
# ---------------------------------- Network -----------------------------------
#
# Set the bind address to a specific IP (IPv4 or IPv6):
#
network.host: 0.0.0.0
#
# Set a custom port for HTTP:
#
http.port: 9200
#
# For more information, see the documentation at:
# 
#
# --------------------------------- Discovery ----------------------------------
#
# Pass an initial list of hosts to perform discovery when new node is started:
# The default list of hosts is ["127.0.0.1", "[::1]"]
#
# discovery.zen.ping.unicast.hosts: ["host1", "host2"]
#
# Prevent the "split brain" by configuring the majority of nodes (total number of nodes / 2 + 1):
#
# discovery.zen.minimum_master_nodes: 3
#
# For more information, see the documentation at:
# 
#
# ---------------------------------- Gateway -----------------------------------
#
# Block initial recovery after a full cluster restart until N nodes are started:
#
# gateway.recover_after_nodes: 3
#
# For more information, see the documentation at:
# 
#
# ---------------------------------- Various -----------------------------------
#
# Disable starting multiple nodes on a single system:
#
# node.max_local_storage_nodes: 1
#
# Require explicit names when deleting indices:
#
# action.destructive_requires_name: true

./elasticsearch -d

./elasticsearch &

useradd admin

chmod -R 777 elasticsearch

su admin

./elasticsearch -d

ps -ef|grep elasticsearch

export ES_HEAP_SIZE=1g

./elasticsearch -Xms256m -Xmx256m -d

http://你的服务器IP:9200

{
    "name": "node-1",
    "cluster_name": "my-application",
    "cluster_uuid": "zrghL-WiQzeVE4rlX0WUAg",
    "version": {
        "number": "2.4.1",
        "build_hash": "c67dc32e24162035d18d6fe1e952c4cbcbe79d16",
        "build_timestamp": "2016-09-27T18:57:55Z",
        "build_snapshot": false,
        "lucene_version": "5.5.2"
    },
    "tagline": "You Know, for Search"
}

./bin/plugin install mobz/elasticsearch-head

http://你的服务器IP:9200/_plugin/head/

GET http://localhost:9200/_search?q = name:central

{
    "took": 78,
    "timed_out": false,
    "_shards": {
        "total": 10,
        "successful": 10,
        "failed": 0
    },
    "hits": {
        "total": 1,
        "max_score": 0.19178301,
        "hits": [
            {
                "_index": "schools",
                "_type": "school",
                "_id": "1",
                "_score": 0.19178301,
                "_source": {
                    "name": "Central School",
                    "description": "CBSE Affiliation",
                    "street": "Nagan",
                    "city": "paprola",
                    "state": "HP",
                    "zip": "176115",
                    "location": [
                        31.8955385,
                        76.8380405
                    ],
                    "fees": 2000,
                    "tags": [
                        "Senior Secondary",
                        "beautiful campus"
                    ],
                    "rating": "3.5"
                }
            }
        ]
    }
}

Get http://localhost:9200/schools/_search?q = tags:sports

{
    "took": 16,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 1,
        "max_score": 0.5,
        "hits": [
            {
                "_index": "schools",
                "_type": "school",
                "_id": "2",
                "_score": 0.5,
                "_source": {
                    "name": "Saint Paul School",
                    "description": "ICSE Afiliation",
                    "street": "Dawarka",
                    "city": "Delhi",
                    "state": "Delhi",
                    "zip": "110075",
                    "location": [
                        28.5733056,
                        77.0122136
                    ],
                    "fees": 5000,
                    "tags": [
                        "Good Faculty",
                        "Great Sports"
                    ],
                    "rating": "4.5"
                }
            }
        ]
    }
}

POST http://localhost:9200/schools/_search

{
   "query":{
      "query_string":{
         "query":"up"
      }
   }
}

JSON

{
   "_source":{
      "name":"City School", "description":"ICSE", "street":"West End",
      "city":"Meerut", "state":"UP", "zip":"250002", "location":[28.9926174, 77.692485],
      "fees":3500, "tags":["Well equipped labs"],"rating":"4.5"
   }
}

GET /my_index/my_type/_search
{
    "query": {
        "match_phrase": {
            "title": "quick brown fox"
        }
    }
}

"match": {
    "title": {
        "query": "quick brown fox",
        "type":  "phrase"
    }
}

{
    "query": {
        "match": {
            "symptom": {   
                "query":    "Love You",  
                //"operator": "and",
                 "minimum_should_match": "90%" 
            }
        }
    }
}

{
  "query": {
    "bool": {
      "must": { "match_phrase": { "symptom": "头痛" }},
      "must": { "match_phrase": { "symptom": "恶心"  }}
    }
  }
}

{
    "query": {
        "bool": {
            "should": {
                "match": {
                    "symptom": {
                        "query": "头痛",
                        "type": "phrase",
                        "boost": 3
                    }
                }
            },
           "should": {
                "match": {
                    "symptom": {
                        "query": "恶心",
                        "type": "phrase",
                        "boost": 2
                    }
                }
            }
        }
    }
}

如果每页展示 5 条结果，可以用下面方式请求得到 1 到 3 页的结果：

GET /_search?size=5
GET /_search?size=5&from=5
GET /_search?size=5&from=10

{
    "query": {
		...
    },
    "_source": [
        "name",
        "symptom"
    ],
}

{
    "query": {
        "bool": {
            "must": {
                "match": {
                    "symptom": {
                        "query": "恶心",
                        "minimum_should_match": "100%"
                    }
                }
            }
        }
    },
    "highlight": {
        "fields": {
            "symptom": {}
        }
    }
}

<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-elasticsearch</artifactId>
  <version>${version}</version>
</dependency>

spring:
  data:
    elasticsearch:
      cluster-name: my-application
      cluster-nodes: 服务器Ip:9300

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-neo4j</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Caused by: java.lang.NoSuchFieldError: LUCENE_5_3_1
	at org.elasticsearch.Version.(Version.java:279) ~[elasticsearch-2.4.6.jar:2.4.6]
	at org.elasticsearch.client.transport.TransportClient$Builder.build(TransportClient.java:131) ~[elasticsearch-2.4.6.jar:2.4.6]

public static final Version V_2_1_0 = new Version(V_2_1_0_ID, false, org.apache.lucene.util.Version.LUCENE_5_3_1);

public static final Version V_2_4_6 = new Version(V_2_4_6_ID, false, org.apache.lucene.util.Version.LUCENE_5_5_4);

<dependency>
    <groupId>org.apache.lucene</groupId>
    <artifactId>lucene-core</artifactId>
    <version>5.5.4</version>
</dependency>

@Document(indexName = "library",type = "book")	//indexName索引名称，type类别
public class Book {
    private int id;
    private String name;
    private String anthony;

    public Book(String name, String anthony, int id) {
        this.name = name;
        this.anthony = anthony;
        this.id = id;
    }

    public Book() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAnthony() {
        return anthony;
    }

    public void setAnthony(String anthony) {
        this.anthony = anthony;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", anthony='" + anthony + '\'' +
                '}';
    }
}

@Repository
public interface BookRepository extends ElasticsearchRepository {
    Book findAllByName(String name);
}

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

    @Autowired
    BookRepository bookRepository;

    @Test
    public void contextLoads() {
        Book book = new Book("《西游记后传》","小白龙",1);
        bookRepository.index(book);	//保存
        Book name = bookRepository.findAllByName("西游记"); //查找
        System.out.println(name);
    }

}

Book{id=1, name='《西游记后传》', anthony='小白龙'}

<dependency>
    <groupId>io.searchbox</groupId>
    <artifactId>jest</artifactId>
    <version>1.0.3</version>
</dependency>

<dependency>
    <groupId>com.sun.jna</groupId>
    <artifactId>jna</artifactId>
    <version>3.0.9</version>
</dependency>

spring:
  elasticsearch:
    jest:
      uris: http://123.206.46.157:9200
      username: elastic
      password: changeme
      read-timeout: 5000
      connection-timeout: 5000

public class Book {
    private int id;
    private String name;
    private String anthony;
	.....
}

@Autowired
private JestClient jestClient;

@Test
public void contextLoads() {
    Book book = new Book("《西游记后传》","小白龙",120);

    //构建一个索引功能 参数为路径.../library/old/1
    Index index = new Index.Builder(book).index("library").type("old").id("3").build();
    try {
        //执行保存
        jestClient.execute(index);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

String query = "{" +
        "    \"query\" : {" +
        "        \"match\" : {" +
        "            \"name\" : \"西游\"" +
        "        }" +
        "    }" +
        "}";

Search search = new Search.Builder(query).addIndex("library").addType("old").build();
try {
    SearchResult result = jestClient.execute(search);
    System.out.println(result.getJsonString());
} catch (IOException e) {
    e.printStackTrace();
}

public interface BookRepository extends Repository {

     List findByNameAndPrice(String name, Integer price);

     List findByNameOrPrice(String name, Integer price);
     
     Page findByName(String name,Pageable page);

     Page findByNameNot(String name,Pageable page);

     Page findByPriceBetween(int price,Pageable page);

     Page findByNameLike(String name,Pageable page);

     @Query("{\"bool\" : {\"must\" : {\"term\" : {\"message\" : \"?0\"}}}}")
     Page findByMessage(String message, Pageable pageable);
 }

@Autowired
private SampleElasticsearchRepository repository;

String documentId = "123456";
SampleEntity sampleEntity1 = new SampleEntity();
sampleEntity1.setId(documentId);
sampleEntity1.setMessage("some message");

String documentId2 = "123457"
SampleEntity sampleEntity2 = new SampleEntity();
sampleEntity2.setId(documentId2);
sampleEntity2.setMessage("test message");

List sampleEntities = Arrays.asList(sampleEntity1, sampleEntity2);

//bulk index
repository.save(sampleEntities);

Book name = bookRepository.findAllById(100);
name.setAnthony("吴承恩");	//改变
bookRepository.save(name); //保存，此时ID不变
name = bookRepository.findAllById(100); //再次查找
System.out.println(name);

bookRepository.delete(1);

	@Autowired
 private ElasticsearchTemplate elasticsearchTemplate;
 
 Book book = new Book("《西游记后传》", "小白龙", 100);
 
 IndexQuery indexQuery = new IndexQueryBuilder()
         .withIndexName("library")
         .withType("book")
         .withId(book.getId()+"")
         .withObject(book) //对象或集合
         .build();
 elasticsearchTemplate.index(indexQuery);

//第一种删除具体的一条记录
elasticsearchTemplate.delete("library","book",100+"");

//第二种删除indexName/type/下的所有
DeleteQuery deleteQuery = new DeleteQuery();
deleteQuery.setIndex("library");
deleteQuery.setType("book");
elasticsearchTemplate.delete(deleteQuery);

//第三种删除indexName/下的所有
elasticsearchTemplate.deleteIndex("library");

//第四种删除查询出来的所有
deleteQuery = new DeleteQuery();
deleteQuery.setQuery(QueryBuilders.matchQuery("id","100"));
elasticsearchTemplate.delete(deleteQuery);

Book book = new Book("《西游记后传》", "猪八戒", 100);

UpdateQuery updateQuery = new UpdateQueryBuilder()
        .withIndexName("library")
        .withType("book")
        .withId(book.getId()+"")
        .build();

elasticsearchTemplate.update(updateQuery);

@Autowired
private ElasticsearchTemplate elasticsearchTemplate;

Sort sort = new Sort(Sort.Direction.DESC, "id");//以id值为准 降序排列，ASC为升序
Pageable pageable = new PageRequest(0, 10, sort);//查看第0页，以每页10条划分

SearchQuery searchQuery = new NativeSearchQueryBuilder()
        .withQuery(QueryBuilders.matchAllQuery()) // 自定义查询（这是不同的地方）
        .withPageable(pageable) // 自定义分页
        .build();
        
Page sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,Book.class);

System.out.println("页数" + sampleEntities.getTotalPages());
System.out.println("行数" + sampleEntities.getTotalElements());
System.out.println("大小" + sampleEntities.getSize());
System.out.println("当前第几页" + sampleEntities.getNumber());
System.out.println("当前页的数量"+sampleEntities.getNumberOfElements());
System.out.println("List:"+sampleEntities.getContent());

匹配所有文档的查询。
matchAllQuery()

为提供的字段名和文本创建类型为“BOOLEAN”的匹配查询。(解释过来就是单个匹配，可以模糊匹配)
matchQuery(String name, Object text) //name 字段值 ，text 查询文本（不支持通配符）

为提供的字段名和文本创建一个通用查询。
commonTermsQuery(String name, Object text)

为提供的字段名和文本创建类型为“BOOLEAN”的匹配查询。
multiMatchQuery(Object text, String... fieldNames) 

为提供的字段名和文本创建一个文本查询，并输入“短句”。
matchPhraseQuery(String name, Object text)

为提供的字段名和文本创建一个与类型“PHRASE_PREFIX”匹配的查询。
matchPhrasePrefixQuery(String name, Object text)

匹配包含术语的文档的查询。
termQuery(String name, Object value)

使用模糊查询匹配文档的查询
fuzzyQuery(String name, Object value)

与包含指定前缀的术语的文档相匹配的查询。
prefixQuery(String name, String prefix)

在一定范围内匹配文档的查询。
rangeQuery(String name)

实现通配符搜索查询。支持的通配符是*，它匹配任何字符序列(包括空字符)，而?它匹配任何单个字符。注意，这个查询可能很慢，因为它需要遍历许多项。为了防止异常缓慢的通配符查询，通配符项不应该以一个通配符*或?开头。

wildcardQuery(String name, String query) //query 通配符查询字符串

将包含术语的文档与指定的正则表达式匹配的查询
regexpQuery(String name, String regexp) //regexp的正则表达式

解析查询字符串并运行它的查询。有两种模式。第一,当没有字段添加(使用QueryStringQueryBuilder.field(字符串),将运行查询一次,非前缀字段将使用QueryStringQueryBuilder.defaultField(字符串)。第二,当一个或多个字段添加(使用QueryStringQueryBuilder.field(String)),将运行提供的解析查询字段,并结合使用DisMax或普通的布尔查询(参见QueryStringQueryBuilder.useDisMax(布尔))。

queryStringQuery(String queryString)

类似于query_string查询的查询，但不会为任何奇怪的字符串语法抛出异常。
simpleQueryStringQuery(String queryString)

可以使用BoostingQuery类来有效地降级与给定查询匹配的结果。
boostingQuery()

匹配与其他查询的布尔组合匹配的文档的查询
boolQuery()

创建一个可用于实现MultiTermQueryBuilder的子查询的SpanQueryBuilder。
spanMultiTermQueryBuilder(MultiTermQueryBuilder multiTermQueryBuilder)

允许定义自定义得分函数的查询。
functionScoreQuery(QueryBuilder queryBuilder, ScoreFunctionBuilder function)

更像这样的查询，查找“like”提供的文档，例如提供的MoreLikeThisQueryBuilder.likeText(String)，它是针对查询所构造的字段进行检查的

moreLikeThisQuery(String... fields)

构造一个新的非计分子查询，包含子类型和要在子文档上运行的查询。这个查询的结果是这些子文档匹配的父文档。
hasChildQuery(String type, QueryBuilder query)

构造一个新的非评分父查询，父类型和在父文档上运行的查询。这个查询的结果是父文档匹配的子文档。
hasParentQuery(String type, QueryBuilder query)

基于对其中任何一个项进行匹配的若干项的字段文件
termsQuery(String name, String... values)

一个查询构建器，它允许构建给定JSON字符串或二进制数据作为输入的查询。当您希望使用Java Builder API，但仍然需要将JSON查询字符串与其他查询构建器结合时，这是非常有用的。

wrapperQuery(String source)

MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("字段名", "查询文本");

QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery("name", "Love You");

MoreLikeThisQueryBuilder queryBuilder = QueryBuilders
        .moreLikeThisQuery("name")// 要匹配的字段, 不填默认_all
        .like("西游")// 匹配的文本
        .minTermFreq(1);// 文本最少出现的次数（默认是2，我们设为1）

添加一些文本以查找“类似”的文档
addLikeText(String... likeTexts)

查找类似文档
like(Item... likeItems)

设置不从其中选择（比如我们调用.like("西游").unlike("西游记")这样会导致啥也查不到）
unlike(String... unlikeTexts)

添加一些文本以查找与此不同的文档
addUnlikeText(String... unlikeTexts)

设置将包含在任何生成查询中的查询条件的最大数量。默认25
maxQueryTerms(int maxQueryTerms)

设置单词被忽略的频率，默认5，小于将不会被发现
minDocFreq(int minDocFreq)

设置单词仍然出现的最大频率。单词出现更多的文档将被忽略。默认为无限
maxDocFreq(int maxDocFreq)

设置将被忽略的单词的最小单词长度，默认0
minWordLength(int minWordLength)

设置将被忽略的单词的最大单词长度，默认无限
maxWordLength(int maxWordLength)

设置停止词，匹配时会忽略停止词
stopWords(String... stopWords)

设置词语权重，默认是1
boostTerms(float boostTerms)

查询权重（默认1）
boost(float boost)

设置不从其中选择术语的文本（文档Item）
ignoreLike(String... likeText)

QueryBuilder queryBuilder = QueryBuilders.boolQuery()
                .must(QueryBuilders.matchQuery("name", "西游")) //AND
                .must(QueryBuilders.wildcardQuery("name", "西游?")) //Not
                .should(QueryBuilders.matchQuery("name", "西游记")); //Or

QueryBuilder queryBuilder = QueryBuilders
                .constantScoreQuery(QueryBuilders.matchQuery("name", "西游记"))
                .boost(2.0f);

QueryBuilder queryBuilder = QueryBuilders.rangeQuery("id")
                .from("20")
                .to("50")
                .includeLower(true)     // 包含上界
                .includeUpper(true);      // 包含下届

QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("user", "ki*hy");

QueryBuilders.constantScoreQuery(FilterBuilders.termQuery("name", "kimchy")).boost(2.0f);