Lucene学习

最新推荐文章于 2024-08-10 14:11:54 发布

转载最新推荐文章于 2024-08-10 14:11:54 发布 · 240 阅读

很早就听说Lucene的大名了，但一直没空研究，这几天比较闲，抽了一个下午时间，学习了一下Lucene，写了一个简单的Demo，总的感受是使用起来简单方便，在使用之前，首先要理解以下关键的类：

Document
Document 是用来描述文档的，这里的文档可以指一个 HTML 页面，一封电子邮件，或者是一个文本文件。一个 Document 对象由多个 Field 对象组成的。可以把一个 Document 对象想象成数据库中的一个记录，而每个 Field 对象就是记录的一个字段。
Field
Field 对象是用来描述一个文档的某个属性的，比如一封电子邮件的标题和内容可以用两个 Field 对象分别描述。
Analyzer
在一个文档被索引之前，首先需要对文档内容进行分词处理，这部分工作就是由 Analyzer 来做的。Analyzer 类是一个抽象类，它有多个实现。针对不同的语言和应用需要选择适合的 Analyzer。Analyzer 把分词后的内容交给 IndexWriter 来建立索引。
IndexWriter
IndexWriter 是 Lucene 用来创建索引的一个核心的类，他的作用是把一个个的 Document 对象加到索引中来。
Directory
这个类代表了 Lucene 的索引的存储的位置，这是一个抽象类，它目前有两个实现，第一个是 FSDirectory，它表示一个存储在文件系统中的索引的位置。第二个是 RAMDirectory，它表示一个存储在内存当中的索引的位置。

Query
这是一个抽象类，他有多个实现，比如 TermQuery, BooleanQuery, PrefixQuery. 这个类的目的是把用户输入的查询字符串封装成 Lucene 能够识别的 Query。

IndexSearcher
IndexSearcher 是用来在建立好的索引上进行搜索的。它只能以只读的方式打开一个索引，所以可以有多个 IndexSearcher 的实例在一个索引上进行操作。

Hits
Hits 是用来保存搜索结果的。

理解了这些类之后，我写了一个简单的demo，包括索引构建和索引搜索，以后如果要做复杂的搜索，可以根据这个demo做扩展，是不是很简单哈。

1.开始导入相应的jar包

2.Demo编写

public class Item {
   private String id;
   private String title;
   private String content;

   public Item() {
   }

   public Item(String id, String title, String content) {
       this.id = id;
       this.title = title;
       this.content = content;
   }

   public String getId() {
       return id;
   }

   public void setId(String id) {
       this.id = id;
   }

   public String getTitle() {
       return title;
   }

   public void setTitle(String title) {
       this.title = title;
   }

   public String getContent() {
       return content;
   }

   public void setContent(String content) {
       this.content = content;
   }

   public String toString() {
       StringBuilder sb = new StringBuilder();
       sb.append("[id=").append(id).append(",title=").append(title).append(",content=").append(content).append("]");
       return sb.toString();
   }
}

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

public class LuceneDemo {
   private boolean buildIndexer(Analyzer analyzer, Directory directory, List<Item> items) {
       IndexWriter iwriter = null;
       try {
           // 配置索引
           iwriter = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_4_10_4, analyzer));
           // 删除所有document
           iwriter.deleteAll();
           // 将文档信息存入索引
           Document doc[] = new Document[items.size()];
           for (int i = 0; i < items.size(); i++) {
               doc[i] = new Document();

               Item item = items.get(i);
               java.lang.reflect.Field[] fields = item.getClass().getDeclaredFields();
               for (java.lang.reflect.Field field : fields) {
                   String fieldName = field.getName();
                   String getMethodName = "get" + toFirstLetterUpperCase(fieldName);
                   Object obj = item.getClass().getMethod(getMethodName).invoke(item);
                   doc[i].add(new Field(fieldName, (String) obj, TextField.TYPE_STORED));
               }
               iwriter.addDocument(doc[i]);
           }

       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           try {
               iwriter.close();
           } catch (IOException e) {
           }
       }
       return true;
   }

   /**
   * 72 * 根据keyword搜索索引 73 * @param analyzer 74 * @param directory 75 * @param
   * keyword 76 * @return 77
   */
   public List<Item> searchIndexer(Analyzer analyzer, Directory directory, String keyword) {
       DirectoryReader ireader = null;
       List<Item> result = new ArrayList<Item>();
       try {
           // 设定搜索目录
           ireader = DirectoryReader.open(directory);
           IndexSearcher isearcher = new IndexSearcher(ireader);

           // 对多field进行搜索
           java.lang.reflect.Field[] fields = Item.class.getDeclaredFields();
           int length = fields.length;
           String[] multiFields = new String[length];
           for (int i = 0; i < length; i++) {
               multiFields[i] = fields[i].getName();
           }
           MultiFieldQueryParser parser = new MultiFieldQueryParser(multiFields, analyzer);

           // 设定具体的搜索词
           Query query = parser.parse(keyword);
           ScoreDoc[] hits = isearcher.search(query, null, 10).scoreDocs;
           for (int i = 0; i < hits.length; i++) {
               Document hitDoc = isearcher.doc(hits[i].doc);
               Item item = new Item();
               for (String field : multiFields) {
                   String setMethodName = "set" + toFirstLetterUpperCase(field);
                   item.getClass().getMethod(setMethodName, String.class).invoke(item, hitDoc.get(field));
               }
               result.add(item);
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           try {
               ireader.close();
               directory.close();
           } catch (IOException e) {
           }
       }
       return result;
   }

   /**
   * 首字母转大写
   *
   * @param str
   * @return
   */
   public static String toFirstLetterUpperCase(String str) {
       if (str == null || str.length() < 2) {
           return str;
       }
       return str.substring(0, 1).toUpperCase() + str.substring(1, str.length());
   }

   public static void main(String[] args) throws Exception {
       LuceneDemo demo = new LuceneDemo();
       Analyzer analyzer = new StandardAnalyzer();
       List<Item> items = new ArrayList<Item>();
       items.add(new Item("1", "first", "This is the text to be greatly indexed."));
       items.add(new Item("2", "second", "This is great"));
       items.add(new Item("3", "third", "I love apple and pear. "));
       items.add(new Item("4", "four", "我是中国人"));
       items.add(new Item("5", "five", "我叫何瑞"));

       // 索引存到内存中的目录
       // Directory directory = new RAMDirectory();
       // 索引存储到硬盘
       File file = new File("d:/lucene");
       Directory directory = FSDirectory.open(file);
       demo.buildIndexer(analyzer, directory, items);
       List<Item> result = demo.searchIndexer(analyzer, directory, "text");

       for (Item item : result) {
           System.out.println(item.toString());
       }
   }
}