一、pom.xml配置

SpringBoot版本1.5.6https://blog.csdn.net/kingice1014/article/details/73166686

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

注意es版本、es服务端版本、ik分词器版本

缺点

SpringDataES不支持摘要和高亮展示，需要手写

二、项目代码集成示例

Yml配置

spring:data:elasticsearch:cluster-name: elasticsearch#默认即为elasticsearch# 没有部署es的时候这个地方注释掉如果没有指定，则启动ClientNodecluster-nodes: 172.31.3.223:9300 #配置es节点信息，逗号分隔

这些配置的属性，最终会设置到org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchProperties这个实体中。

存储映射实体

@Document(indexName = "picocr_index", type = "picocr", shards = 5,replicas = 1, indexStoreType = "fs", refreshInterval = "-1")
public class PicOcr implements Serializable {private static final long serialVersionUID = 551589397625941750L;/** 图片id */@Id// @Field(index = FieldIndex.not_analyzed, store = true, type = FieldType.Long)private Long id;/** 案件id */@Field(index = FieldIndex.not_analyzed, store = true, type = FieldType.Long)private Long caseId;/** folderId */@Field(index = FieldIndex.not_analyzed, store = true, type = FieldType.String)private String nId;/** 图片名称 */@Field(index = FieldIndex.analyzed, store = true, type = FieldType.String,searchAnalyzer = "ik", analyzer = "ik")private String title;/** 图片ocr内容 */@Field(index = FieldIndex.analyzed, store = true, type = FieldType.String,searchAnalyzer = "ik", analyzer = "ik")private String content;
// 省略 get set
}

indexName必须小写，否则报错 indexName = "picocr_index"

@Document注解

在需要建立索引的类上加上[@Document](https://my.oschina.net/xzz1230)注解，即表明这个实体需要进行索引

@Persistent
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Document {String indexName();//索引库的名称，个人建议以项目的名称命名String type() default "";//类型，个人建议以实体的名称命名short shards() default 5;//默认分区数short replicas() default 1;//每个分区默认的备份数String refreshInterval() default "1s";//刷新间隔String indexStoreType() default "fs";//索引文件存储类型
}

加上了[@Document](https://my.oschina.net/xzz1230)注解之后，默认情况下这个实体中所有的属性都会被建立索引、并且分词。

@Field注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
@Inherited
public @interface Field {FieldType type() default FieldType.Auto;#自动检测属性的类型FieldIndex index() default FieldIndex.analyzed;#默认情况下分词 DateFormat format() default DateFormat.none;String pattern() default "";boolean store() default false;#默认情况下不存储原文String searchAnalyzer() default "";#指定字段搜索时使用的分词器String indexAnalyzer() default "";#指定字段建立索引时指定的分词器String[] ignoreFields() default {};#如果某个字段需要被忽略boolean includeInParent() default false;}

创建Repository

public interface PicOcrRepository extends ElasticsearchRepository<PicOcr, Long> {/*** * @description 根据参数删除 符合jpa规范*              注意：调用这个方法后，要调用 refesh方法，否则删除不生效* @author lli* @create 2018年6月14日下午5:06:45* @version 1.0* @param caseId* @param nId* @return*/Long deleteByCaseIdAndNId(Long caseId, String nId);
}

三、安装ES

保障版本一致性，由于前面jar包依赖的是2.4.5版本，故服务端选择2.4.6 或者5版本小版本不一致没什么问题

下载安装ES

下载地址：https://www.elastic.co/downloads/past-releases

选择对应的版本即可

测试默认分词

测试标准分词浏览器请求测试，地址如下：

http://localhost:9200/_analyze?analyzer=standard&pretty=true&text=今天天气真好

四、Ik分词器安装

https://github.com/medcl/elasticsearch-analysis-ik/releases?after=v5.6.6

地址如上

版本关系如下：

下载到对应IK版本的zip包后，放入到ES的plugins文件夹下解压，目录结构如下：

测试IK分词效果

浏览器输入如下地址：

http://localhost:9200/analyze?analyzer=ik&pretty=true&text=今天天气真好

这里可以选择多种模式 默认是更多分词

http://localhost:9200/analyze?analyzer=ik_smart&pretty=true&text=今天天气真好

analyzer:

ik:

alias: [ik_analyzer]

type: org.elasticsearch.index.analysis.IkAnalyzerProvider

ik_max_word:

type: ik

use_smart: false

ik_smart:

type: ik

use_smart: true

注意：安装ik后要重启es

安装Elasticsearch-Head 插件

https://www.sojson.com/blog/85.html

访问地址是http://{你的ip地址}:9200/plugin/head/

五、API测试

增加、更新

        PicOcr b = new PicOcr();b.setCaseId(123L);b.setId(300L);b.setnId("1215abkjsdkjf");b.setContent("中华人民共和国12");b.setTitle("中华人民共和国12333");System.err.println(aa.save(b));

删除

        // 通过主键删除aa.delete(300L);// 通过自定义删除，必须调用下refresh，否则删除不生效aa.deleteByCaseIdAndNId(123L, "12333");aa.refresh();

简单查询

// 查询全部，分页等
aa.findAll();
// 自定义条件查询
QueryBuilder query = QueryBuilders.boolQuery().must(QueryBuilders.termQuery("id", "1")).must(QueryBuilders.termQuery("content", "人民"));
Iterable<PicOcr> test = aa.search(query);

高亮、摘要查询

    QueryBuilder query = QueryBuilders.boolQuery().must(QueryBuilders.termQuery("caseId", dto.getCaseId())).must(QueryBuilders.termQuery("content", dto.getKeyWord()));// 加入查询中SearchResponse response = client.prepareSearch("picocr_index").setTypes("picocr").setQuery(query).addHighlightedField("content", 50)// 添加高亮的字段.setHighlighterPreTags("<span>").setHighlighterPostTags("</span>").execute().actionGet();// 遍历结果, 获取高亮片段SearchHits searchHits = response.getHits();PicOcr picOcr = null;for (SearchHit hit : searchHits) {Text[] text = hit.getHighlightFields().get("content").getFragments();if (text.length > 0) {picOcr = new PicOcr();picOcr.setCaseId(((Integer) hit.getSource().get("caseId")).longValue());picOcr.setId(((Integer) hit.getSource().get("id")).longValue());picOcr.setnId((String) hit.getSource().get("nId"));picOcr.setTitle((String) hit.getSource().get("title"));picOcr.setContent(text[0].toString());result.add(picOcr);}}

查询综合篇

照抄：https://www.cnblogs.com/wenbronk/p/6432990.html

package com.wenbronk.javaes;import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map.Entry;import org.elasticsearch.action.ListenableActionFuture;
import org.elasticsearch.action.get.GetRequestBuilder;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.IndicesQueryBuilder;
import org.elasticsearch.index.query.NestedQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.QueryStringQueryBuilder;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.index.query.SpanFirstQueryBuilder;
import org.elasticsearch.index.query.WildcardQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.junit.Before;
import org.junit.Test;/*** java操作查询api* @author 231**/
public class JavaESQuery {private TransportClient client;@Beforepublic void testBefore() {Settings settings = Settings.settingsBuilder().put("cluster.name", "wenbronk_escluster").build();client = TransportClient.builder().settings(settings).build().addTransportAddress(new InetSocketTransportAddress(new InetSocketAddress("192.168.50.37", 9300)));System.out.println("success to connect escluster");}/*** 使用get查询*/@Testpublic void testGet() {GetRequestBuilder requestBuilder = client.prepareGet("twitter", "tweet", "1");GetResponse response = requestBuilder.execute().actionGet();GetResponse getResponse = requestBuilder.get();ListenableActionFuture<GetResponse> execute = requestBuilder.execute();System.out.println(response.getSourceAsString());}/*** 使用QueryBuilder* termQuery("key", obj) 完全匹配* termsQuery("key", obj1, obj2..)   一次匹配多个值* matchQuery("key", Obj) 单个匹配, field不支持通配符, 前缀具高级特性* multiMatchQuery("text", "field1", "field2"..);  匹配多个字段, field有通配符忒行* matchAllQuery();         匹配所有文件*/@Testpublic void testQueryBuilder() {
//        QueryBuilder queryBuilder = QueryBuilders.termQuery("user", "kimchy");QueryBUilder queryBuilder = QueryBuilders.termQuery("user", "kimchy", "wenbronk", "vini");QueryBuilders.termsQuery("user", new ArrayList<String>().add("kimchy"));
//        QueryBuilder queryBuilder = QueryBuilders.matchQuery("user", "kimchy");
//        QueryBuilder queryBuilder = QueryBuilders.multiMatchQuery("kimchy", "user", "message", "gender");QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();searchFunction(queryBuilder);}/*** 组合查询* must(QueryBuilders) :   AND* mustNot(QueryBuilders): NOT* should:                  : OR*/@Testpublic void testQueryBuilder2() {QueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.termQuery("user", "kimchy")).mustNot(QueryBuilders.termQuery("message", "nihao")).should(QueryBuilders.termQuery("gender", "male"));searchFunction(queryBuilder);}/*** 只查询一个id的* QueryBuilders.idsQuery(String...type).ids(Collection<String> ids)*/@Testpublic void testIdsQuery() {QueryBuilder queryBuilder = QueryBuilders.idsQuery().ids("1");searchFunction(queryBuilder);}/*** 包裹查询, 高于设定分数, 不计算相关性*/@Testpublic void testConstantScoreQuery() {QueryBuilder queryBuilder = QueryBuilders.constantScoreQuery(QueryBuilders.termQuery("name", "kimchy")).boost(2.0f);searchFunction(queryBuilder);// 过滤查询
//        QueryBuilders.constantScoreQuery(FilterBuilders.termQuery("name", "kimchy")).boost(2.0f);}/*** disMax查询* 对子查询的结果做union, score沿用子查询score的最大值, * 广泛用于muti-field查询*/@Testpublic void testDisMaxQuery() {QueryBuilder queryBuilder = QueryBuilders.disMaxQuery().add(QueryBuilders.termQuery("user", "kimch"))  // 查询条件.add(QueryBuilders.termQuery("message", "hello")).boost(1.3f).tieBreaker(0.7f);searchFunction(queryBuilder);}/*** 模糊查询* 不能用通配符, 不知道干啥用*/@Testpublic void testFuzzyQuery() {QueryBuilder queryBuilder = QueryBuilders.fuzzyQuery("user", "kimch");searchFunction(queryBuilder);}/*** 父或子的文档查询*/@Testpublic void testChildQuery() {QueryBuilder queryBuilder = QueryBuilders.hasChildQuery("sonDoc", QueryBuilders.termQuery("name", "vini"));searchFunction(queryBuilder);}/*** moreLikeThisQuery: 实现基于内容推荐, 支持实现一句话相似文章查询* {   "more_like_this" : {   "fields" : ["title", "content"],   // 要匹配的字段, 不填默认_all"like_text" : "text like this one",   // 匹配的文本}   }     percent_terms_to_match：匹配项（term）的百分比，默认是0.3min_term_freq：一篇文档中一个词语至少出现次数，小于这个值的词将被忽略，默认是2max_query_terms：一条查询语句中允许最多查询词语的个数，默认是25stop_words：设置停止词，匹配时会忽略停止词min_doc_freq：一个词语最少在多少篇文档中出现，小于这个值的词会将被忽略，默认是无限制max_doc_freq：一个词语最多在多少篇文档中出现，大于这个值的词会将被忽略，默认是无限制min_word_len：最小的词语长度，默认是0max_word_len：最多的词语长度，默认无限制boost_terms：设置词语权重，默认是1boost：设置查询权重，默认是1analyzer：设置使用的分词器，默认是使用该字段指定的分词器*/@Testpublic void testMoreLikeThisQuery() {QueryBuilder queryBuilder = QueryBuilders.moreLikeThisQuery("user").like("kimchy");
//                            .minTermFreq(1)         //最少出现的次数
//                            .maxQueryTerms(12);        // 最多允许查询的词语searchFunction(queryBuilder);}/*** 前缀查询*/@Testpublic void testPrefixQuery() {QueryBuilder queryBuilder = QueryBuilders.matchQuery("user", "kimchy");searchFunction(queryBuilder);}/*** 查询解析查询字符串*/@Testpublic void testQueryString() {QueryBuilder queryBuilder = QueryBuilders.queryStringQuery("+kimchy");searchFunction(queryBuilder);}/*** 范围内查询*/public void testRangeQuery() {QueryBuilder queryBuilder = QueryBuilders.rangeQuery("user").from("kimchy").to("wenbronk").includeLower(true)     // 包含上界.includeUpper(true);      // 包含下届searchFunction(queryBuilder);}/*** 跨度查询*/@Testpublic void testSpanQueries() {QueryBuilder queryBuilder1 = QueryBuilders.spanFirstQuery(QueryBuilders.spanTermQuery("name", "葫芦580娃"), 30000);     // Max查询范围的结束位置  QueryBuilder queryBuilder2 = QueryBuilders.spanNearQuery()  .clause(QueryBuilders.spanTermQuery("name", "葫芦580娃")) // Span Term Queries  .clause(QueryBuilders.spanTermQuery("name", "葫芦3812娃"))  .clause(QueryBuilders.spanTermQuery("name", "葫芦7139娃"))  .slop(30000)                                               // Slop factor  .inOrder(false)  .collectPayloads(false);  // Span NotQueryBuilder queryBuilder3 = QueryBuilders.spanNotQuery()  .include(QueryBuilders.spanTermQuery("name", "葫芦580娃"))  .exclude(QueryBuilders.spanTermQuery("home", "山西省太原市2552街道"));  // Span Or   QueryBuilder queryBuilder4 = QueryBuilders.spanOrQuery()  .clause(QueryBuilders.spanTermQuery("name", "葫芦580娃"))  .clause(QueryBuilders.spanTermQuery("name", "葫芦3812娃"))  .clause(QueryBuilders.spanTermQuery("name", "葫芦7139娃"));  // Span Term  QueryBuilder queryBuilder5 = QueryBuilders.spanTermQuery("name", "葫芦580娃");  }/*** 测试子查询*/@Testpublic void testTopChildrenQuery() {QueryBuilders.hasChildQuery("tweet", QueryBuilders.termQuery("user", "kimchy")).scoreMode("max");}/*** 通配符查询, 支持 * * 匹配任何字符序列, 包括空* 避免* 开始, 会检索大量内容造成效率缓慢*/@Testpublic void testWildCardQuery() {QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("user", "ki*hy");searchFunction(queryBuilder);}/*** 嵌套查询, 内嵌文档查询*/@Testpublic void testNestedQuery() {QueryBuilder queryBuilder = QueryBuilders.nestedQuery("location", QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("location.lat", 0.962590433140581)).must(QueryBuilders.rangeQuery("location.lon").lt(36.0000).gt(0.000))).scoreMode("total");}/*** 测试索引查询*/@Testpublic void testIndicesQueryBuilder () {QueryBuilder queryBuilder = QueryBuilders.indicesQuery(QueryBuilders.termQuery("user", "kimchy"), "index1", "index2").noMatchQuery(QueryBuilders.termQuery("user", "kimchy"));}/*** 查询遍历抽取* @param queryBuilder*/private void searchFunction(QueryBuilder queryBuilder) {SearchResponse response = client.prepareSearch("twitter").setSearchType(SearchType.DFS_QUERY_THEN_FETCH).setScroll(new TimeValue(60000)).setQuery(queryBuilder).setSize(100).execute().actionGet();while(true) {response = client.prepareSearchScroll(response.getScrollId()).setScroll(new TimeValue(60000)).execute().actionGet();for (SearchHit hit : response.getHits()) {Iterator<Entry<String, Object>> iterator = hit.getSource().entrySet().iterator();while(iterator.hasNext()) {Entry<String, Object> next = iterator.next();System.out.println(next.getKey() + ": " + next.getValue());if(response.getHits().hits().length == 0) {break;}}}break;}
//        testResponse(response);}/*** 对response结果的分析* @param response*/public void testResponse(SearchResponse response) {// 命中的记录数long totalHits = response.getHits().totalHits();for (SearchHit searchHit : response.getHits()) {// 打分float score = searchHit.getScore();// 文章idint id = Integer.parseInt(searchHit.getSource().get("id").toString());// titleString title = searchHit.getSource().get("title").toString();// 内容String content = searchHit.getSource().get("content").toString();// 文章更新时间long updatetime = Long.parseLong(searchHit.getSource().get("updatetime").toString());}}/*** 对结果设置高亮显示*/public void testHighLighted() {/*  5.0 版本后的高亮设置* client.#().#().highlighter(hBuilder).execute().actionGet();HighlightBuilder hBuilder = new HighlightBuilder();hBuilder.preTags("<h2>");hBuilder.postTags("</h2>");hBuilder.field("user");        // 设置高亮显示的字段*/// 加入查询中SearchResponse response = client.prepareSearch("blog").setQuery(QueryBuilders.matchAllQuery()).addHighlightedField("user")        // 添加高亮的字段.setHighlighterPreTags("<h1>").setHighlighterPostTags("</h1>").execute().actionGet();// 遍历结果, 获取高亮片段SearchHits searchHits = response.getHits();for(SearchHit hit:searchHits){System.out.println("String方式打印文档搜索内容:");System.out.println(hit.getSourceAsString());System.out.println("Map方式打印高亮内容");System.out.println(hit.getHighlightFields());System.out.println("遍历高亮集合，打印高亮片段:");Text[] text = hit.getHighlightFields().get("title").getFragments();for (Text str : text) {System.out.println(str.string());}}}
}

高级Api番外篇

https://yq.aliyun.com/articles/70020

https://www.jb51.net/article/114215.htm

https://blog.csdn.net/tianyaleixiaowu/article/details/76149547

https://www.cnblogs.com/rainwang/p/5725214.html

NativeSearchQueryBuilder

可以配合Repository

@NoRepositoryBean
public interface ElasticsearchRepository<T, ID extends Serializable> extends ElasticsearchCrudRepository<T, ID> {  <S extends T> S index(S var1);  Iterable<T> search(QueryBuilder var1);  Page<T> search(QueryBuilder var1, Pageable var2);  Page<T> search(SearchQuery var1);  Page<T> searchSimilar(T var1, String[] var2, Pageable var3);  void refresh();  Class<T> getEntityClass();
}  

可以配合ElasticsearchTemplate

百万批量插入

我们经常需要往ElasticSearch中插入大量的测试数据来完成测试搜索，一条一条插肯定是不行的，ES提供了批量插入数据的功能——bulk。

前面讲过JPA的save方法也可以save（List）批量插值，但适用于小数据量，要完成超大数据的插入就要用ES自带的bulk了，可以迅速插入百万级的数据。

public void bulkIndex(List<Person> personList) {int counter = 0;try {if (!elasticsearchTemplate.indexExists(PERSON_INDEX_NAME)) {elasticsearchTemplate.createIndex(PERSON_INDEX_TYPE);}List<IndexQuery> queries = new ArrayList<>();for (Person person : personList) {IndexQuery indexQuery = new IndexQuery();indexQuery.setId(person.getId() + "");indexQuery.setObject(person);indexQuery.setIndexName(PERSON_INDEX_NAME);indexQuery.setType(PERSON_INDEX_TYPE);//上面的那几步也可以使用IndexQueryBuilder来构建//IndexQuery index = new IndexQueryBuilder().withId(person.getId() + "").withObject(person).build();queries.add(indexQuery);if (counter % 500 == 0) {elasticsearchTemplate.bulkIndex(queries);queries.clear();System.out.println("bulkIndex counter : " + counter);}counter++;}if (queries.size() > 0) {elasticsearchTemplate.bulkIndex(queries);}System.out.println("bulkIndex completed.");} catch (Exception e) {System.out.println("IndexerService.bulkIndex e;" + e.getMessage());throw e;}}

高亮查询+摘要

    public void shouldReturnHighlightedFieldsForGivenQueryAndFields() {//givenString documentId = randomNumeric(5);String actualMessage = "some test message";String highlightedMessage = "some <em>test</em> message";SampleEntity sampleEntity = SampleEntity.builder().id(documentId).message(actualMessage).version(System.currentTimeMillis()).build();IndexQuery indexQuery = getIndexQuery(sampleEntity);elasticsearchTemplate.index(indexQuery);elasticsearchTemplate.refresh(SampleEntity.class);SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("message", "test")).withHighlightFields(new HighlightBuilder.Field("message")).build();Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery, SampleEntity.class, new SearchResultMapper() {@Overridepublic <T> AggregatedPage<T> mapResults(SearchResponse response, Class<T> clazz, Pageable pageable) {List<SampleEntity> chunk = new ArrayList<SampleEntity>();for (SearchHit searchHit : response.getHits()) {if (response.getHits().getHits().length <= 0) {return null;}SampleEntity user = new SampleEntity();user.setId(searchHit.getId());user.setMessage((String) searchHit.getSource().get("message"));user.setHighlightedMessage(searchHit.getHighlightFields().get("message").fragments()[0].toString());chunk.add(user);}if (chunk.size() > 0) {return new AggregatedPageImpl<T>((List<T>) chunk);}return null;}});assertThat(sampleEntities.getContent().get(0).getHighlightedMessage(), is(highlightedMessage));}

六、问题总结

ES不允许root启动问题

出于安全考虑，默认es不允许以root用户启动

修改bin下脚本 elasticsearch，放开限制

ES_JAVA_OPTS="-Des.insecure.allow.root=true"

https://blog.csdn.net/napoay/article/details/53237471

远程无法访问9200、9300端口问题，本地可以

可以访问127.0.0.1:9200，但不能访问 公网IP:9200

修改配置文件 config/elasticsearch.yml

network.host: 0.0.0.0

设成0.0.0.0让任何人都可以访问。线上服务不要这样设置，要设成具体的 IP。

https://blog.csdn.net/u012599988/article/details/51767183

七、配置详解

https://www.cnblogs.com/hanyouchun/p/5163183.html

配置文件2.0版配置文件位于%ES_HOME%/config/elasticsearch.yml文件中，用Editplus打开它，你便可以进行配置。
所有的配置都可以使用环境变量，例如：
node.rack: ${RACK_ENV_VAR}
表示环境变量中有一个RACK_ENV_VAR变量。
下面列举一下elasticsearch的可配置项：
1. 集群名称，默认为elasticsearch：
cluster.name: elasticsearch
2. 节点名称，es启动时会自动创建节点名称，但你也可进行配置：
node.name: "Franz Kafka"
3. 是否作为主节点，每个节点都可以被配置成为主节点，默认值为true：
node.master: true
4. 是否存储数据，即存储索引片段，默认值为true：
node.data: true
master和data同时配置会产生一些奇异的效果：
1) 当master为false，而data为true时，会对该节点产生严重负荷；
2) 当master为true，而data为false时，该节点作为一个协调者；
3) 当master为false，data也为false时，该节点就变成了一个负载均衡器。
你可以通过连接http://localhost:9200/_cluster/health或者http://localhost:9200/_cluster/nodes，或者使用插件http://github.com/lukas-vlcek/bigdesk或http://mobz.github.com/elasticsearch-head来查看集群状态。
5. 每个节点都可以定义一些与之关联的通用属性，用于后期集群进行碎片分配时的过滤：
node.rack: rack314
6. 默认情况下，多个节点可以在同一个安装路径启动，如果你想让你的es只启动一个节点，可以进行如下设置：
node.max_local_storage_nodes: 1
7. 设置一个索引的碎片数量，默认值为5：
index.number_of_shards: 5
8. 设置一个索引可被复制的数量，默认值为1：
index.number_of_replicas: 1
当你想要禁用公布式时，你可以进行如下设置：
index.number_of_shards: 1
index.number_of_replicas: 0
这两个属性的设置直接影响集群中索引和搜索操作的执行。假设你有足够的机器来持有碎片和复制品，那么可以按如下规则设置这两个值：
1) 拥有更多的碎片可以提升索引执行能力，并允许通过机器分发一个大型的索引；
2) 拥有更多的复制器能够提升搜索执行能力以及集群能力。
对于一个索引来说，number_of_shards只能设置一次，而number_of_replicas可以使用索引更新设置API在任何时候被增加或者减少。
ElasticSearch关注加载均衡、迁移、从节点聚集结果等等。可以尝试多种设计来完成这些功能。
可以连接http://localhost:9200/A/_status来检测索引的状态。
9. 配置文件所在的位置，即elasticsearch.yml和logging.yml所在的位置：
path.conf: /path/to/conf
10. 分配给当前节点的索引数据所在的位置：
path.data: /path/to/data
可以可选择的包含一个以上的位置，使得数据在文件级别跨越位置，这样在创建时就有更多的自由路径，如：
path.data: /path/to/data1,/path/to/data2
11. 临时文件位置：
path.work: /path/to/work
12. 日志文件所在位置：
path.logs: /path/to/logs
13. 插件安装位置：
path.plugins: /path/to/plugins
14. 插件托管位置，若列表中的某一个插件未安装，则节点无法启动：
plugin.mandatory: mapper-attachments,lang-groovy
15. JVM开始交换时，ElasticSearch表现并不好：你需要保障JVM不进行交换，可以将bootstrap.mlockall设置为true禁止交换：
bootstrap.mlockall: true
请确保ES_MIN_MEM和ES_MAX_MEM的值是一样的，并且能够为ElasticSearch分配足够的内在，并为系统操作保留足够的内存。
16. 默认情况下，ElasticSearch使用0.0.0.0地址，并为http传输开启9200-9300端口，为节点到节点的通信开启9300-9400端口，也可以自行设置IP地址：
network.bind_host: 192.168.0.1
17. publish_host设置其他节点连接此节点的地址，如果不设置的话，则自动获取，publish_host的地址必须为真实地址：
network.publish_host: 192.168.0.1
18. bind_host和publish_host可以一起设置：
network.host: 192.168.0.1
19. 可以定制该节点与其他节点交互的端口：
transport.tcp.port: 9300
20. 节点间交互时，可以设置是否压缩，转为为不压缩：
transport.tcp.compress: true
21. 可以为Http传输监听定制端口：
http.port: 9200
22. 设置内容的最大长度：
http.max_content_length: 100mb
23. 禁止HTTP
http.enabled: false
24. 网关允许在所有集群重启后持有集群状态，集群状态的变更都会被保存下来，当第一次启用集群时，可以从网关中读取到状态，默认网关类型（也是推荐的）是local：
gateway.type: local
25. 允许在N个节点启动后恢复过程：
gateway.recover_after_nodes: 1
26. 设置初始化恢复过程的超时时间：
gateway.recover_after_time: 5m
27. 设置该集群中可存在的节点上限：
gateway.expected_nodes: 2
28. 设置一个节点的并发数量，有两种情况，一种是在初始复苏过程中：
cluster.routing.allocation.node_initial_primaries_recoveries: 4
另一种是在添加、删除节点及调整时：
cluster.routing.allocation.node_concurrent_recoveries: 2
29. 设置复苏时的吞吐量，默认情况下是无限的：
indices.recovery.max_size_per_sec: 0
30. 设置从对等节点恢复片段时打开的流的数量上限：
indices.recovery.concurrent_streams: 5
31. 设置一个集群中主节点的数量，当多于三个节点时，该值可在2-4之间：
discovery.zen.minimum_master_nodes: 1
32. 设置ping其他节点时的超时时间，网络比较慢时可将该值设大：
discovery.zen.ping.timeout: 3s
http://elasticsearch.org/guide/reference/modules/discovery/zen.html上有更多关于discovery的设置。
33. 禁止当前节点发现多个集群节点，默认值为true：
discovery.zen.ping.multicast.enabled: false
34. 设置新节点被启动时能够发现的主节点列表（主要用于不同网段机器连接）：
discovery.zen.ping.unicast.hosts: ["host1", "host2:port", "host3[portX-portY]"]
35.设置是否可以通过正则或者_all删除或者关闭索引
action.destructive_requires_name 默认false 允许 可设置true不允许