SpringBoot_持久化方案_Elasticsearch

深藏阁楼爱情的钟 2021-10-06 03:26 303阅读 0赞

### SpringBoot\_持久化方案\_Elasticsearch ###

*  方式一：TransportClient
 *   *  引入依赖
     *  ES配置
     *  配置文件
     *  初始化索引
     *  相关操作
     *   *  保存
         *  查询
 *  方式二：RestClient
 *   *  引入依赖
     *  配置文件application.yml
     *  配置源码
     *  创建索引
     *  查询

# 方式一：TransportClient #

ES提供的传统客户端，官方计划8.0版本删除此客户端

## 引入依赖 ##

<dependency>
    		<groupId>org.elasticsearch</groupId>
    		<artifactId>elasticsearch</artifactId>
    		<version>6.2.3</version>
    	</dependency>
    	<dependency>
    		<groupId>org.elasticsearch.client</groupId>
    		<artifactId>transport</artifactId>
    		<version>6.2.3</version>
    	</dependency>

## ES配置 ##

@Getter
    @Setter
    @Configuration
    @ConfigurationProperties(prefix = "elasticsearch")
    public class ElasticSearchConfig {
    	private String clusterName;
    	private String clusterNodes;
        /**
         * 使用elasticsearch实现类时才触发
         *
         * @return
         */
    	@Bean
        @ConditionalOnBean(value = EsServiceImpl.class)
    	public TransportClient getESClient() {
    		// 设置集群名字
    		Settings settings = Settings.builder().put("cluster.name", this.clusterName).build();
    		TransportClient client = new PreBuiltTransportClient(settings);
    		try {
    			// 读取的ip列表是以逗号分隔的
    			for (String clusterNode : this.clusterNodes.split(",")) {
    				String ip = clusterNode.split(":")[0];
    				String port = clusterNode.split(":")[1];
    				((TransportClient) client)
    						.addTransportAddress(new TransportAddress(InetAddress.getByName(ip), Integer.parseInt(port)));
    			}
    		} catch (UnknownHostException e) {
    			e.printStackTrace();
    		}
    		return client;
    	}
    }

## 配置文件 ##

elasticsearch:
      clusterName: elasticsearch
      clusterNodes: 127.0.0.1:9300

## 初始化索引 ##

private static final String INDEX = "index_logs"; //日志
    private static final String TYPE = "type_logs";
    
    @Autowired
    private TransportClient client;
    
    /**
     * 初始化日志es索引
     */
    @PostConstruct
    public void initIndex() {
    	LogService logService = applicationContext.getBean(LogService.class);//获取spring容器对象
    	// 日志实现是否采用elasticsearch
    	boolean flag = (logService instanceof EsLogServiceImpl);
    	if (!flag) {
    		return;
    	}
    
    	try {
    		// 判断索引是否存在
    		IndicesExistsResponse indicesExistsResponse = client.admin().indices()
    				.exists(new IndicesExistsRequest(INDEX)).get();
    		if (indicesExistsResponse.isExists()) {
    			return;
    		}
    	} catch (InterruptedException e) {
    		e.printStackTrace();
    	} catch (ExecutionException e) {
    		e.printStackTrace();
    	}
    	
    	CreateIndexRequestBuilder requestBuilder = client.admin().indices().prepareCreate(INDEX);
    	
    	CreateIndexResponse createIndexResponse = requestBuilder.execute().actionGet();
    	if (createIndexResponse.isAcknowledged()) {
    		logger.info("索引：{},创建成功", INDEX);
    	} else {
    		logger.error("索引：{},创建失败", INDEX);
    	}
    }

## 相关操作 ##

### 保存 ###

private static final String INDEX = "index_logs"; //日志
    private static final String TYPE = "type_logs";
    
    @Autowired
    private TransportClient client;
    
    // ========代码示例========
    String string = JSONObject.toJSONString(log);
    IndexRequestBuilder builder = client.prepareIndex(INDEX, TYPE).setSource(string, XContentType.JSON);
    builder.execute();

### 查询 ###

private static final String INDEX = "index_logs"; //日志
    private static final String TYPE = "type_logs";
    
    @Autowired
    private TransportClient client;
    
    // ========代码示例========
    SearchRequestBuilder builder = client.prepareSearch().setIndices(INDEX).setTypes(TYPE);
    BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
    //查询条件拼装
    queryBuilder.must(QueryBuilders.wildcardQuery("username", "*" + username + "*"));//模糊查询
    queryBuilder.must(QueryBuilders.matchQuery("flag", bool));//精确查询
    queryBuilder.must(QueryBuilders.rangeQuery("createTime").from(toTimestamp(2019-02-19T00:00:00)));//查询创建时间大于2019-02-19 00:00:00
    queryBuilder.must(QueryBuilders.rangeQuery("createTime").to(toTimestamp(2019-02-20T23:59:59)));//并且创建时间小于2019-02-20 23:59:59
    //封装请求对象
    builder.setPostFilter(queryBuilder);
    //排序和分页
    builder.addSort("createTime", SortOrder.DESC);//根据createTime字段值降序查询列表
    builder.setFrom(start);//分页查询 第一页为0
    builder.setSize(length);//查询记录数据
    //高亮查询---选用
    HighlightBuilder highlightBuilder=new HighlightBuilder();
    highlightBuilder.preTags("<span style=\"color:red\">");
    highlightBuilder.postTags("</span>");
    highlightBuilder.field("title");//设置查询字段
    builder.highlighter(highlightBuilder);
    //获取响应数据
    SearchResponse searchResponse = builder.get();
    SearchHits searchHits = searchResponse.getHits();
    Long total = searchHits.getTotalHits();//查询到的记录数
    int size = searchHits.getHits().length;
    List<Log> list = new ArrayList<Log>(size);//查询的list数据
    if (size > 0) {
        //封装数据
    	searchHits.forEach(hit -> {
    		String val = hit.getSourceAsString();//获取查询原数据
    		//高亮查询---选用
    		Map<String, HighlightField> highlightFields = hit.getHighlightFields();//获取高亮数据
    		HighlightField highlightField = highlightFields.get("title");
    		Text[] texts = highlightField.getFragments();
    		String title = "";
    		for (Text text : texts) {
    			title += text;
    		}
    		Log parseObject = JSONObject.parseObject(val, Log.class);
    		//高亮查询---选用
    		parseObject .setTitle(title);
    		list.add(parseObject );
    	});
    }
    
    //格式yyyy-MM-ddT00:00:00     yyyy-MM-ddT23:59:59
    private Long toTimestamp(String str) {
    	LocalDateTime localDateTime = LocalDateTime.parse(str);
    	Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    	return date.getTime();
    }

# 方式二：RestClient #

RestClient是官方推荐使用的，它包括两种：Java Low Level REST Client和 Java High Level REST Client。  
ES在6.0之后提供 Java High Level REST Client， 两种客户端官方更推荐使用 Java High Level REST Client，不过当前它还处于完善中，有些功能还没有。

## 引入依赖 ##

<dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch‐rest‐high‐level‐client</artifactId>
        <version>6.2.1</version>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>6.2.1</version>
    </dependency>

## 配置文件application.yml ##

plxc:
      elasticsearch:
        hostlist: ${eshostlist:127.0.0.1:9200} #多个结点中间用逗号分隔
      course:
        index: xc_course
        type: doc
        source_field: id,name,grade,mt,st,charge,valid,pic,qq,price,price_old,status,studymodel,teachmode,expires,pub_time,start_time,end_time
      media:
        index: xc_course_media
        type: doc
        source_field: courseid,media_id,media_url,teachplan_id,media_fileoriginalname

## 配置源码 ##

import org.apache.http.HttpHost;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    
    @Configuration
    public class ElasticsearchConfig {
    
        @Value("${xuecheng.elasticsearch.hostlist}")
        private String hostlist;
    
        @Bean
        public RestHighLevelClient restHighLevelClient(){
            //解析hostlist配置信息
            String[] split = hostlist.split(",");
            //创建HttpHost数组，其中存放es主机和端口的配置信息
            HttpHost[] httpHostArray = new HttpHost[split.length];
            for(int i=0;i<split.length;i++){
                String item = split[i];
                httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
            }
            //创建RestHighLevelClient客户端
            return new RestHighLevelClient(RestClient.builder(httpHostArray));
        }
    
        //项目主要使用RestHighLevelClient，对于低级的客户端暂时不用
        @Bean
        public RestClient restClient(){
            //解析hostlist配置信息
            String[] split = hostlist.split(",");
            //创建HttpHost数组，其中存放es主机和端口的配置信息
            HttpHost[] httpHostArray = new HttpHost[split.length];
            for(int i=0;i<split.length;i++){
                String item = split[i];
                httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
            }
            return RestClient.builder(httpHostArray).build();
        }
    
    }

## 创建索引 ##

@SpringBootTest
    @RunWith(SpringRunner.class)
    public class TestIndex {
    
        @Autowired
        RestHighLevelClient client;
    
        @Autowired
        RestClient restClient;
    
        //创建索引库
        @Test
        public void testCreateIndex() throws IOException {
            //创建索引对象
            CreateIndexRequest createIndexRequest = new CreateIndexRequest("xc_course");
            //设置参数
            createIndexRequest.settings(Settings.builder().put("number_of_shards","1").put("number_of_replicas","0"));
            //指定映射
            createIndexRequest.mapping("doc"," {\n" +
                    " \t\"properties\": {\n" +
                    "            \"studymodel\":{\n" +
                    "             \"type\":\"keyword\"\n" +
                    "           },\n" +
                    "            \"name\":{\n" +
                    "             \"type\":\"keyword\"\n" +
                    "           },\n" +
                    "           \"description\": {\n" +
                    "              \"type\": \"text\",\n" +
                    "              \"analyzer\":\"ik_max_word\",\n" +
                    "              \"search_analyzer\":\"ik_smart\"\n" +
                    "           },\n" +
                    "           \"pic\":{\n" +
                    "             \"type\":\"text\",\n" +
                    "             \"index\":false\n" +
                    "           }\n" +
                    " \t}\n" +
                    "}", XContentType.JSON);
            //操作索引的客户端
            IndicesClient indices = client.indices();
            //执行创建索引库
            CreateIndexResponse createIndexResponse = indices.create(createIndexRequest);
            //得到响应
            boolean acknowledged = createIndexResponse.isAcknowledged();
            System.out.println(acknowledged);
    
        }
    
        //删除索引库
        @Test
        public void testDeleteIndex() throws IOException {
            //删除索引对象
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("xc_course");
            //操作索引的客户端
            IndicesClient indices = client.indices();
            //执行删除索引
            DeleteIndexResponse delete = indices.delete(deleteIndexRequest);
            //得到响应
            boolean acknowledged = delete.isAcknowledged();
            System.out.println(acknowledged);
    
        }
    
        //添加文档
        @Test
        public void testAddDoc() throws IOException {
            //文档内容
            //准备json数据
            Map<String, Object> jsonMap = new HashMap<>();
            jsonMap.put("name", "spring cloud实战");
            jsonMap.put("description", "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。");
            jsonMap.put("studymodel", "201001");
            SimpleDateFormat dateFormat =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            jsonMap.put("timestamp", dateFormat.format(new Date()));
            jsonMap.put("price", 5.6f);
    
            //创建索引创建对象
            IndexRequest indexRequest = new IndexRequest("xc_course","doc");
            //文档内容
            indexRequest.source(jsonMap);
            //通过client进行http的请求
            IndexResponse indexResponse = client.index(indexRequest);
            DocWriteResponse.Result result = indexResponse.getResult();
            System.out.println(result);
    
        }
    
        //查询文档
        @Test
        public void testGetDoc() throws IOException {
            //查询请求对象
            GetRequest getRequest = new GetRequest("xc_course","doc","tzk2-mUBGsEnDOUe482B");
            GetResponse getResponse = client.get(getRequest);
            //得到文档的内容
            Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();
            System.out.println(sourceAsMap);
        }
    }

## 查询 ##

@SpringBootTest
    @RunWith(SpringRunner.class)
    public class TestSearch {
    
        @Autowired
        RestHighLevelClient client;
    
        @Autowired
        RestClient restClient;
    
    
        //搜索全部记录
        @Test
        public void testSearchAll() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //搜索方式
            //matchAllQuery搜索全部
            searchSourceBuilder.query(QueryBuilders.matchAllQuery());
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
        //分页查询
        @Test
        public void testSearchPage() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //设置分页参数
            //页码
            int page = 1;
            //每页记录数
            int size = 1;
            //计算出记录起始下标
            int from  = (page-1)*size;
            searchSourceBuilder.from(from);//起始记录下标，从0开始
            searchSourceBuilder.size(size);//每页显示的记录数
            //搜索方式
            //matchAllQuery搜索全部
            searchSourceBuilder.query(QueryBuilders.matchAllQuery());
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
    
        //TermQuery
        @Test
        public void testTermQuery() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //设置分页参数
            //页码
            int page = 1;
            //每页记录数
            int size = 1;
            //计算出记录起始下标
            int from  = (page-1)*size;
            searchSourceBuilder.from(from);//起始记录下标，从0开始
            searchSourceBuilder.size(size);//每页显示的记录数
            //搜索方式
            //termQuery
            searchSourceBuilder.query(QueryBuilders.termQuery("name","spring"));
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
        //根据id查询
        @Test
        public void testTermQueryByIds() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //搜索方式
            //根据id查询
            //定义id
            String[] ids = new String[]{"1","2"};
            searchSourceBuilder.query(QueryBuilders.termsQuery("_id",ids));
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
    
        //MatchQuery
        @Test
        public void testMatchQuery() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //搜索方式
            //MatchQuery
            searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开发框架")
                    .minimumShouldMatch("80%"));
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
        //MultiMatchQuery
        @Test
        public void testMultiMatchQuery() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //搜索方式
            //MultiMatchQuery
            searchSourceBuilder.query(QueryBuilders.multiMatchQuery("spring css","name","description")
                    .minimumShouldMatch("50%")
                    .field("name",10));
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
    
        //BoolQuery
        @Test
        public void testBoolQuery() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //boolQuery搜索方式
            //先定义一个MultiMatchQuery
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring css", "name", "description")
                    .minimumShouldMatch("50%")
                    .field("name", 10);
            //再定义一个termQuery
            TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("studymodel", "201001");
    
            //定义一个boolQuery
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.must(multiMatchQueryBuilder);
            boolQueryBuilder.must(termQueryBuilder);
    
            searchSourceBuilder.query(boolQueryBuilder);
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
        //filter
        @Test
        public void testFilter() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //boolQuery搜索方式
            //先定义一个MultiMatchQuery
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring css", "name", "description")
                    .minimumShouldMatch("50%")
                    .field("name", 10);
    
            //定义一个boolQuery
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.must(multiMatchQueryBuilder);
            //定义过虑器
            boolQueryBuilder.filter(QueryBuilders.termQuery("studymodel","201001"));
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(90).lte(100));
    
            searchSourceBuilder.query(boolQueryBuilder);
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
        //Sort
        @Test
        public void testSort() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //boolQuery搜索方式
            //定义一个boolQuery
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            //定义过虑器
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
    
            searchSourceBuilder.query(boolQueryBuilder);
            //添加排序
            searchSourceBuilder.sort("studymodel", SortOrder.DESC);
            searchSourceBuilder.sort("price", SortOrder.ASC);
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    
        //Highlight
        @Test
        public void testHighlight() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //boolQuery搜索方式
            //先定义一个MultiMatchQuery
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("开发框架", "name", "description")
                    .minimumShouldMatch("50%")
                    .field("name", 10);
    
            //定义一个boolQuery
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.must(multiMatchQueryBuilder);
            //定义过虑器
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
    
            searchSourceBuilder.query(boolQueryBuilder);
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
    
            //设置高亮
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.preTags("<tag>");
            highlightBuilder.postTags("</tag>");
            highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
    //        highlightBuilder.fields().add(new HighlightBuilder.Field("description"));
            searchSourceBuilder.highlighter(highlightBuilder);
    
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                //源文档的name字段内容
                String name = (String) sourceAsMap.get("name");
                //取出高亮字段
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                if(highlightFields!=null){
                    //取出name高亮字段
                    HighlightField nameHighlightField = highlightFields.get("name");
                    if(nameHighlightField!=null){
                        Text[] fragments = nameHighlightField.getFragments();
                        StringBuffer stringBuffer = new StringBuffer();
                        for(Text text:fragments){
                            stringBuffer.append(text);
                        }
                        name = stringBuffer.toString();
                    }
                }
    
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }
    }