#创建索引库：
curl -XPUT http://192.168.9.11:9200/bjsxt/

#创建document：
curl -XPOST http://192.168.9.11:9200/bjsxt/employee -d '
{
	"first_name" : "bin",
	"last_name" : "tang",
	"age" : 33,
	"about" : "I love to go rock climbing",
	"interests": [ "sports", "music" ]
}'

#更新document：
curl -XPUT http://192.168.9.11:9200/bjsxt/employee/1 -d '
{
	"first_name" : "bin",
	"last_name" : "pang",
	"age" : 30,
	"about" : "I love to go rock climbing",
	"interests": [ "sports", "music" ]
}'


PUT 和 POST 都是新增,修改。PUT必须指定ID，所以PUT一般数据更新 。POST 可以指定ID，也可以不指定 做新增比较好。

#根据document的id来查询数据：
curl -XGET http://192.168.9.11:9200/bjsxt/employee/1?pretty

#根据field来查询数据：
curl -XGET http://192.168.239.3:9200/bjsxt/employee/_search?q=first_name="bin"

#根据field来查询数据：match
curl -XGET http://192.168.239.3:9200/bjsxt/book/_search -d '
{
	"query":
		{"match":
			{"name":"hadoop"}
		}
}'



#对多个field发起查询：multi_match
curl -XGET http://192.168.239.3:9200/bjsxt/employee/_search -d '
{
	"query":
		{"multi_match":
			{
				"query":"John",
				"fields":["last_name","first_name"],
				"operator":"or"
			}
		}
}'


#多个term对多个field发起查询:bool（boolean） 
#	组合查询，must，must_not,should 
#		must + must : 交集
#		must +must_not ：差集
#		should+should  : 并集

curl -XGET http://192.168.239.3:9200/bjsxt/employee/_search -d '
{
	"query":
		{"bool" :
			{
				"must" : 
					{"match":
						{"first_name":"bin"}
					},
				"must" : 
					{"match":
						{"age":33}
					}
			}
		}
}'

##查询first_name=bin的，或者年龄在20岁到30岁之间的

curl -XGET http://192.168.239.3:9200/bjsxt/employee/_search -d '
{
	"query":
		{"bool" :
			{
			"must" :
				{"term" : 
					{ "first_name" : "bin" }
				}
			,
			"must_not" : 
				{"range":
					{"age" : { "from" : 20, "to" : 30 }
				}
			}
			}
		}
}'


#修改配置
curl -XPUT 'http://192.168.239.3:9200/test2/' -d'{"settings":{"number_of_replicas":2}}'



curl -XPOST http://192.168.239.3:9200/bjsxt/person/_mapping -d'
{
    "person": {
        "properties": {
            "content": {
                "type": "string",
                "store": "no",
                "term_vector": "with_positions_offsets",
                "analyzer": "ik_max_word",
                "search_analyzer": "ik_max_word",
                "include_in_all": "true",
                "boost": 8
            }
        }
    }
}'

ES JAVA API

    添加maven依赖

 连接到es集

        1：通过TransportClient这个接口，我们可以不启动节点就可以和es集群进行通信，它需要指定es集群中其中一台或多台机的ip地址和端口

TransportClient client = new TransportClient().addTransportAddress(new InetSocketTransportAddress("host1", 9300))
                                              .addTransportAddress(new InetSocketTransportAddress("host2", 9300));

        如果需要使用其他名称的集群（默认是elasticsearch），需要如下设置

Settings settings = ImmutableSettings.settingsBuilder().put("cluster.name", "myClusterName").build();
TransportClient client = new TransportClient(settings).addTransportAddress(new InetSocketTransportAddress("host1", 9300));

        2：通过TransportClient这个接口，开启自动嗅探整个集群的状态，es会自动把集群中其它机器的ip地址加到客户端中

Settings settings = ImmutableSettings.settingsBuilder().put("client.transport.sniff", true).build();
TransportClient client = new TransportClient(settings).addTransportAddress(new InetSocketTransportAddress("host1", 9300));

索引index（四种json,map,bean,es helpers）

IndexResponse response = client.prepareIndex(“bjsxt", "emp", "1").setSource().execute().actionGet();

查询get

GetResponse response = client.prepareGet(“bjsxt", "emp", "1").execute().actionGet();

 更新update， 更新或者插入upsert

删除delete

DeleteResponse response = client.prepareDelete(“bjsxt", "emp", "1").execute().actionGet();

总数count

long count = client.prepareCount(“bjsxt").execute().get().getCount();

查询search

        SearchType

 .setQuery(QueryBuilders.matchQuery("name", "test"))

.setFrom(0).setSize(1)

.addSort("age", SortOrder.DESC)

.setPostFilter(FilterBuilders.rangeFilter("age").from(1).to(19))

搜索引擎例子：

       先用爬虫将网站数据爬下来，在将数据导入ES中，建立索引，前端传来搜索关键字，返回结果（url，文章标题，关键字部分的摘要）

步骤：

    1、爬虫下载所有的网页文件（原始数据）

    2、把每个网页抽取其中有用的数据

    title

    content

    url

    3、把抽取之后的数据分词索引（ES）

    4、搜索（ES）

    分页，高亮，结果片段

    5、索引更新：

            1、重新创建新索引库，让后在某个时间点替换老的库

            file.rname()

            2、实时更新，要个有新的数据过来，通过API更新其中一个doc (协处理器)

爬数据：

       。。。。。。

处理数据与搜索：

IndexService  ： 处理索引建立与搜索查询

package com.laoxiao.es;

import java.io.File;
import java.net.InetAddress;
import java.util.HashMap;
import java.util.Map;

import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.Requests;
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.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryParser;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.junit.Test;
import org.springframework.stereotype.Service;

import com.laoxiao.util.HtmlTool;

@Service
public class IndexService {

	//存放html文件的目录
	public static String DATA_DIR="D:\\data\\";
	
	public static Client client;

	static {
		Settings settings = Settings.settingsBuilder()
				.put("cluster.name", "bjsxt").build();
		try {
			client = TransportClient
					.builder()
					.settings(settings)
					.build()
					.addTransportAddress(
							new InetSocketTransportAddress(InetAddress
									.getByName("node1"), 9300))
					.addTransportAddress(
							new InetSocketTransportAddress(InetAddress
									.getByName("node2"), 9300))
					.addTransportAddress(
							new InetSocketTransportAddress(InetAddress
									.getByName("node3"), 9300));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * admin():管理索引库的。client.admin().indices()
	 * 
	 * 索引数据的管理：client.prepare
	 * 
	 */
	@Test
	public void createIndex() throws Exception {
		IndicesExistsResponse resp = client.admin().indices().prepareExists("bjsxt").execute().actionGet();
		if(resp.isExists()){
			client.admin().indices().prepareDelete("bjsxt").execute().actionGet();
		}
		client.admin().indices().prepareCreate("bjsxt").execute().actionGet();

		new XContentFactory();

		XContentBuilder builder = XContentFactory.jsonBuilder().startObject()
				.startObject("htmlbean").startObject("properties")
				.startObject("title").field("type", "string")
				.field("store", "yes").field("analyzer", "ik_max_word")
				.field("search_analyzer", "ik_max_word").endObject()
				.startObject("content").field("type", "string")
				.field("store", "yes").field("analyzer", "ik_max_word")
				.field("search_analyzer", "ik_max_word").endObject()
//				.startObject("url").field("type", "string")
//				.field("store", "yes").field("analyzer", "ik_max_word")
//				.field("search_analyzer", "ik_max_word").endObject()
				.endObject().endObject().endObject();
		PutMappingRequest mapping = Requests.putMappingRequest("bjsxt").type("htmlbean").source(builder);
		client.admin().indices().putMapping(mapping).actionGet();

	}
	
	/**
	 * 把源数据html文件添加到索引库中（构建索引文件）
	 */
	@Test
	public void addHtmlToES(){
		readHtml(new File(DATA_DIR));
	}
	
	/**
	 * 遍历数据文件目录d:/data ，递归方法
	 * @param file
	 */
	public void readHtml(File file){
		if(file.isDirectory()){
			File[]  fs =file.listFiles();
			for (int i = 0; i < fs.length; i++) {
				File f = fs[i];
				readHtml(f);
			}
		}else{
			HtmlBean bean;
			try {
				bean = HtmlTool.parserHtml(file.getPath());
				if(bean!=null){
					Map<String, String> dataMap =new HashMap<String, String>();
					dataMap.put("title", bean.getTitle());
					dataMap.put("content", bean.getContent());
					dataMap.put("url", bean.getUrl());
					//写索引
					client.prepareIndex("bjsxt", "htmlbean").setSource(dataMap).execute().actionGet();
				}
			} catch (Throwable e) {
				e.printStackTrace();
			}
			
		}
	}
	
	/**
	 * 搜索
	 * @param kw
	 * @param num
	 * @return
	 */
	public PageBean<HtmlBean> search(String kw,int num,int count){
		PageBean<HtmlBean> wr =new PageBean<HtmlBean>();
		wr.setIndex(num);
//		//构建查询条件
//		MatchQueryBuilder q1 =new MatchQueryBuilder("title", kw);
//		MatchQueryBuilder q2 =new MatchQueryBuilder("content", kw);
//		
//		//构建一个多条件查询对象
//		BoolQueryBuilder q =new BoolQueryBuilder(); //组合查询条件对象
//		q.should(q1);
//		q.should(q2);
		
//		RangeQueryBuilder q1 =new RangeQueryBuilder("age");
//		q1.from(18);
//		q1.to(40);
		
		MultiMatchQueryBuilder q =new MultiMatchQueryBuilder(kw, new String[]{"title","content"});
		SearchResponse resp=null;
		if(wr.getIndex()==1){
			resp = client.prepareSearch("bjsxt")
					.setTypes("htmlbean")
					.setQuery(q)
					.addHighlightedField("title")
					.addHighlightedField("content")
					.setHighlighterPreTags("<font color=\"red\">")
					.setHighlighterPostTags("</font>")
					.setHighlighterFragmentSize(14)//设置显示结果中一个碎片段的长度
					.setHighlighterNumOfFragments(3)//设置显示结果中每个结果最多显示碎片段，每个碎片段之间用...隔开
					.setFrom(0)
					.setSize(10)
					.execute().actionGet();
			
		}else{
			wr.setTotalCount(count);
			resp = client.prepareSearch("bjsxt")
					.setTypes("htmlbean")
					.setQuery(q)
					.addHighlightedField("title")
					.addHighlightedField("content")
					.setHighlighterPreTags("<font color=\"red\">")
					.setHighlighterPostTags("</font>")
					.setHighlighterFragmentSize(14)
					.setHighlighterNumOfFragments(3)
					.setFrom(wr.getStartRow())
					.setSize(10)
					.execute().actionGet();
		}
		SearchHits hits= resp.getHits();
		wr.setTotalCount((int)hits.getTotalHits());
		
		for(SearchHit hit : hits.getHits()){
			HtmlBean bean =new HtmlBean();
			if(hit.getHighlightFields().get("title")==null){//title中没有包含关键字
				bean.setTitle(hit.getSource().get("title").toString());//获取原来的title（没有高亮的title）
			}else{
				bean.setTitle(hit.getHighlightFields().get("title").getFragments()[0].toString());
			}
			if(hit.getHighlightFields().get("content")==null){//title中没有包含关键字
				bean.setContent(hit.getSource().get("content").toString());//获取原来的title（没有高亮的title）
			}else{
				StringBuilder sb =new StringBuilder();
				for(Text text: hit.getHighlightFields().get("content").getFragments()){
					sb.append(text.toString()+"...");
				}
				bean.setContent(sb.toString());
			}
			
			bean.setUrl(hit.getSource().get("url").toString());
			wr.setBean(bean);
			
		}
		
		
		return wr;
	}
}

HtmlBean ： 一个html里数据的封装类

package com.laoxiao.es;

public class HtmlBean {

	private int id;
	private String title;
	private String content;
	private String url;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	
}

HtmlTool ： html工具类

package com.laoxiao.util;

import java.io.File;

import com.laoxiao.es.HtmlBean;
import com.laoxiao.es.IndexService;

import net.htmlparser.jericho.CharacterReference;
import net.htmlparser.jericho.Element;
import net.htmlparser.jericho.HTMLElementName;
import net.htmlparser.jericho.Source;

public class HtmlTool {

	
	/**
	 * 
	 * @param path html 文件路径
	 */
	public static HtmlBean parserHtml(String path)throws Throwable{
		HtmlBean bean  =new HtmlBean();
		Source source=new Source(new File(path));
		// Call fullSequentialParse manually as most of the source will be parsed.
		source.fullSequentialParse();
		Element titleElement=source.getFirstElement(HTMLElementName.TITLE);
		if(titleElement==null){
			return null;
		}else{
			String title=CharacterReference.decodeCollapseWhiteSpace(titleElement.getContent());
			bean.setTitle(title);
		}
		String content =source.getTextExtractor().setIncludeAttributes(true).toString();
		
		String url =path.substring(IndexService.DATA_DIR.length());
		bean.setContent(content);
		bean.setUrl(url);
		return bean;
  }
	
	public static void main(String[] args) {
		try {
			parserHtml("D:/data/www.sxt.cn/blog-category-7.html");
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

Elasticsearch的优化

        1、调大系统的"最大打开文件数",建议32K甚至是64K

                    ulimit -a (查看)

                    ulimit -n 32000(设置)

        2、修改配置文件调整ES的JVM内存大小

                    1：修改bin/elasticsearch.in.sh中ES_MIN_MEM和ES_MAX_MEM的大小，

                        建议设置一样大，避免频繁的分配内存，根据服务器内存大小，一般分配60%左右(默认256M)

                    2：如果使用searchwrapper插件启动es的话则修改bin/service/elasticsearch.conf(默认1024M)

        3、设置mlockall来锁定进程的物理内存地址

                    避免交换（swapped）来提高性能

                    修改文件conf/elasticsearch.yml

                            boostrap.mlockall: true

        4、分片多的话，可以提升建立索引的能力，5-20个比较合适。

                    如果分片数过少或过多，都会导致检索比较慢。

                    分片数过多会导致检索时打开比较多的文件，另外也会导致多台服务器之间通讯。

                    而分片数过少会导至单个分片索引过大，所以检索速度慢。建议单个分片最多存储20G左右的索引数据，所以，分片数量=数据总量/20G

       5、 副本多的话，可以提升搜索的能力，但是如果设置很多副本的话也会对服务器造成额外的压力，因为需要同步数据。所以建议设置2-3个即可。

       6、要定时对索引进行优化，不然segment越多，查询的性能就越差，索引量不是很大的话情况下可以将segment设置为1

                    curl -XPOST 'http://localhost:9200/bjsxt/_optimize?max_num_segments=1'

                    java代码：client.admin().indices().prepareOptimize(“bjsxt").setMaxNumSegments(1).get();