前言,公司之前在线文档使用的Flash预览,用的es2全文检索,现在要进行项目整改,Flash现在不能用了,所以调整为KKFileView。对于ES也需要进行升级,添加IK中文分词器。所以就写了这篇文档进行总结与存档。

关于KKFileView的搭建与使用这里就不多说了,KKFileView官网基本都给出了解决方案,有一些个别的复制问题,我也在另一篇文档中写了。KKFileView在线预览初使用记录,主要解决不可复制等一些限制问题。

Elasticsearch在Java中使用

下面我贴出了已经写好工具类,方便后续使用。

文件处理

如果是纯文本的格式,那么我们直接上传就好了,但是如果是word、PDF等其他的文件形式,就需要进行预处理操作了。所以我们要先建立一个通道;关于为什么建立通道的问题,有兴趣的同学可以去看一下es的PUT请求原理;

安装文本抽取插件

## 安装目录下运行下面的命令就可以进行安装
./bin/elasticsearch-plugin install ingest-attachment

定义文本抽取管道

利用kibana运行下面的代码段,提示true就OK了.
[记得重启es,不然一会定义管道的时候,会报错哦。如果是集群的话,所有的服务都要重启才可以]
如果不知道kibana是什么的同学,可以去学习一下
对于安装kibana和运行可以去看一下我的另一篇文档
Linux安装运行
Mac安装运行
ik分词器这两篇文档也都有说

PUT /_ingest/pipeline/attachment
{
    "description": "Extract attachment information",
    "processors": [
        {
            "attachment": {
                "field": "content",
                "ignore_missing": true
            }
        },
        {
            "remove": {
                "field": "content"
            }
        }
    ]
}

创建索引

PUT /索引名称
这里的properties可以根据实际字段进行调整

PUT /fileindex
{
  "mappings": {
    "properties": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "sfName":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "createBy":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "type":{
        "type": "keyword"
      },
      "attachment": {
        "properties": {
          "content":{
            "type": "text",
            "analyzer": "ik_smart"
          }
        }
      }
    }
  }
}

如果上面两步都成功的话,那可以进行一个测试了

因为ElasticSearch是基于JSON 格式的文档数据库,所以附件文档在插入ElasticSearch之前必须进行Base64编码。先通过下面的网站将一个pdf文件转化为base64的文本。PDF to Base64

POST /docwrite/_doc?pipeline=attachment
{
	"name":"进口红酒",
	"type":"pdf",
	"content":"这里放入你转换后的base64"
}

然后我们可以通过GET来查询刚刚上传的文档是否成功。

GET /docwrite/_search

如果不出意外的话,应该是可以正常看到已经解析后的信息,这里我就不贴图了。
如果不指定pipline的话,是无法被es解析的。查询出来就是不是你所认识的中文,哈哈哈。

Java操作实例

POM引入

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

		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.5.8</version>
		</dependency>

		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpcore</artifactId>
			<version>4.4.9</version>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.7</version>
		</dependency>

必要信息的实体类

//这个实体类可以是 你的实际业务为主,但是要保留content字段
public class fileMessage {
    String id; //用于存储文件id
    String name; //文件名
    String type; //文件的type,pdf,word,or txt
    String content; //文件转化成base64编码后所有的内容。
}

上传代码

使用下面的updateESFile方法就可以上传了。具体的业务逻辑,你们可以根据实际业务来做,实体类也要根据实际业务来做。

private void updateESFile(String filePath){
	File file = new File(filePath);
	if (!file.exists()) {
		System.out.println("找不到文件");
	}
	fileMessage fileM = new fileMessage();
	try {
		byte[] bytes = getContent(file);
		String base64 = Base64.getEncoder().encodeToString(bytes);
		fileM.setId("1");
		fileM.setName(file.getName());
		fileM.setContent(base64);
		IndexRequest indexRequest = new IndexRequest("fileindex");
		//上传同时,使用attachment pipline进行提取文件
		indexRequest.source(JSON.toJSONString(fileM), XContentType.JSON);
		indexRequest.setPipeline("attachment");
		IndexResponse indexResponse = EsUtil.client.index(indexRequest, RequestOptions.DEFAULT);
		logger.info("send to eSearch:" + fileName);
		logger.info("send to eSeach results:" + indexResponse);
	} catch (IOException | SAXException | TikaException e) {
		e.printStackTrace();
	}
}


/**
	 * 文件转base64
	 * @param file
	 * @return
	 * @throws IOException
	 */
	private byte[] getContent(File file) throws IOException {

		long fileSize = file.length();
		if (fileSize > Integer.MAX_VALUE) {
			System.out.println("file too big...");
			return null;
		}
		FileInputStream fi = new FileInputStream(file);
		byte[] buffer = new byte[(int) fileSize];
		int offset = 0;
		int numRead = 0;
		while (offset < buffer.length
				&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
			offset += numRead;
		}
		// 确保所有数据均被读取
		if (offset != buffer.length) {
			throw new IOException("Could not completely read file "
					+ file.getName());
		}
		fi.close();
		return buffer;
	}

JavaEsUtil工具类

package util;
import com.alibaba.fastjson.JSON;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;


public class EsUtil {
    /**
     * 客户端,本次使用本地连接
     */
    public static RestHighLevelClient client = new RestHighLevelClient(
            RestClient.builder(
                    new HttpHost("127.0.0.1", 9200, "http")));


    /**
     * 停止连接
     */
    public static void shutdown() {
        if (client != null) {
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 默认类型(整个type类型传闻在8.0版本后可能会废弃,但是目前7.13版本下先保留)
     */
    public static final String DEFAULT_TYPE = "_doc";

    /**
     * set方法前缀
     */
    public static final String SET_METHOD_PREFIX = "set";

    /**
     * 返回状态-CREATED
     */
    public static final String RESPONSE_STATUS_CREATED = "CREATED";

    /**
     * 返回状态-OK
     */
    public static final String RESPONSE_STATUS_OK = "OK";

    /**
     * 返回状态-NOT_FOUND
     */
    public static final String RESPONSE_STATUS_NOT_FOUND = "NOT_FOUND";

    /**
     * 需要过滤的文档数据
     */
    public static final String[] IGNORE_KEY = {"@timestamp", "@version", "type"};

    /**
     * 超时时间 1s
     */
    public static final TimeValue TIME_VALUE_SECONDS = TimeValue.timeValueSeconds(1);

    /**
     * 批量新增
     */
    public static final String PATCH_OP_TYPE_INSERT = "insert";

    /**
     * 批量删除
     */
    public static final String PATCH_OP_TYPE_DELETE = "delete";

    /**
     * 批量更新
     */
    public static final String PATCH_OP_TYPE_UPDATE = "update";

//==========================================数据操作(工具)(不参与调用es)=================================================

    /**
     * 方法描述: 剔除指定文档数据,减少不必要的循环
     *
     * @param map 文档数据
     * @return: void
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:39 上午
     */
    public static void ignoreSource(Map<String, Object> map) {
        for (String key : IGNORE_KEY) {
            map.remove(key);
        }
    }


    /**
     * 方法描述: 将文档数据转化为指定对象
     *
     * @param sourceAsMap 文档数据
     * @param clazz       转换目标Class对象
     * @return 对象
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:38 上午
     */
    public static <T> T dealObject(Map<String, Object> sourceAsMap, Class<T> clazz) {
        try {
            ignoreSource(sourceAsMap);
            Iterator<String> keyIterator = sourceAsMap.keySet().iterator();
            T t = clazz.newInstance();
            while (keyIterator.hasNext()) {
                String key = keyIterator.next();
                String replaceKey = key.replaceFirst(key.substring(0, 1), key.substring(0, 1).toUpperCase());
                Method method = null;
                try {
                    method = clazz.getMethod(SET_METHOD_PREFIX + replaceKey, sourceAsMap.get(key).getClass());
                } catch (NoSuchMethodException e) {
                    continue;
                }
                method.invoke(t, sourceAsMap.get(key));
            }
            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


//==========================================索引操作=================================================

    /**
     * 方法描述: 创建索引,若索引不存在且创建成功,返回true,若同名索引已存在,返回false
     *
     * @param: [index] 索引名称
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 11:01 上午
     */
    public static boolean insertIndex(String index) {
        //创建索引请求
        CreateIndexRequest request = new CreateIndexRequest(index);
        //执行创建请求IndicesClient,请求后获得响应
        try {
            CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
            return response != null;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 方法描述: 判断索引是否存在,若存在返回true,若不存在或出现问题返回false
     *
     * @param: [index] 索引名称
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 11:09 上午
     */
    public static boolean isExitsIndex(String index) {
        GetIndexRequest request = new GetIndexRequest(index);
        try {
            return client.indices().exists(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /*
     * 方法描述: 删除索引,删除成功返回true,删除失败返回false
     * @param: [index] 索引名称
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 11:23 上午
     */
    public static boolean deleteIndex(String index) {
        DeleteIndexRequest request = new DeleteIndexRequest(index);
        try {
            AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
            return response.isAcknowledged();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


//==========================================文档操作(新增,删除,修改)=================================================

    /**
     * 方法描述: 新增/修改文档信息
     *
     * @param index 索引
     * @param id    文档id
     * @param data  数据
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:34 上午
     */
    public static boolean insertOrUpdateDocument(String index, String id, Object data) {
        try {
            IndexRequest request = new IndexRequest(index);
            request.timeout(TIME_VALUE_SECONDS);
            if (id != null && id.length() > 0) {
                request.id(id);
            }
            request.source(JSON.toJSONString(data), XContentType.JSON);
            IndexResponse response = client.index(request, RequestOptions.DEFAULT);
            String status = response.status().toString();
            if (RESPONSE_STATUS_CREATED.equals(status) || RESPONSE_STATUS_OK.equals(status)) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 方法描述: 更新文档信息
     *
     * @param index 索引
     * @param id    文档id
     * @param data  数据
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:34 上午
     */
    public static boolean updateDocument(String index, String id, Object data) {
        try {
            UpdateRequest request = new UpdateRequest(index, id);
            request.doc(JSON.toJSONString(data), XContentType.JSON);
            UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
            String status = response.status().toString();
            if (RESPONSE_STATUS_OK.equals(status)) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 方法描述:删除文档信息
     *
     * @param index 索引
     * @param id    文档id
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:33 上午
     */
    public static boolean deleteDocument(String index, String id) {
        try {
            DeleteRequest request = new DeleteRequest(index, id);
            DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
            String status = response.status().toString();
            if (RESPONSE_STATUS_OK.equals(status)) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 方法描述: 小数据量批量新增
     *
     * @param index    索引
     * @param dataList 数据集 新增修改需要传递
     * @param timeout  超时时间 单位为秒
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:31 上午
     */
    public static boolean simplePatchInsert(String index, List<Object> dataList, long timeout) {
        try {
            BulkRequest bulkRequest = new BulkRequest();
            bulkRequest.timeout(TimeValue.timeValueSeconds(timeout));
            if (dataList != null && dataList.size() > 0) {
                for (Object obj : dataList) {
                    bulkRequest.add(
                            new IndexRequest(index)
                                    .source(JSON.toJSONString(obj), XContentType.JSON)
                    );
                }
                BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
                if (!response.hasFailures()) {
                    return true;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 功能描述:
     * @param index 索引名称
     * @param idList 需要批量删除的id集合
     * @return : boolean
     * @author : gxf
     * @date : 2021/6/30 1:22
     */
    public static boolean patchDelete(String index, List<String> idList) {
        BulkRequest request = new BulkRequest();
        for (String id:idList) {
            request.add(new DeleteRequest().index(index).id(id));
        }
        try {
            BulkResponse response = EsUtil.client.bulk(request, RequestOptions.DEFAULT);
            return !response.hasFailures();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


//==========================================文档操作(查询)=================================================

    /**
     * 方法描述: 判断文档是否存在
     *
     * @param index 索引
     * @param id    文档id
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:36 上午
     */
    public static boolean isExistsDocument(String index, String id) {
        return isExistsDocument(index, DEFAULT_TYPE, id);
    }


    /**
     * 方法描述: 判断文档是否存在
     *
     * @param index 索引
     * @param type  类型
     * @param id    文档id
     * @return: boolean
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:36 上午
     */
    public static boolean isExistsDocument(String index, String type, String id) {
        GetRequest request = new GetRequest(index, type, id);
        try {
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
            return response.isExists();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 方法描述: 根据id查询文档
     *
     * @param index 索引
     * @param id    文档id
     * @param clazz 转换目标Class对象
     * @return 对象
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:36 上午
     */
    public static <T> T selectDocumentById(String index, String id, Class<T> clazz) {
        return selectDocumentById(index, DEFAULT_TYPE, id, clazz);
    }


    /**
     * 方法描述: 根据id查询文档
     *
     * @param index 索引
     * @param type  类型
     * @param id    文档id
     * @param clazz 转换目标Class对象
     * @return 对象
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:35 上午
     */
    public static <T> T selectDocumentById(String index, String type, String id, Class<T> clazz) {
        try {
            type = type == null || type.equals("") ? DEFAULT_TYPE : type;
            GetRequest request = new GetRequest(index, type, id);
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
            if (response.isExists()) {
                Map<String, Object> sourceAsMap = response.getSourceAsMap();
                return dealObject(sourceAsMap, clazz);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 方法描述:(筛选条件)获取数据集合
     *
     * @param index         索引
     * @param sourceBuilder 请求条件
     * @param clazz         转换目标Class对象
     * @return: java.util.List<T>
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:35 上午
     */
    public static <T> List<T> selectDocumentList(String index, SearchSourceBuilder sourceBuilder, Class<T> clazz) {
        try {
            SearchRequest request = new SearchRequest(index);
            if (sourceBuilder != null) {
                // 返回实际命中数
                sourceBuilder.trackTotalHits(true);
                request.source(sourceBuilder);
            }
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            if (response.getHits() != null) {
                List<T> list = new ArrayList<>();
                SearchHit[] hits = response.getHits().getHits();
                for (SearchHit documentFields : hits) {
                    Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();
                    list.add(dealObject(sourceAsMap, clazz));
                }
                return list;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 方法描述:(筛选条件)获取数据
     *
     * @param index         索引
     * @param sourceBuilder 请求条
     * @return: java.util.List<T>
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 10:35 上午
     */
    public static SearchResponse selectDocument(String index, SearchSourceBuilder sourceBuilder) {
        try {
            SearchRequest request = new SearchRequest(index);
            if (sourceBuilder != null) {
                // 返回实际命中数
                sourceBuilder.trackTotalHits(true);
                sourceBuilder.size(10000);
                request.source(sourceBuilder);
            }
            return client.search(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 方法描述: 筛选查询,返回使用了<span style='color:red'></span>处理好的数据.
     *
     * @param: index 索引名称
     * @param: sourceBuilder sourceBuilder对象
     * @param: clazz 需要返回的对象类型.class
     * @param: highLight 需要表现的高亮匹配字段
     * @return: java.util.List<T>
     * @author: gxf
     * @date: 2021年07月27日
     * @time: 6:39 下午
     */
    public static <T> List<T> selectDocumentListHighLight(String index, SearchSourceBuilder sourceBuilder, Class<T> clazz, String highLight) {
        try {
            SearchRequest request = new SearchRequest(index);
            if (sourceBuilder != null) {
                // 返回实际命中数
                sourceBuilder.trackTotalHits(true);
                //高亮
                HighlightBuilder highlightBuilder = new HighlightBuilder();
                highlightBuilder.field(highLight);
                highlightBuilder.requireFieldMatch(false);//多个高亮关闭
                highlightBuilder.preTags("<span style='color:red'>");
                highlightBuilder.postTags("</span>");
                sourceBuilder.highlighter(highlightBuilder);
                request.source(sourceBuilder);
            }
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            if (response.getHits() != null) {
                List<T> list = new ArrayList<>();
                for (SearchHit documentFields : response.getHits().getHits()) {
                    Map<String, HighlightField> highlightFields = documentFields.getHighlightFields();
                    HighlightField title = highlightFields.get(highLight);
                    Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();
                    if (title != null) {
                        Text[] fragments = title.fragments();
                        String n_title = "";
                        for (Text fragment : fragments) {
                            n_title += fragment;
                        }
                        sourceAsMap.put(highLight, n_title);//高亮替换原来的内容
                    }
                    list.add(dealObject(sourceAsMap, clazz));
                }
                return list;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 方法描述: 返回索引内所有内容,返回SearchResponse对象,需要自己解析,不对数据封装
     * @param: index 索引名称
     * @return: SearchResponse
     * @author: gxf
     * @date: 2021/6/30
     * @time: 1:28 上午
     */
    public static SearchResponse queryAllData(String index){
        //创建搜索请求对象
        SearchRequest request = new SearchRequest(index);
        //构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //查询所有数据
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        request.source(sourceBuilder);
        try {
            return client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 方法描述: 返回索引内所有内容,返回指定类型
     * @param: index 索引名称
     * @param: clazz 需要接受转换的对象类型
     * @return: java.util.List<T>
     * @author: gxf
     * @date: 2021/6/30
     * @time: 1:32 上午
     */
    public static <T> List<T> queryAllData(String index, Class<T> clazz){
        //创建搜索请求对象
        SearchRequest request = new SearchRequest(index);
        //构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //查询所有数据
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        request.source(sourceBuilder);
        try {
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            if (response.getHits() != null) {
                List<T> list = new ArrayList<>();
                SearchHit[] hits = response.getHits().getHits();
                for (SearchHit documentFields : hits) {
                    Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();
                    list.add(dealObject(sourceAsMap, clazz));
                }
                return list;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Java ES全文检索


public List<Map<String, Object>> eSearch(String msg) throws UnknownHostException {
//
		List<Map<String, Object>> matchRsult = new LinkedList<Map<String, Object>>();
		SearchSourceBuilder builder = new SearchSourceBuilder();

		//因为我这边实际业务需要其他字段的查询,所以进行查询的字段就比较,如果只是查询文档中内容的话,打开注释的代码,然后注释掉这行代码		
		builder.query(QueryBuilders.multiMatchQuery(msg,"attachment.content","name","sfName","createBy").analyzer("ik_smart"));

		//builder.query(QueryBuilders.matchQuery("attachment.content", msg).analyzer("ik_smart"));
		SearchResponse searchResponse = EsUtil.selectDocument("fileindex", builder);
		SearchHits hits = searchResponse.getHits();

		for (SearchHit hit : hits.getHits()) {
			hit.getSourceAsMap().put("msg", "");
			matchRsult.add(hit.getSourceAsMap());
			// System.out.println(hit.getSourceAsString());
		}
		System.out.println("over in the main");

		return matchRsult;
	}

完结

至此简单使用Java对ES文档上传后全文检索已经完成。祝愿大家完美撒花;
✿✿ヽ(°▽°)ノ✿      帅哥美女,留个赞再走吧。

Logo

为开发者提供学习成长、分享交流、生态实践、资源工具等服务,帮助开发者快速成长。

更多推荐