全文检索 java Lucene

索引文件：[D:\luceneDemo\data\TXT小说\陛下是妻迷.txt] 大小:[1185.0 KB]
索引文件：[D:\luceneDemo\data\TXT小说\随身空间重生在七十年代.txt] 大小:[2245.0 KB]
索引文件：[D:\luceneDemo\data\TXT小说\韶光慢.txt] 大小:[3732.0 KB]
索引文件：[D:\luceneDemo\data\TXT小说\鬼知道鲛人是什么[娱乐圈].txt] 大小:[1870.0 KB]
索引文件：[D:\luceneDemo\data\农门娇妻：将军要耕田.txt] 大小:[3484.0 KB]
索引文件：[D:\luceneDemo\data\新建文本文档.txt] 大小:[0.0 KB]
===================================================
索引完毕：索引了[57]个文件、花费了  42376 毫秒
===================================================
开始搜索关键词：[佳佳]  发现了[11]个匹配文档
===================================================
D:\luceneDemo\data\新建文本文档.txt 大小:[0.0 KB]
D:\luceneDemo\data\test1008.docx 大小:[11.0 KB]
D:\luceneDemo\data\test1665.docx 大小:[11.0 KB]
D:\luceneDemo\data\TXT小说\他很撩很宠.txt 大小:[526.0 KB]
D:\luceneDemo\data\TXT小说\四神集团①：首席总裁的逃妻.txt 大小:[3167.0 KB]
D:\luceneDemo\data\TXT小说\第一宠婚：老公，坏坏坏！.txt 大小:[1357.0 KB]
D:\luceneDemo\data\TXT小说\六零小娇妻.txt 大小:[6316.0 KB]
D:\luceneDemo\data\TXT小说\豪门隐婚.txt 大小:[3345.0 KB]
D:\luceneDemo\data\TXT小说\侯门闺娇.txt 大小:[1002.0 KB]
D:\luceneDemo\data\TXT小说\鬼知道鲛人是什么[娱乐圈].txt 大小:[1870.0 KB]
D:\luceneDemo\data\TXT小说\豪门重生之娇妻养成.txt 大小:[4306.0 KB]
===================================================

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;

 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
 import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
 import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
 import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.StringField;
 import org.apache.lucene.document.TextField;
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.search.TopScoreDocCollector;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.FSDirectory;
 import org.apache.poi.EmptyFileException;
 import org.apache.poi.POIXMLDocument;
 import org.apache.poi.POIXMLTextExtractor;
 import org.apache.poi.hwpf.extractor.WordExtractor;
 import org.apache.poi.openxml4j.exceptions.OpenXML4JException;
 import org.apache.poi.xwpf.extractor.XWPFWordExtractor;
 import org.apache.xmlbeans.XmlException;
 import org.wltea.analyzer.lucene.IKAnalyzer;

 public class Retrieval {

     IndexWriter writer = null;
     Directory dir = null;
     Analyzer analyzer = null;
     IndexWriterConfig config = null;

     // 文件目录
     // 查询字符串
     public List<String> RunRetrieval(String fileDir, String querystr) {

         // 添加到ext.dic
         // appendMethodB(EXT_DIC_PATH,querystr);

         // 搜索结果
         List<String> resFile = new ArrayList<String>();

         String uuid = UUID.randomUUID().toString();
         // 索引目录
         String indexDir = fileDir + "\\..\\temp_" + uuid;
         try {
             long start = System.currentTimeMillis();

             // 智能中文分析器
             analyzer = new IKAnalyzer();
             // 中文分词器
             // analyzer=new SmartChineseAnalyzer();
             // 实例化分析器
             // analyzer = new StandardAnalyzer();

             // 实例化IndexWriterConfig
             config = new IndexWriterConfig(analyzer);
             // 得到索引所在目录的路径
             dir = FSDirectory.open(Paths.get(indexDir));
             // 实例化IndexWriter
             writer = new IndexWriter(dir, config);
             // 定义文件数组，循环得出要加索引的文件
             File[] files = new File(fileDir).listFiles();
             if (null == files) {
                 System.out.println("没有文件");
                 return null;
             }
             for (File file : files) {
                 recursionDir(file);
             }

             writer.commit();

             // 返回索引了多少个文件，有几个文件返回几个
             long end = System.currentTimeMillis();
             System.out.println("===================================================");
             System.out.println("索引完毕：索引了[" + writer.numDocs() + "]个文件、花费了  " + (end - start) + " 毫秒");
             System.out.println("===================================================");

             int hitsPerPage = 100;

             IndexReader reader = DirectoryReader.open(dir);
             IndexSearcher searcher = new IndexSearcher(reader);
             Term term = new Term("contents", querystr);
             // Query q = new QueryParser("contents", analyzer).parse(querystr);
             TermQuery query = new TermQuery(term);

             TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage);
             System.out.print("开始搜索关键词：[" + querystr + "]  ");
             searcher.search(query, collector);
             ScoreDoc[] hits = collector.topDocs().scoreDocs;

             System.out.println("发现了[" + hits.length + "]个匹配文档");
             System.out.println("===================================================");
             for (int i = 0; i < hits.length; ++i) {
                 int docId = hits[i].doc;
                 Document doc = searcher.doc(docId);

                 // System.out.println(doc.get("contents"));
                 // System.out.print(doc.get("FileName"));
                 System.out.print(doc.get("fullPath") + " 大小:[" + doc.get("size") + " KB]");
                 resFile.add(doc.get("fullPath"));

                 // displayTokens(analyzer, txt2String(new File(doc.get("fullPath"))), querystr);
                 System.out.println();
                 // System.out.print(" "+doc.get("size"));
             }
             reader.close();
             System.out.println("===================================================");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 if (null != writer) {
                     // 删除索引
                     writer.deleteAll();
                     writer.close();
                     // 删除索引文件（不是程序运行所必须的）
                     deleteDir(new File(indexDir));
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return resFile;
     }

     private void writeToIndex(File file) {

         WordExtractor extractorForDoc = null;
         POIXMLTextExtractor extractorForDocx = null;

         try {

             if (file.length() == 0) {
                 return;
             }

             double fileLength = file.length() / 1000;

             // 从这开始，对每个文件加索引
             System.out.println("索引文件：[" + file.getCanonicalPath() + "] 大小:[" + fileLength + " KB]");
             // 索引要一行一行的找，，在数据中为文档，所以要得到所有行，即文档
             // 实例化Document
             Document document = new Document();
             String prefix = file.getName().substring(file.getName().lastIndexOf(".") + 1);

             // 如果是Word
             if (prefix.equals("docx")) {
                 extractorForDocx = new XWPFWordExtractor(POIXMLDocument.openPackage(file.getAbsolutePath()));
                 Reader contents = new StringReader(extractorForDocx.getText());
                 // add():把设置好的索引加到Document里，以便在确定被索引文档。
                 document.add(new TextField("contents", contents));
             } else if (prefix.equals("doc")) {
                 FileInputStream inputStream = new FileInputStream(file.getAbsolutePath());
                 extractorForDoc = new WordExtractor(inputStream);
                 Reader contents = new StringReader(extractorForDoc.getText());
                 // add():把设置好的索引加到Document里，以便在确定被索引文档。
                 document.add(new TextField("contents", contents));
             } else if (prefix.equals("txt")) {
                 // add():把设置好的索引加到Document里，以便在确定被索引文档。
                 document.add(new TextField("contents", new FileReader(file)));
             }
             // Field.Store.YES：把文件名存索引文件里，为NO就说明不需要加到索引文件里去
             document.add(new StringField("FileName", file.getName(), Field.Store.YES));
             // 把完整路径存在索引文件里
             document.add(new StringField("fullPath", file.getCanonicalPath(), Field.Store.YES));

             // document.add(new TextField("size", file.getTotalSpace() + " bytes",
             // Field.Store.YES));
             document.add(new TextField("size", String.valueOf(fileLength), Field.Store.YES));

             // 开始写入,就把文档写进了索引文件里去了；
             writer.addDocument(document);

         } catch (EmptyFileException e) {

         } catch (IOException e) {
             e.printStackTrace();
         } catch (XmlException e) {
             e.printStackTrace();
         } catch (OpenXML4JException e) {
             e.printStackTrace();
         } finally {
             try {
                 if (null != extractorForDoc) {
                     extractorForDoc.close();
                 }
                 if (null != extractorForDocx) {
                     extractorForDocx.close();
                 }
             } catch (IOException e) {
                 // TODO 自动生成的 catch 块
                 e.printStackTrace();
             }
         }
     }

     @SuppressWarnings("unused")
     private void recursionDir(File f) {
         if (f != null) {
             if (f.isDirectory()) {
                 File[] fileArray = f.listFiles();
                 if (fileArray != null) {
                     for (int i = 0; i < fileArray.length; i++) {
                         // 递归调用
                         recursionDir(fileArray[i]);
                     }
                 }
             } else {
                 writeToIndex(f);
             }
         }
     }

     private void displayTokens(Analyzer analyzer, String text, String keyword) throws Exception {

         // System.out.println("当前使用的分词器：" + analyzer.getClass().getName());

         // 分词流，即将对象分词后所得的Token在内存中以流的方式存在，也说是说如果在取得Token必须从TokenStream中获取，而分词对象可以是文档文本，也可以是查询文本。
         TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(text));
         // 表示token的首字母和尾字母在原文本中的位置。比如I'm的位置信息就是(0,3)，需要注意的是startOffset与endOffset的差值并不一定就是termText.length()，
         // 因为可能term已经用stemmer或者其他过滤器处理过；
         OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
         // 这个有点特殊，它表示tokenStream中的当前token与前一个token在实际的原文本中相隔的词语数量，用于短语查询。比如：
         // 在tokenStream中[2:a]的前一个token是[1:I'm ]，
         // 它们在原文本中相隔的词语数是1，则token="a"的PositionIncrementAttribute值为1；
         PositionIncrementAttribute positionIncrementAttribute = tokenStream
                 .addAttribute(PositionIncrementAttribute.class);

         CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);

         // 表示token词典类别信息，默认为“Word”，比如I'm就属于<APOSTROPHE>，有撇号的类型；
         TypeAttribute typeAttribute = tokenStream.addAttribute(TypeAttribute.class);
         tokenStream.reset();

         int position = 0;
         while (tokenStream.incrementToken()) {
             int increment = positionIncrementAttribute.getPositionIncrement();
             if (increment > 0) {
                 position = position + increment;
             }
             int startOffset = offsetAttribute.startOffset();
             int endOffset = offsetAttribute.endOffset();
             String term = charTermAttribute.toString();
             // System.out.println("第" + position + "个分词：TYPE:" + typeAttribute.type() + "、["
             // + term + "]" + "、位置：["
             // + startOffset + "-->" + endOffset + "]");
             if (term.equals(keyword)) {
                 System.out.println("第" + position + "个分词：TYPE:" + typeAttribute.type() + "、[" + term + "]" + "、位置：["
                         + startOffset + "-->" + endOffset + "]");
             }
         }
         tokenStream.close();
     }

     /**
      * 读取txt文件的内容
      *
      * @param file
      *            想要读取的文件对象
      * @return 返回文件内容
      */
     public static String txt2String(File file) {
         StringBuilder result = new StringBuilder();
         try {
             BufferedReader br = new BufferedReader(new FileReader(file));// 构造一个BufferedReader类来读取文件
             String s = null;
             while ((s = br.readLine()) != null) {// 使用readLine方法，一次读一行
                 result.append(System.lineSeparator() + s);
             }
             br.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
         return result.toString();
     }

     /**
      * 递归删除目录下的所有文件及子目录下所有文件
      *
      * @param dir
      *            将要删除的文件目录
      *
      */
     private static boolean deleteDir(File dir) {
         if (dir.isDirectory()) {
             String[] children = dir.list();
             for (int i = 0; i < children.length; i++) {
                 boolean success = deleteDir(new File(dir, children[i]));
                 if (!success) {
                     return false;
                 }
             }
         }
         // 目录此时为空，可以删除
         return dir.delete();
     }

     /**
      * B方法追加文件：使用FileWriter
      */
     public static void appendMethodB(String fileName, String content) {
         try {
             // 打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
             FileWriter writer = new FileWriter(fileName, true);
             // FileWriter writer = new FileWriter(fileName, false);
             writer.write("\r\n");
             // content=new String(content.getBytes("ISO-8859-1"),"UTF-8");
             System.out.println("写入新词汇到ext.dic:[" + content + "]");
             writer.write(content);
             writer.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }