ElaticSearch

最新推荐文章于 2024-03-28 11:03:04 发布

javashareauthor

最新推荐文章于 2024-03-28 11:03:04 发布

阅读量940

点赞数

分类专栏： ElasticSearch 文章标签： ElasticSearch

本文链接：https://blog.csdn.net/javashareauthor/article/details/90241087

版权

ElasticSearch 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

ElaticSearch介绍

一个实时的分布式搜索和分析引擎。设计用于云计算，能够达到实时搜索，稳定，可靠，快速，方便安装,且基于restful接口。

ElaticSearch与数据库的比较

Database(数据库)	Index(索引库)
Table(表)	Type(类型)
Row(行)	document(文档)
Col(列)	filed(字段)

安装（windows的环境安装ElasticSearch6.7版本）PS->linux下的安装类似

1、下载ElasticSearch压缩包，然后解压

2、修改config下的elasticsearch.yml文件

设置node.name
设置cluster.name
设置 network.host

3、点击bin目录下的elasticsearch.bat进行启动。

4、测试，浏览器输入地址：http://192.168.5.61:9200/，如果打印如下结果，那么安装成功

5、安装kibana-6.7.2可视化插件，下载好kibana-6.7.2，然后在config下的kibana.yml文件做如下修改：

server.port: 5601

server.host: "192.168.5.61"

elasticsearch.hosts: ["http://192.168.5.61:9200"]

6、测试插件，在本地浏览器中输入http://192.168.5.61:5601，如果看到以下截图，说明插件安装成功

7、将ElasticSearch 安装成Windows服务（Service），切换到ElasticSearch的bin目录，执行service.bat install

8、启动ElasticSearch服务 service.bat start

9、在run界面，输入 services.msc，查看ElasticSearch服务

常用命令（如果需要测试如下命令，可以在dos窗口和kibana可视化插件进行测试，由于dos窗口每次对elasticsearch操作的时候，需要输入ip和端口，如：http://192.168.5.61:9200/_cat/health?v，然而在插件进行操作的时候，不需要输入ip和端口，因为这些都在配置文件配置好了。因此建议在插件进行操作，截图如下：

1、查看健康状态

get /_cat/health?v

2、创建索引

Put 索引名称

3、插入数据

格式如下：

PUT /index_name/type_name/doc_id 
{
 "key1": "value1", "key2": "value2", "key3": "value3" ...... 
}

案例如下：

put /mytest/user/1
{
  "name":"zhangsan",
  "age":"24"
}

备注：mytest是索引名称，user是类型名称，1是id

不指定文档id上传，系统会生成一个唯一的文档id如：

put /mytest/user
{
  "name":"zhangsan",
  "age":"24"
}

4、修改文档

文档在ElasticSearch中是不可变，修改文档的逻辑是新建一个文档覆盖旧文档。

PUT  /index_name/type_name/doc_id
{
     "key11": "value11",
     "key22": "value22",
     "key33": "value33"
}

响应中_version字段会加一。

5、删除文档

DELETE /index_name/type_name/doc_id

6、删除索引

DELETE /index_name

7、删除多个索引

DELETE /index_name1, index_name2

8、删除所有的索引

DELETE /_all

9、修改索引设置

PUT /index_name/_setting
{
    "number_of_replicas": 1
}

修改index_name的索引，设置备份分片为1

10、打开或关闭索引

POST /index_name/_close
{
}

关闭索引，搜索时只能显示元数据不能显示具体的数据

POST /index_name/_open
{
}

开启索引，可以搜索的具体的数据

11、空搜索

GET /_search

没有指定任何查询条件，只返回索引中的所有文档

12、多索引搜索

GET /index_1,index_2/_search

在index index_1和index_2中搜索

GET /index_name/type_name/doc_id/_source

只获取指定id的source内容，会忽略元信息

GET /index_1,index_2/type_1,type_2/_search

在indexindex_1和index_2中搜索类型type_1和type_2

13、分页

GET /_search?size=5&from=5

使用size和from进行分页

14、条件搜索

GET /_all/index_name/_search?q=filed_name:field_value

搜索所有索引中类型为index_name索引中filed_name中包含filed_value的文档。

注意: 1、索引库得名称必须全部小写，不能以下划线开头，也不能包含逗号。

2、7.0之前默认会创建5个shared,7.0开始之后创建一个shard。

3、再ES6.0之后，一个index对应一个type。

健康状态值

Green（代表正常）

Yellow（代表正常，但是一些副本还没有分配）

Red（非正常）

Java客户端连接ES

Java客户端连接ES主要两种实现方式，Elasticsearch(ES)有两种连接方式：transport、rest。transport通过TCP方式访问ES(只支持java),rest方式通过http API 访问ES(没有语言限制)。

TransportClient

步骤1：获取client；

步骤2：执行对应的增、删、改、查操作。

查询使用参考（以下我已经验证过，好用ok）：

/**
* Query Search
* @param index
* @param type
* @param term
* @param queryString
*/
private static void querySearch(String index, String type,String term,String queryString){
Client client = createTransportClient();
SearchResponse response = client.prepareSearch(index)
  .setTypes(type)
  // 设置查询类型
// 1.SearchType.DFS_QUERY_THEN_FETCH = 精确查询
// 2.SearchType.SCAN = 扫描查询,无序
// 3.SearchType.COUNT = 不设置的话,这个为默认值,还有的自己去试试吧
  .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
  // 设置查询关键词
  .setQuery(QueryBuilders.matchQuery(term, queryString))
  .addHighlightedField(term)
  .setHighlighterPreTags("<em>")
  .setHighlighterPostTags("</em>")
  // 设置查询数据的位置,分页用
.setFrom(0)
// 设置查询结果集的最大条数
.setSize(60)
// 设置是否按查询匹配度排序
.setExplain(true)
// 最后就是返回搜索响应信息
  .execute()
  .actionGet();
SearchHits searchHits = response.getHits();
System.out.println("-----------------在["+term+"]中搜索关键字["+queryString+"]---------------------");
System.out.println("共匹配到:"+searchHits.getTotalHits()+"条记录!");
SearchHit[] hits = searchHits.getHits();
for (SearchHit searchHit : hits) {
//获取高亮的字段
Map<String, HighlightField> highlightFields = searchHit.getHighlightFields();
HighlightField highlightField = highlightFields.get(term);
System.out.println("高亮字段:"+highlightField.getName()+"\n高亮部分内容:"+highlightField.getFragments()[0].string());
Map<String, Object> sourceAsMap = searchHit.sourceAsMap();
Set<String> keySet = sourceAsMap.keySet();
for (String string : keySet) {
//key value 值对应关系
System.out.println(string+":"+sourceAsMap.get(string));
}
System.out.println();
}
}

Rest

官方提供low-level rest client(支持5.0及以后版本) 和high-level rest client(支持版本为 5.6及以后版本)

low-level rest client

引入maven依赖

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>6.5.4</version>
</dependency>
 <dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>rest</artifactId>
    <version>5.3.2</version>
</dependency>

创建rest client

Header[] defaultHeaders = new Header[] { new BasicHeader("header", "value") };
RestClient restClient = RestClient.builder(
        new HttpHost("localhost", 9200, "http"))
    .setDefaultHeaders(defaultHeaders) //设置默认标头
    .setMaxRetryTimeoutMillis(10000) //同一请求重试超时时间，默认30s
    .setFailureListener(new RestClient.FailureListener() {

    }) //设置侦听器，节点出现故障会收到通知
    .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
        @Override
        public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
            CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            //create the authentication scope
            AuthScope authScope = new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT, AuthScope
                .ANY_REALM);
            // Create credential pair(username,password)
            UsernamePasswordCredentials usernamePasswordCredentials = new UsernamePasswordCredentials("username", "password");
            credentialsProvider.setCredentials(authScope, usernamePasswordCredentials);
            return httpClientBuilder.setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {
                @Override
                public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
                    return 30 * 1000;
                }
            }).setDefaultCredentialsProvider(credentialsProvider);
        }
    })
    .setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
        @Override
        public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
            return requestConfigBuilder.setSocketTimeout(10000);
        }
    })
    .build();

high level rest client

引入maven依赖

      <dependency>
          <groupId>org.elasticsearch</groupId>
          <artifactId>elasticsearch</artifactId>
          <version>6.7.1</version>
      </dependency>


      <dependency>
          <groupId>org.elasticsearch.client</groupId>
          <artifactId>elasticsearch-rest-high-level-client</artifactId>
          <version>6.7.2</version>
      </dependency>

创建rest client

RestHighLevelClient client = new RestHighLevelClient( RestClient.builder(new HttpHost("localhost", 9200, "http")));

由于在阿里云使用的是ES6.7,仅支持high level rest client，因此在后面着重对该模式进行阐述。

常用的操作工具类：ElasticSearchUtils.java

package com.dflm.weixin.elasticsearch;

import com.dflm.weixin.business.exception.BusinessException;
import com.dflm.weixin.business.model.User;
import com.dflm.weixin.util.ValidateUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;


import org.apache.http.entity.ContentType;
import org.apache.http.nio.entity.NStringEntity;
import org.elasticsearch.ElasticsearchStatusException;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.*;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.IndicesClient;

import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.ScoreSortBuilder;
import org.elasticsearch.search.sort.SortOrder;

import java.io.IOException;
import java.util.*;

/**
 * <p>
 *     在该项目中，使用的ElaticSearch的版本为6.7，因此只允许一个index下对应一个type,
 *     不能出现多个type
 * </p>
 * ElasticSearch操作工具类
 * @author  lh
 * @version  1.0
 * @time 2019-05-15
 */
public class ElasticSearchUtils {

    // 引入logger日志对象
    public static final Log logger = LogFactory.getLog(ElasticSearchUtils.class);


    // 初始化API客户端
    public static RestHighLevelClient client = new RestHighLevelClient(
            RestClient.builder(
                    new HttpHost("192.168.5.61", 9200, "http")
            ));

    /**
     * 关键字搜索->指定匹配类型
     * @param indexName  索引名称
     * @param type  类型
     * @param fieldName   字段名称
     * @param keyword   关键词
     * @param start   开始下标
     * @param count   总的记录数
     * @return
     * @throws IOException
     */
    public static List<Map<String, Object>> search(String indexName,String type, String fieldName, String keyword, int start, int count) throws IOException {
        // 初始化搜索请求对象，构造注入索引名
        SearchRequest searchRequest = new SearchRequest(indexName);
        // 初始化SearchSourceBuilder对象
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // 关键字匹配对应字段
        MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder(fieldName, keyword);
        // 模糊匹配
        matchQueryBuilder.fuzziness(Fuzziness.AUTO);
        sourceBuilder.query(matchQueryBuilder);
        // 第start页
        sourceBuilder.from(start);
        // 共count条
        sourceBuilder.size(count);
        searchRequest.source(sourceBuilder);
        searchRequest.types(type);
        // 匹配度从高到低
        sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));

        // 获取搜索返回对象
        SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
        // 获取搜索击中对象
        SearchHits hits = searchResponse.getHits();
        List<Map<String, Object>> matchRsult = new LinkedList<>();
        // 将击中的数据放入到集合
        for (SearchHit hit : hits.getHits()) {
            matchRsult.add(hit.getSourceAsMap());
        }
        return matchRsult;
    }

    /**
     * 删除指定类型的id
     * @param indexName  索引名称
     * @param type   类型
     * @param id   id
     * @throws IOException  异常信息
     */
    public static void deleteDocument(String indexName,String type,String id) throws Exception {
        try {
            DeleteRequest request = new DeleteRequest(indexName, type, id);
            client.delete(request, RequestOptions.DEFAULT);
            System.out.println("删除成功");
        } catch(Throwable e) {
            e.printStackTrace();
            throw new BusinessException("插入数据异常");
        }
    }

    /**
     * 查询所有索引下的字段信息
     * @param  index
     * @return
     */
    public static List<Map<String, Object>> queryAll(String index) throws Exception {
        // 创建查询对象SearchRequest
        SearchRequest searchRequest = new SearchRequest(index);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 查询全部信息
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
        // 获取搜索击中对象
        SearchHits hits = searchResponse.getHits();
        List<Map<String, Object>> matchRsult = new LinkedList<>();
        // 将击中的数据放入到集合
        for (SearchHit hit : hits.getHits()) {
            matchRsult.add(hit.getSourceAsMap());
        }
        return matchRsult;
    }


    /**
     * 根据id进行搜索->支持多id进行搜索
     * @param  index
     * @return
     */
    public static List<Map<String, Object>> queryAllById(String index,List<String> ids) throws Exception {
        List<Map<String, Object>> matchRsult = new LinkedList<>();
        if(!ValidateUtil.checkListIsNotEmpty(ids)){
            return matchRsult;
        }
        // 创建查询对象SearchRequest
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        for (String id: ids) {
            TermQueryBuilder termQueryBuilder = new TermQueryBuilder("id", id);
            boolQueryBuilder.should(termQueryBuilder);
        }
        SearchRequest searchRequest = new SearchRequest(index);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(boolQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        // 获取搜索击中对象
        SearchHits hits = response.getHits();
        // 将击中的数据放入到集合
        for (SearchHit hit : hits.getHits()) {
            matchRsult.add(hit.getSourceAsMap());
        }
        return matchRsult;
    }

    /**
     * 根据范围进行搜索
     * @param  index
     * @return
     */
    public static List<Map<String, Object>> queryAllByRange(String index,String type,String filed,String startValue,String endValue) throws Exception {
        List<Map<String, Object>> matchRsult = new LinkedList<>();
        SearchRequest searchRequest = new SearchRequest(index);
        // SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // sourceBuilder.from(0);
        // sourceBuilder.size(10);
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(filed);
        rangeQueryBuilder.gte(startValue);
        rangeQueryBuilder.lte(endValue);
        searchRequest.types(type);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(rangeQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        // 获取搜索击中对象
        SearchHits hits = response.getHits();
        // 将击中的数据放入到集合
        for (SearchHit hit : hits.getHits()) {
            matchRsult.add(hit.getSourceAsMap());
        }
        return matchRsult;
    }

    /**
     * 获得指定type指定id的json数据
     * @param indexName   索引名称
     * @param type   类型
     * @param id    id
     * @return  Map
     * @throws IOException
     */
    public static Map getDocument(String indexName,String type, String id) throws IOException {
        GetRequest request = new GetRequest(
                indexName,
                type,
                id);
        GetResponse response = client.get(request,RequestOptions.DEFAULT);
        if (!response.isExists()) {
            System.out.println("检查到服务器上 " + type + " id=" + id + "的文档不存在");
            return null;
        } else {
            String source = response.getSourceAsString();
            System.out.print("获取到服务器上 " + type + " id=" + id + "的文档内容是：");
            System.out.println(source);
            // 转化为map返回
            return response.getSourceAsMap();
        }
    }

    /**
     * 插入指定type的对象数据
     * @param indexName   索引名称
     * @param type   类型名称
     * @param object  对象数据
     * @throws IOException
     */
    public static void addDocument(String indexName,String type,Object object) throws Exception {
        Map<String, Object> jsonMap = new HashMap<>();
        // 将object转为map
        jsonMap = Beanutil.bean2map(object);
        Object obj = jsonMap.get("id");
        if(obj == null){
            throw new BusinessException("id为空，插入数据异常");
        }
        IndexRequest indexRequest = new IndexRequest(indexName, type, obj.toString())
                .source(jsonMap);
        client.index(indexRequest,RequestOptions.DEFAULT);
        System.out.println("已经向ElasticSearch服务器增加barbase：" + object);

    }

    /**
     * 插入指定type的对象数据(类型名称默认为对象的简单类名)
     * @param indexName   索引名称
     * @param object  对象数据
     * @throws IOException
     */
    public static void addDocument(String indexName,Object object) throws Exception {
        if(object == null){
            throw new BusinessException("对象信息为空，插入数据异常");
        }
        // 获取object的简单类名(这里必须是小写)
        String simpleName = object.getClass().getSimpleName().toLowerCase();
        Map<String, Object> jsonMap = new HashMap<>();
        // 将object转为map
        jsonMap = Beanutil.bean2map(object);
        Object obj = jsonMap.get("id");
        if(obj == null){
            throw new BusinessException("id为空，插入数据异常");
        }
        IndexRequest indexRequest = new IndexRequest(indexName, simpleName, obj.toString())
                .source(jsonMap);
        client.index(indexRequest,RequestOptions.DEFAULT);
        System.out.println("已经向ElasticSearch服务器增加barbase：" + object);

    }

    /**
     * 校验是否存在该索引
     * @param indexName   索引名称
     * @return  boolean
     * @throws IOException
     */
    private static boolean checkExistIndexV1(String indexName) throws IOException {
        boolean result = true;
        try {
            OpenIndexRequest openIndexRequest = new OpenIndexRequest(indexName);
            client.indices().open(openIndexRequest,RequestOptions.DEFAULT).isAcknowledged();
        } catch (ElasticsearchStatusException ex) {
            String m = "Elasticsearch exception [type=index_not_found_exception, reason=no such index]";
            if (m.equals(ex.getMessage())) {
                result = false;
            }
        }
        if (result)
            System.out.println("索引:" + indexName + " 是存在的");
        else
            System.out.println("索引:" + indexName + " 不存在");

        return result;

    }


    /**
     * 校验是否存在该索引
     * @param indexName   索引名称
     * @return  boolean
     * @throws IOException
     */
    private static boolean checkExistIndexV2(String indexName) throws IOException {
        GetIndexRequest request = new GetIndexRequest();
        // 赋值索引名称
        request.indices(indexName);
        request.local(false);
        request.humanReadable(true);
        boolean exists  = client.indices().exists(request,RequestOptions.DEFAULT) ;
        return exists;
    }

    /**
     * 删除索引
     * @param indexName
     * @throws IOException
     */
    private static void deleteIndex(String indexName) throws IOException {
        // 索引删除请求对象
        DeleteIndexRequest request = new DeleteIndexRequest(indexName);
        // 删除索引
        client.indices().delete(request,RequestOptions.DEFAULT);
        System.out.println("删除了索引：" + indexName);

    }

    /**
     * 新增索引
     * @param indexName 索引名称
     * @throws IOException
     */
    private static void createIndex(String indexName) throws IOException {
        CreateIndexRequest request = new CreateIndexRequest(indexName);
        IndicesClient indicesClient = client.indices();
        indicesClient.create(request,RequestOptions.DEFAULT);
        System.out.println("创建了索引：" + indexName);
    }

    /**
     * 通过ID 更新数据
     *
     * @param object 要增加的数据
     * @param index      索引，类似数据库
     * @param type       类型，类似表
     * @param id         数据ID
     * @return
     */
    public static void updateDataById(Object object, String index, String type, String id) throws Exception{
        UpdateRequest updateRequest = new UpdateRequest();
        Map<String, Object> jsonMap = Beanutil.bean2map(object);
        // 注意doc()方法后的参数需要是json或者map格式，如果传入object格式，会报错：The number of object passed must be even but was [1]
        updateRequest.index(index).type(type).id(id).doc(jsonMap);
        client.update(updateRequest,RequestOptions.DEFAULT);
    }


    /**
     * 使用分词查询
     *
     * @param index          索引名称
     * @param type           类型名称,可传入多个type逗号分隔
     * @param startTime      开始时间
     * @param endTime        结束时间
     * @param size           文档大小限制
     * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
     * @param sortField      排序字段
     * @param matchPhrase    true 使用，短语精准匹配
     * @param highlightField 高亮字段
     * @param matchStr       过滤条件（xxx=111,aaa=222）
     * @return
     */
    public static List<Map<String, Object>> searchListData(String index, String type, long startTime, long endTime, Integer size, String fields, String sortField, boolean matchPhrase, String highlightField, String matchStr) throws  Exception{
        return null;
    }

    /**
     * 高亮结果集 特殊处理
     *
     * @param searchResponse
     * @param highlightField
     */
    private static List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
        List<Map<String, Object>> sourceList = new ArrayList<>();
        return sourceList;
    }

    /**
     * 批量添加
     * @param index  索引名称
     * @param type   类型名称
     * @param list   集合对象
     * @return
     * @throws Exception
     */
    public static boolean bulkAdd(String index,String type,List<Object> list) throws Exception {
        // 初始化BulkRequest对象
        BulkRequest request = new BulkRequest();
        if (ValidateUtil.checkListIsNotEmpty(list)) {
            list.forEach((Object obj) -> {
                // 先将obj转为map
                Map<String, Object> jsonMap = Beanutil.bean2map(obj);
                if (jsonMap != null && null != jsonMap.get("id")) {
                    request.add(new IndexRequest(index, type, jsonMap.get("id").toString())
                            .source(jsonMap));
                }
            });
            BulkResponse bulk = client.bulk(request, RequestOptions.DEFAULT);
            System.out.println("Status:" + bulk.status().name() + ",hasFailures:" + bulk.hasFailures());
            // 状态为OK
            if("OK".equals(bulk.status().name())) {
                // 插入不为失败
                if (bulk.hasFailures()) {
                    return false;
                } else {
                    return true;
                }
            }else{
                return false;
            }
        } else {
            return false;
        }
    }

    public static RestHighLevelClient getClient() {
        return client;
    }

    public static void setClient(RestHighLevelClient client) {
        ElasticSearchUtils.client = client;
    }

    public static void main(String[] args) throws  Exception{
        // createIndex("wemew");
        // checkExistIndexV1("wemew");
        // boolean flag = checkExistIndexV2("wemew");
        // List<Map<String, Object>> list = search("accounts","barbase","city","成都",0,20);
        // list.forEach((Map<String, Object> map) ->{
        // System.out.println("map="+map);
        // });
        // deleteDocument("accounts","barbase","1");
        /*List<Map<String, Object>> list = search("accounts","barbase","id","1",0,20);
        list.forEach((Map<String, Object> map) ->{
             System.out.println("map="+map);
        });*/
        // Map map = getDocument("accounts","barbase","1");
        /*Barbase barbase = new Barbase();
        barbase.setCity("北京");
        barbase.setTel("15889898989");
        barbase.setId("999");
        barbase.setName("北京胡桃里");
        addDocument("accounts",barbase);
        // System.out.println("map="+map);
        Map map = getDocument("accounts","barbase","999");
        System.out.println("map="+map);*/
        List list = new ArrayList();
        User user = new User();
        user.setCity("北京胡桃里");
        user.setTel("15889898989");
        user.setId("007");
        user.setName("张三");
        User user1 = new User();
        user1.setCity("北京胡桃里1");
        user1.setTel("158898989891");
        user1.setId("0071");
        user1.setName("张三1");
        User user2 = new User();
        user2.setCity("北京胡桃里2update");
        user2.setTel("158898989892");
        user2.setId("0072");
        user2.setName("张三2");
        list.add(user);
        list.add(user1);
        list.add(user2);
        // deleteIndex("test");
        /* addDocument("user","user",user);
        // System.out.println("map="+map);
        Map map = getDocument("user","user","007");
        System.out.println("map="+map);*/
        // bulkAdd("test","test",list);
        //Map map = getDocument("test","test","007");
        // System.out.println("map="+map);

        //updateDataById(user2,"test","test","007");

        //Map map1 = getDocument("test","test","007");
        List<Map<String, Object>> lists = queryAllByRange("test","test","tel","158898989890","158898989891");
        for(Map<String, Object> map:lists){
            System.out.println("map="+map);
            // Object obj = Beanutil.map2bean(map,User);
        }

    }
}

Beanutil.java

package com.dflm.weixin.elasticsearch;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.HashMap;
import java.util.Map;

/**
 * bean和map之间的转换工具类
 * @author lh
 * @version  1.0
 */
public class Beanutil {
    /**
     * 将JavaBean对象封装到Map集合当中
     * @param bean
     * @return
     * @throws Exception
     */
    public static Map<String, Object> bean2map(Object bean)
    {
        //创建Map集合对象
        Map<String,Object> map=new HashMap<>();
        try {
            //获取对象字节码信息,不要Object的属性
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass(), Object.class);
            //获取bean对象中的所有属性
            PropertyDescriptor[] list = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor pd : list) {
                String key = pd.getName();//获取属性名
                Object value = pd.getReadMethod().invoke(bean);//调用getter()方法,获取内容
                if (value != null) {
                    map.put(key, value);//增加到map集合当中
                }
            }
        }catch(Exception e){
            e.printStackTrace();
            return null;
        }
        return map;
    }


    /**
     * 将Map集合中的数据封装到JavaBean对象中
     * @param map        集合
     * @param classType 封装javabean对象
     * @throws Exception
     */
    public static <T> T map2bean(Map<String, Object> map,Class<T> classType) throws Exception
    {
        //采用反射动态创建对象
        T obj = classType.newInstance();
        //获取对象字节码信息,不要Object的属性
        BeanInfo beanInfo = Introspector.getBeanInfo(classType,Object.class);
        //获取bean对象中的所有属性
        PropertyDescriptor[] list = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor pd : list) {
            String key = pd.getName();    //获取属性名
            Object value=map.get(key);  //获取属性值
            pd.getWriteMethod().invoke(obj, value);//调用属性setter()方法,设置到javabean对象当中
        }
        return obj;
    }
}

以上就是对ES的个人理解，如果存在有误的地方，还请各位指正。

javashareauthor

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
ElaticSearch

ElaticSearch介绍一个实时的分布式搜索和分析引擎。设计用于云计算，能够达到实时搜索，稳定，可靠，快速，方便安装,且基于restful接口。ElaticSearch与数据库的比较 Database(数据库) Index(索引库) Table(表) Type(类型) Row(行) ...
复制链接

扫一扫