Lucene6.6之多索引+排序+多查询

曾经终败给现在 2022-06-10 02:42 199阅读 0赞

本次项目时在**Lucene6.6**下建立的，需要JDK的版本一定要为**JDK1.8**，所需要的jar包：

![这里写图片描述][SouthEast]

**索引的建立**  
TXT文件内容的读取：

public static String FileReaderAll(String FileName, String charset) throws IOException {
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(FileName), charset));
            String line = new String();
            String temp = new String();
    
            while ((line = reader.readLine()) != null) {
                temp += line;
            }
            reader.close();
            return temp;
        }

**索引条件：**  
文件名能被索引、存储；  
内容能被索引，不存储；  
修改时间存储，不被检索。

为文件夹内的TXT文件建立索引，这里用文件的修改时间进行排序：

/* 指明要索引文件夹的位置 */
            File fileDir = new File("D:\\luceneData");
    
            /* 这里放索引文件的位置 */
            String indexPath = "D:\\index";
    
            Directory dir = FSDirectory.open(Paths.get(indexPath));
    
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            IndexWriterConfig iwc = new IndexWriterConfig(luceneAnalyzer);
            iwc.setOpenMode(OpenMode.CREATE);
            IndexWriter indexWriter = new IndexWriter(dir, iwc);
            File[] textFiles = fileDir.listFiles();
            long startTime = new Date().getTime();
    
            // 增加document到索引去
            for (int i = 0; i < textFiles.length; i++) { 
                if (textFiles[i].isFile()) {
                    System.out.println("File " + textFiles[i].getCanonicalPath() + " 正在被索引....");
                    textFiles[i].getName();
                    System.out.println("文件名：" + textFiles[i].getName());
                    String temp = FileReaderAll(textFiles[i].getCanonicalPath(), "GBK");
                    System.out.println("文件的内容：" + temp);
    
                    long time = textFiles[i].lastModified();
                    String modifitime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time));
                    System.out.println("文件的日期：" + modifitime);
    
                    FieldType modifiField_fieldType = new FieldType();
                    modifiField_fieldType.setStored(false);
    
                    // fieldName_fieldType.setIndexOptions(value);
    
                    Document document = new Document();
                    //文件名能被索引、存储
                    Field FieldName = new TextField("name", textFiles[i].getName(), Field.Store.YES);
                    //内容能被索引，不存储
                    Field FieldBody = new TextField("body", temp, Field.Store.YES);
                    //修改时间存储，不被检索
                    Field modifiField = new StoredField("modifiField", time);
    
                    document.add(FieldName);
                    document.add(FieldBody);
                    document.add(modifiField);
                    document.add(new NumericDocValuesField("modifiField", time));
                    document.add(new IntPoint("modifiField", (int) time));
    
                    System.out.println("**********");
                    indexWriter.addDocument(document);
                }
            }
            indexWriter.close();
    
            // 测试一下索引的时间
            long endTime = new Date().getTime();
            System.out.println("这占用了" + (endTime - startTime) + " 毫秒来把文档增加到索引里面去!" + fileDir.getPath());

截图：  
![这里写图片描述][SouthEast 1]

**多条件查询**  
进行分页的处理方法，这里我用到的是Searcher.searchAfter();lucene3.5以后提供一个searchAfter，这个是在特大数据量采用（亿级数据量），速度相对慢一点，像google搜索图片的时候，点击更多，然后再出来一批。这种方式就是把数据保存在缓存里面。然后再去取。

public static List<Map<Object, Object>> searchByName(int pageIndex, int pageSize, Query query,
                IndexSearcher searcher, Sort sort) throws IOException {
            // 第二种分页方式
            // 获取上一页的最后一个元素
            ScoreDoc lastSd = getLastScoreDoc(pageIndex, pageSize, query, searcher, sort);
            TopDocs tds = searcher.searchAfter(lastSd, query, pageSize, sort);
            List<Map<Object, Object>> lists = new ArrayList<>();
            for (ScoreDoc sd : tds.scoreDocs) {
                Document doc = searcher.doc(sd.doc);
                lists.add(searchPutListMap(doc));
            }
            return lists;
        }

private static ScoreDoc getLastScoreDoc(int pageIndex, int pageSize, Query query, IndexSearcher searcher, Sort sort)
                throws IOException {
            if (pageIndex == 1)
                return null;// 如果是第一页就返回空
            int num = pageSize * (pageIndex - 1);// 获取上一页的最后数量
            TopDocs tds = searcher.search(query, num, sort);
            return tds.scoreDocs[num - 1];
        }

还有另外一种方法：lucene3.5之前分页提供的方式为再查询方式（每次查询全部记录，然后取其中部分记录，这种方式用的最多），lucene官方的解释：由于我们的速度足够快。处理海量数据时，内存容易内存溢出。

//第一种分页方式
                    TopDocs results=searcher.search(query, pageIndex*pageSize,sort); 
                    ScoreDoc[] hits=null;
                    hits=results.scoreDocs;
                    int start = (pageIndex-1)*pageSize;
                    int end = pageIndex*pageSize;
                    Document document=null;
                    for (int i=start;i<end;i++) {  
                        document=searcher.doc(hits[i].doc);  
                        lists.add(searchPutListMap(document));
                    }
                    if (hits.length>0) {
                        System.out.println("输入关键字为："+queryString+"，"+"找到"+hits.length+"条结果!");                        
                    }*/

多条件查询的处理方法（+排序），先按文件名进行查询，结果放在lists中，在按文件内容进行查询，结果放在lists2中，最后用lists.retainAll(lists2)取出两个list的交集，这样就实现了多条件查询（注意，用于Lunece6.6跟以前的版本不太一样，默认是分词查询，进行文件名查询时，有时需要加上文件名后缀才能查到，不然查到的都是分词查询的结果）：

public static List<Map<Object, Object>> searchLucene(String index, String queryTitle, String queryBody,
                int pageIndex, int pageSize) throws IOException, ParseException {
    
            IndexReader reader = DirectoryReader.open(FSDirectory.open(Paths.get(index)));
            IndexSearcher searcher = new IndexSearcher(reader);// 检索工具
    
            Sort sort = new Sort(new SortField("modifiField", SortField.Type.LONG, false));
            Analyzer analyzer = new StandardAnalyzer();
    
            // list<map>集合
            List<Map<Object, Object>> lists = new ArrayList<>();
            List<Map<Object, Object>> lists2 = new ArrayList<>();
    
            QueryParser qp = new QueryParser("name", analyzer);// 用于解析用户输入的工具
            QueryParser qp2 = new QueryParser("body", analyzer);// 用于解析用户输入的工具
    
            Query query = null;
            query = qp.parse(queryTitle + ".txt");
    
            Query query2 = null;
            query2 = qp.parse(queryTitle);
    
            Query query3 = null;
            query3 = qp2.parse(queryBody);
    
            if (searcher != null) {
                lists = searchByName(pageIndex, pageSize, query, searcher, sort);
                lists.addAll(searchByName(pageIndex, pageSize, query2, searcher, sort));
                lists2 = searchByName(pageIndex, pageSize, query3, searcher, sort);
                reader.close();
            }
            lists.retainAll(lists2);
            System.out.println("找到匹配的类似数据有" + lists.size() + "个");
            return lists;
        }

查询结果的提取，放在Map结果集中:

public static Map<Object, Object> searchPutListMap(Document document) {
            String body = document.get("body");
            String name = document.get("name");
            String modifiedtime = document.get("modifiField");
            // 日期格式转换
            long t = Long.parseLong(modifiedtime);
            String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(t));
            Map<Object, Object> map = new HashMap<>();
            map.put("name", name);
            map.put("time", time);
            map.put("body", body);
            return map;
        }

测试代码:

public static void main(String[] args) throws IOException, ParseException {
            String index = "D:\\index";// 搜索的索引路径
            String queryTitle = "ccc"; // 搜索的标题索引名称
            String queryBody = "你好"; // 搜索的内容索引名称
            if ((queryTitle.equals("") || queryTitle == null) || (queryBody.equals("") || queryBody == null)) {
                return;
            }
            int pageIndex = 1;// 第几页
            int pageSize = 100;// 每页显示多少数据
            List<Map<Object, Object>> lists = searchLucene(index, queryTitle, queryBody, pageIndex, pageSize);
            for (Map<Object, Object> map : lists) {
                System.out.println("文件名：" + map.get("name"));
                System.out.println("日期：" + map.get("time"));
                System.out.println("文件内容：" + map.get("body"));
            }
        }

截图：  
![这里写图片描述][SouthEast 2]

[SouthEast]: /images/20220610/1ad18691de5b43db9ec006a192419d98.png
[SouthEast 1]: /images/20220610/4b48c8be3a4a4f3db3a4de31cf5c9361.png
[SouthEast 2]: /images/20220610/2ffaa32fb03c4bbfbd2ef779c54ea6e9.png