`
zzc1684
  • 浏览: 1228631 次
  • 性别: Icon_minigender_1
  • 来自: 广州
文章分类
社区版块
存档分类
最新评论

Java搜索工具——Lucene实例总结(一)

Java搜索工具——Lucene实例总结(一) 
阅读更多

    参考网页：http://footman265.iteye.com/blog/849744

    搞了一天半，终于利用lucene工具Demo完了我想要的功能，这其中包括为数据库建立增量索引、从索引文件根据id删除索引、单字段查询功能、多字段 查询功能、多条件查询功能以及查询结果关键字高亮显示的功能。今天晚些的时候把这些功能进行了整理。看样子一时半会还下不了班，就把Demo的结果 一 一 列举下来吧。。。

   

    理论参考：http://lianj-lee.iteye.com/category/69005?show_full=true

    Lucene3.0对数据库建立索引：http://269181927.iteye.com/blog/789779

 

1. 所需要的文件(见附件)

 

    依赖包：

    lucene-core-2.4.0.jar                   lucene工具包

    lucene-highlighter-2.4.0.jar          高亮显示工具包

    IKAnalyzer2.0.2OBF.jar                分词工具(支持字典分词)

    mysql-connector-java-5.0.3-bin    链接mysql驱动

 

    数据表：

    pd_ugc.sql(所在数据库为lucenetest)

 

    类文件：

    在附件index.rar和test.rar，解压后放入java工程中的src下即可

 

2. 为数据库建立增量索引

    参考网页：http://www.blogjava.net/laoding/articles/279230.html

Java代码  收藏代码
  1. package index;  
  2. //--------------------- Change Logs----------------------  
  3. // <p>@author zhiqiang.zhang Initial Created at 2010-12-23<p>  
  4. //-------------------------------------------------------  
  5. import java.io.BufferedReader;  
  6. import java.io.File;  
  7. import java.io.FileReader;  
  8. import java.io.FileWriter;  
  9. import java.io.IOException;  
  10. import java.io.PrintWriter;  
  11. import java.sql.Connection;  
  12. import java.sql.DriverManager;  
  13. import java.sql.ResultSet;  
  14. import java.sql.Statement;  
  15. import java.util.Date;  
  16.   
  17. import org.apache.lucene.analysis.Analyzer;  
  18. import org.apache.lucene.analysis.standard.StandardAnalyzer;  
  19. import org.apache.lucene.document.Document;  
  20. import org.apache.lucene.document.Field;  
  21. import org.apache.lucene.index.IndexWriter;  
  22.   
  23. //增量索引  
  24. /* 
  25.  * 实现思路:首次查询数据库表所有记录，对每条记录建立索引，并将最后一条记录的id存储到storeId.txt文件中 
  26.  *         当新插入一条记录时，再建立索引时不必再对所有数据重新建一遍索引， 
  27.  *         可根据存放在storeId.txt文件中的id查出新插入的数据，只对新增的数据新建索引，并把新增的索引追加到原来的索引文件中 
  28.  * */  
  29. public class IncrementIndex {  
  30.   
  31.     public static void main(String[] args) {  
  32.         try {  
  33.             IncrementIndex index = new IncrementIndex();  
  34.             String path = "E:\\workspace2\\Test\\lucene_test\\poiIdext";//索引文件的存放路径  
  35.             String storeIdPath = "E:\\workspace2\\Test\\lucene_test\\storeId.txt";//存储ID的路径  
  36.             String storeId = "";  
  37.             Date date1 = new Date();  
  38.             storeId = index.getStoreId(storeIdPath);  
  39.             ResultSet rs = index.getResult(storeId);  
  40.             System.out.println("开始建立索引。。。。");  
  41.             index.indexBuilding(path, storeIdPath, rs);  
  42.             Date date2 = new Date();  
  43.             System.out.println("耗时："+(date2.getTime()-date1.getTime())+"ms");  
  44.             storeId = index.getStoreId(storeIdPath);  
  45.             System.out.println(storeId);//打印出这次存储起来的ID  
  46.         } catch (Exception e) {  
  47.             e.printStackTrace();  
  48.         }  
  49.     }  
  50.   
  51.     public static void buildIndex(String indexFile, String storeIdFile) {  
  52.         try {  
  53.             String path = indexFile;//索引文件的存放路径  
  54.             String storeIdPath = storeIdFile;//存储ID的路径  
  55.             String storeId = "";  
  56.             storeId = getStoreId(storeIdPath);  
  57.             ResultSet rs = getResult(storeId);  
  58.             indexBuilding(path, storeIdPath, rs);  
  59.             storeId = getStoreId(storeIdPath);  
  60.             System.out.println(storeId);//打印出这次存储起来的ID  
  61.         } catch (Exception e) {  
  62.             e.printStackTrace();  
  63.         }  
  64.     }  
  65.   
  66.     public static ResultSet getResult(String storeId) throws Exception {  
  67.         Class.forName("com.mysql.jdbc.Driver").newInstance();  
  68.         String url = "jdbc:mysql://localhost:3306/lucenetest";  
  69.         String userName = "root";  
  70.         String password = "****";  
  71.         Connection conn = DriverManager.getConnection(url, userName, password);  
  72.         Statement stmt = conn.createStatement();  
  73.         String sql = "select  * from pd_ugc";  
  74.         ResultSet rs = stmt.executeQuery(sql + " where id > '" + storeId + "'order by id");  
  75.         return rs;  
  76.     }  
  77.   
  78.     public static boolean indexBuilding(String path, String storeIdPath, ResultSet rs) {  
  79.         try {  
  80.             Analyzer luceneAnalyzer = new StandardAnalyzer();  
  81.             // 取得存储起来的ID，以判定是增量索引还是重新索引  
  82.             boolean isEmpty = true;  
  83.             try {  
  84.                 File file = new File(storeIdPath);  
  85.                 if (!file.exists()) {  
  86.                     file.createNewFile();  
  87.                 }  
  88.                 FileReader fr = new FileReader(storeIdPath);  
  89.                 BufferedReader br = new BufferedReader(fr);  
  90.                 if (br.readLine() != null) {  
  91.                     isEmpty = false;  
  92.                 }  
  93.                 br.close();  
  94.                 fr.close();  
  95.             } catch (IOException e) {  
  96.                 e.printStackTrace();  
  97.             }  
  98.             //isEmpty=false表示增量索引  
  99.             IndexWriter writer = new IndexWriter(path, luceneAnalyzer, isEmpty);  
  100.             String storeId = "";  
  101.             boolean indexFlag = false;  
  102.             String id;  
  103.             String name;  
  104.             String address;  
  105.             String citycode;  
  106.             while (rs.next()) {  
  107.                 id = rs.getInt("id") + "";  
  108.                 name = rs.getString("name");  
  109.                 address = rs.getString("address");  
  110.                 citycode = rs.getString("citycode");  
  111.                 writer.addDocument(Document(id, name, address, citycode));  
  112.                 storeId = id;//将拿到的id给storeId，这种拿法不合理，这里为了方便  
  113.                 indexFlag = true;  
  114.             }  
  115.             writer.optimize();  
  116.             writer.close();  
  117.             if (indexFlag) {  
  118.                 // 将最后一个的ID存到磁盘文件中  
  119.                 writeStoreId(storeIdPath, storeId);  
  120.             }  
  121.             return true;  
  122.         } catch (Exception e) {  
  123.             e.printStackTrace();  
  124.             System.out.println("出错了" + e.getClass() + "\n   错误信息为:   " + e.getMessage());  
  125.             return false;  
  126.         }  
  127.   
  128.     }  
  129.   
  130.     public static Document Document(String id, String name, String address, String citycode) {  
  131.         Document doc = new Document();  
  132.         doc.add(new Field("id", id, Field.Store.YES, Field.Index.TOKENIZED));  
  133.         doc.add(new Field("name", name, Field.Store.YES, Field.Index.TOKENIZED));//查询字段  
  134.         doc.add(new Field("address", address, Field.Store.YES, Field.Index.TOKENIZED));  
  135.         doc.add(new Field("citycode", citycode, Field.Store.YES, Field.Index.TOKENIZED));//查询字段  
  136.         return doc;  
  137.     }  
  138.   
  139.     // 取得存储在磁盘中的ID  
  140.     public static String getStoreId(String path) {  
  141.         String storeId = "";  
  142.         try {  
  143.             File file = new File(path);  
  144.             if (!file.exists()) {  
  145.                 file.createNewFile();  
  146.             }  
  147.             FileReader fr = new FileReader(path);  
  148.             BufferedReader br = new BufferedReader(fr);  
  149.             storeId = br.readLine();  
  150.             if (storeId == null || storeId == "") storeId = "0";  
  151.             br.close();  
  152.             fr.close();  
  153.         } catch (Exception e) {  
  154.             e.printStackTrace();  
  155.         }  
  156.         return storeId;  
  157.     }  
  158.   
  159.     // 将ID写入到磁盘文件中  
  160.     public static boolean writeStoreId(String path, String storeId) {  
  161.         boolean b = false;  
  162.         try {  
  163.             File file = new File(path);  
  164.             if (!file.exists()) {  
  165.                 file.createNewFile();  
  166.             }  
  167.             FileWriter fw = new FileWriter(path);  
  168.             PrintWriter out = new PrintWriter(fw);  
  169.             out.write(storeId);  
  170.             out.close();  
  171.             fw.close();  
  172.             b = true;  
  173.         } catch (IOException e) {  
  174.             e.printStackTrace();  
  175.         }  
  176.         return b;  
  177.     }  
  178. }  

 

3. 索引操作

Java代码  收藏代码
  1. package index;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.Reader;  
  5. import java.io.StringReader;  
  6. import java.util.ArrayList;  
  7. import java.util.Date;  
  8. import java.util.List;  
  9.   
  10. import org.apache.lucene.analysis.Analyzer;  
  11. import org.apache.lucene.analysis.StopFilter;  
  12. import org.apache.lucene.analysis.Token;  
  13. import org.apache.lucene.analysis.TokenStream;  
  14. import org.apache.lucene.analysis.standard.StandardAnalyzer;  
  15. import org.apache.lucene.document.Document;  
  16. import org.apache.lucene.index.CorruptIndexException;  
  17. import org.apache.lucene.index.IndexReader;  
  18. import org.apache.lucene.index.Term;  
  19. import org.apache.lucene.queryParser.MultiFieldQueryParser;  
  20. import org.apache.lucene.queryParser.ParseException;  
  21. import org.apache.lucene.queryParser.QueryParser;  
  22. import org.apache.lucene.search.BooleanClause;  
  23. import org.apache.lucene.search.BooleanQuery;  
  24. import org.apache.lucene.search.Hits;  
  25. import org.apache.lucene.search.IndexSearcher;  
  26. import org.apache.lucene.search.Query;  
  27. import org.apache.lucene.search.ScoreDoc;  
  28. import org.apache.lucene.search.TopDocCollector;  
  29. import org.apache.lucene.search.highlight.Highlighter;  
  30. import org.apache.lucene.search.highlight.QueryScorer;  
  31. import org.apache.lucene.search.highlight.SimpleFragmenter;  
  32. import org.apache.lucene.search.highlight.SimpleHTMLFormatter;  
  33. import org.mira.lucene.analysis.IK_CAnalyzer;  
  34.   
  35. public class IndexUtils {  
  36.   
  37.     //0. 创建增量索引  
  38.     public static void buildIndex(String indexFile, String storeIdFile) {  
  39.         IncrementIndex.buildIndex(indexFile, storeIdFile);  
  40.     }  
  41.   
  42.     //1. 单字段查询  
  43.     @SuppressWarnings("deprecation")  
  44.     public static List<IndexResult> queryByOneKey(IndexSearcher indexSearcher, String field,  
  45.             String key) {  
  46.         try {  
  47.             Date date1 = new Date();  
  48.             QueryParser queryParser = new QueryParser(field, new StandardAnalyzer());  
  49.             Query query = queryParser.parse(key);  
  50.             Hits hits = indexSearcher.search(query);  
  51.             Date date2 = new Date();  
  52.             System.out.println("耗时：" + (date2.getTime() - date1.getTime()) + "ms");  
  53.             List<IndexResult> list = new ArrayList<IndexResult>();  
  54.             for (int i = 0; i < hits.length(); i++) {  
  55.                 list.add(getIndexResult(hits.doc(i)));  
  56.             }  
  57.             return list;  
  58.         } catch (ParseException e) {  
  59.             e.printStackTrace();  
  60.         } catch (IOException e) {  
  61.             e.printStackTrace();  
  62.         }  
  63.         return null;  
  64.     }  
  65.   
  66.     //2. 多条件查询。这里实现的是and操作  
  67.     //注：要查询的字段必须是index的  
  68.     //即doc.add(new Field("pid", rs.getString("pid"), Field.Store.YES,Field.Index.TOKENIZED));     
  69.     @SuppressWarnings("deprecation")  
  70.     public static List<IndexResult> queryByMultiKeys(IndexSearcher indexSearcher, String[] fields,  
  71.             String[] keys) {  
  72.   
  73.         try {  
  74.             BooleanQuery m_BooleanQuery = new BooleanQuery();  
  75.             if (keys != null && keys.length > 0) {  
  76.                 for (int i = 0; i < keys.length; i++) {  
  77.                     QueryParser queryParser = new QueryParser(fields[i], new StandardAnalyzer());  
  78.                     Query query = queryParser.parse(keys[i]);  
  79.                     m_BooleanQuery.add(query, BooleanClause.Occur.MUST);//and操作  
  80.                 }  
  81.                 Hits hits = indexSearcher.search(m_BooleanQuery);  
  82.                 List<IndexResult> list = new ArrayList<IndexResult>();  
  83.                 for (int i = 0; i < hits.length(); i++) {  
  84.                     list.add(getIndexResult(hits.doc(i)));  
  85.                 }  
  86.                 return list;  
  87.             }  
  88.         } catch (ParseException e) {  
  89.             e.printStackTrace();  
  90.         } catch (IOException e) {  
  91.             e.printStackTrace();  
  92.         }  
  93.         return null;  
  94.     }  
  95.   
  96.     //3.高亮显示  实现了单条件查询  
  97.     //可改造为多条件查询  
  98.     public static List<IndexResult> highlight(IndexSearcher indexSearcher, String key) {  
  99.         try {  
  100.             QueryParser queryParser = new QueryParser("name", new StandardAnalyzer());  
  101.             Query query = queryParser.parse(key);  
  102.             TopDocCollector collector = new TopDocCollector(800);  
  103.             indexSearcher.search(query, collector);  
  104.             ScoreDoc[] hits = collector.topDocs().scoreDocs;  
  105.   
  106.             Highlighter highlighter = null;  
  107.             SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<font color='red'>",  
  108.                     "</font>");  
  109.             highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));  
  110.             highlighter.setTextFragmenter(new SimpleFragmenter(200));  
  111.             List<IndexResult> list = new ArrayList<IndexResult>();  
  112.             Document doc;  
  113.             for (int i = 0; i < hits.length; i++) {  
  114.                 //System.out.println(hits[i].score);  
  115.                 doc = indexSearcher.doc(hits[i].doc);  
  116.                 TokenStream tokenStream = new StandardAnalyzer().tokenStream("name",  
  117.                         new StringReader(doc.get("name")));  
  118.                 IndexResult ir = getIndexResult(doc);  
  119.                 ir.setName(highlighter.getBestFragment(tokenStream, doc.get("name")));  
  120.                 list.add(ir);  
  121.             }  
  122.             return list;  
  123.         } catch (ParseException e) {  
  124.             e.printStackTrace();  
  125.         } catch (IOException e) {  
  126.             e.printStackTrace();  
  127.         }  
  128.         return null;  
  129.   
  130.     }  
  131.   
  132.     //4. 多字段查询  
  133.     @SuppressWarnings("deprecation")  
  134.     public static List<IndexResult> queryByMultiFileds(IndexSearcher indexSearcher,  
  135.             String[] fields, String key) {  
  136.         try {  
  137.             MultiFieldQueryParser mfq = new MultiFieldQueryParser(fields, new StandardAnalyzer());  
  138.             Query query = mfq.parse(key);  
  139.             Hits hits = indexSearcher.search(query);  
  140.             List<IndexResult> list = new ArrayList<IndexResult>();  
  141.             for (int i = 0; i < hits.length(); i++) {  
  142.                 list.add(getIndexResult(hits.doc(i)));  
  143.             }  
  144.   
  145.             return list;  
  146.         } catch (ParseException e) {  
  147.             e.printStackTrace();  
  148.         } catch (IOException e) {  
  149.             e.printStackTrace();  
  150.         }  
  151.         return null;  
  152.     }  
  153.   
  154.     //5. 删除索引  
  155.     public static void deleteIndex(String indexFile, String id) throws CorruptIndexException,  
  156.             IOException {  
  157.         IndexReader indexReader = IndexReader.open(indexFile);  
  158.         indexReader.deleteDocuments(new Term("id", id));  
  159.         indexReader.close();  
  160.     }  
  161.   
  162.     //6. 一元分词  
  163.     @SuppressWarnings("deprecation")  
  164.     public static String Standard_Analyzer(String str) {  
  165.         Analyzer analyzer = new StandardAnalyzer();  
  166.         Reader r = new StringReader(str);  
  167.         StopFilter sf = (StopFilter) analyzer.tokenStream("", r);  
  168.         System.out.println("=====StandardAnalyzer====");  
  169.         System.out.println("分析方法：默认没有词只有字（一元分词）");  
  170.         Token t;  
  171.         String results = "";  
  172.         try {  
  173.             while ((t = sf.next()) != null) {  
  174.                 System.out.println(t.termText());  
  175.                 results = results + " " + t.termText();  
  176.             }  
  177.         } catch (IOException e) {  
  178.             e.printStackTrace();  
  179.         }  
  180.         return results;  
  181.     }  
  182.   
  183.     //7. 字典分词  
  184.     @SuppressWarnings("deprecation")  
  185.     public static String ik_CAnalyzer(String str) {  
  186.         Analyzer analyzer = new IK_CAnalyzer();  
  187.         Reader r = new StringReader(str);  
  188.         TokenStream ts = (TokenStream) analyzer.tokenStream("", r);  
  189.         System.out.println("=====IK_CAnalyzer====");  
  190.         System.out.println("分析方法:字典分词,正反双向搜索");  
  191.         Token t;  
  192.         String results = "";  
  193.         try {  
  194.             while ((t = ts.next()) != null) {  
  195.                 System.out.println(t.termText());  
  196.                 results = results + " " + t.termText();  
  197.             }  
  198.         } catch (IOException e) {  
  199.             e.printStackTrace();  
  200.         }  
  201.         return results;  
  202.     }  
  203.   
  204.     //在结果中搜索  
  205.     public static void queryFromResults() {  
  206.   
  207.     }  
  208.   
  209.     //组装对象  
  210.     public static IndexResult getIndexResult(Document doc) {  
  211.         IndexResult ir = new IndexResult();  
  212.         ir.setId(doc.get("id"));  
  213.         ir.setName(doc.get("name"));  
  214.         ir.setAddress(doc.get("address"));  
  215.         ir.setCitycode(doc.get("citycode"));  
  216.         return ir;  
  217.     }  
  218. }  

 

    查询索引结果对象：IndexResult

Java代码  收藏代码
  1. package index;  
  2.   
  3. public class IndexResult {  
  4.   
  5.     private String id;  
  6.   
  7.     private String name;  
  8.   
  9.     private String address;  
  10.   
  11.     private String citycode;  
  12.   
  13.       
  14.     public String getId() {  
  15.         return id;  
  16.     }  
  17.     public void setId(String id) {  
  18.         this.id = id;  
  19.     }  
  20.     public String getName() {  
  21.         return name;  
  22.     }  
  23.     public void setName(String name) {  
  24.         this.name = name;  
  25.     }  
  26.   
  27.       
  28.     public String getAddress() {  
  29.         return address;  
  30.     }  
  31.     public void setAddress(String address) {  
  32.         this.address = address;  
  33.     }  
  34.     public String getCitycode() {  
  35.         return citycode;  
  36.     }  
  37.     public void setCitycode(String citycode) {  
  38.         this.citycode = citycode;  
  39.     }  
  40.       
  41. }  

 

4. 测试类

Java代码  收藏代码
  1. package test;  
  2.   
  3. /** 
  4.  * $Id$ 
  5.  * Copyright 2009-2010 Oak Pacific Interactive. All rights reserved. 
  6.  */  
  7.   
  8. import index.IndexResult;  
  9. import index.IndexUtils;  
  10.   
  11. import java.util.Date;  
  12. import java.util.List;  
  13.   
  14. import org.apache.lucene.search.IndexSearcher;  
  15.   
  16. public class Test {  
  17.   
  18.     //存放索引文件  
  19.     private static String indexFile = "E:\\workspace2\\Test\\lucene_test\\poiIdext";  
  20.   
  21.     //存放id  
  22.     private static String storeIdFile = "E:\\workspace2\\Test\\lucene_test\\storeId.txt";  
  23.   
  24.     public static void main(String[] args) throws Exception {  
  25.         //0. 创建增量索引  
  26.         IndexUtils.buildIndex(indexFile, storeIdFile);  
  27.           
  28.         IndexSearcher indexSearcher = new IndexSearcher(indexFile);  
  29.         String key = IndexUtils.ik_CAnalyzer("静安中心");  
  30.   
  31.         //1.单字段查询  
  32.         Date date1 = new Date();  
  33.         List<IndexResult> list = IndexUtils.queryByOneKey(indexSearcher, "name", key);  
  34.         Date date2 = new Date();  
  35.         System.out.println("耗时：" + (date2.getTime() - date1.getTime()) + "ms\n" + list.size()  
  36.                 + "条=======================================单字段查询");  
  37.         //printResults(list);  
  38.   
  39.         //2.多条件查询  
  40.         String[] fields = { "name", "citycode" };  
  41.         String[] keys = { IndexUtils.ik_CAnalyzer("静安中心"), "0000" };  
  42.         date1 = new Date();  
  43.         list = IndexUtils.queryByMultiKeys(indexSearcher, fields, keys);  
  44.         date2 = new Date();  
  45.         System.out.println("耗时：" + (date2.getTime() - date1.getTime()) + "ms\n" + list.size()  
  46.                 + "条\n===============================多条件查询");  
  47.         printResults(list);  
  48.   
  49.         //3.高亮显示  单字段查询  
  50.         System.out.println("\n\n");  
  51.         date1 = new Date();  
  52.         list = IndexUtils.highlight(indexSearcher, key);  
  53.         date2 = new Date();  
  54.         System.out.println("耗时：" + (date2.getTime() - date1.getTime()) + "ms\n" + list.size()  
  55.                 + "条\n======================================高亮显示");  
  56.        // printResults(list);  
  57.   
  58.         //4. 多字段查询  
  59.         date1 = new Date();  
  60.         list = IndexUtils.queryByMultiFileds(indexSearcher, fields, key);  
  61.         date2 = new Date();  
  62.         System.out.println("耗时：" + (date2.getTime() - date1.getTime()) + "ms\n" + list.size()  
  63.                 + "条\n=====================================多字段查询");  
  64.        // printResults(list);  
  65.   
  66.         //5. 删除索引中的字段  根据id进行删除  
  67.         IndexUtils.deleteIndex(indexFile, "123");  
  68.     }  
  69.   
  70.     //打印结果  
  71.     public static void printResults(List<IndexResult> list) {  
  72.         if (list != null && list.size() > 0) {  
  73.             for (int i = 0; i < list.size(); i++) {  
  74.                 System.out.println(list.get(i).getId() + "," + list.get(i).getName() + ","  
  75.                         + list.get(i).getAddress() + "," + list.get(i).getCitycode()+"--->"+i);  
  76.             }  
  77.         }  
  78.     }  
  79. }  

 

5. 其它

 

全文索引：

目前的情况是，搜索hello,"hello world"、"hi hello, how are you"但"worldhello"显示不出来

 

默认情况下，QueryParser不支持通配符打头的查询（如，*ook）。不过在Lucene 2.1版本以后，他们可以通过调用QueryParser.setAllowLeadingWildcard( true )的 方法打开这一功能。注意，这是一个开销很大的操作：它需要扫描索引中全部记号的列表，来寻找匹配这个模式的词。(译注：高效支持这种后缀查询的办法是，建立反序的记号表，Lucene没有实现这一模式。)http://www.codechina.org/faq/show/42/

 

支持空格分词搜索："厕所 26 沈阳" 这是三个词

不支持：“厕所沈阳”这是一个词

 

Lucene能实现“在搜索结果中搜索”的功能么，也就是说第二个搜索仅在第一个搜索结果中进行？

http://www.codechina.org/faq/show/63/

可以。主要有两种做法：

  • 使用QueryFilter把第一个查询当作一个过滤器处理。（你可以在Lucene的邮件列表里面搜索 QueryFilter， Doug Cutting（Lucene的最初作者）反对这种做法。）
  • 用BooleanQuery把前后两个查询结合起来，前一个查询使用 required选项。

我们推荐使用BooleanQuery的方法。

 

============

 // 创建标准文本分析器， 标准的是可以支持的中文的

   Analyzer luceneAnalyzer = new StandardAnalyzer();

   indexWriter = new IndexWriter(indexDir, luceneAnalyzer, true);

   // 可以说是创建一个新的写入工具

   // 第一个参数是要索引建立在哪个目录里

   // 第二个参数是新建一个文本分析器,这里用的是标准的大家也可以自己写一个

   // 第三个参数如果是true，在建立索引之前先将c: \\index目录清空

 

 

 

poi_data_ugc搜索中，索引放在内存里还是磁盘上？？？？

 

针对于lucene使用和优化

http://hi.baidu.com/lewutian/blog/item/48a86d03de58b984d43f7c1b.html

 

ucene入门实例(1):索引文本文件

http://www.java3z.com/cwbwebhome/article/article5/51021.html

分享到：
| 解决jquery-easyui1.3.3 combobox 多选模式 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JSP搜索链接类实例开发源码——java(结合lucene)版的公交搜索系统.zip

    本实例——"JSP搜索链接类实例开发源码——java(结合lucene)版的公交搜索系统"，就是一种实现高效、精准搜索的典型应用，它将Java服务器页面（JSP）与全文搜索引擎Lucene相结合，为用户提供便捷的公交线路查询服务。...

    全文检索技术学习(三)——Lucene支持中文分词 - 李阿昀的博客 - CSDN博客1

    在全文检索技术中，Lucene 是一个非常重要的开源搜索引擎库，它提供了强大的文本分析和索引功能。在处理中文文本时，由于中文的特殊性，需要进行分词处理才能有效地进行搜索。本篇博客主要讨论了如何使用 Lucene ...

    解密搜索引擎技术实战++Lucene&amp;Java;精华版_.pdf

    《解密搜索引擎技术实战——Lucene&Java精华版》是一本深入探讨搜索引擎技术的专业书籍，主要聚焦于开源全文搜索引擎库Lucene以及与之配合的Java编程语言。这本书旨在帮助读者理解搜索引擎的工作原理，并通过实际...

    全文检索保存在文件中的数据——简单实例

    在"工具"标签的上下文中，我们可以理解为这个实例可能是介绍如何将Lucene作为工具集成到实际项目中，例如，构建一个简单的文件搜索应用，使得用户能够快速找到存储在大量文件中的信息。 总的来说，这篇博客可能详细...

    Lucene nutch 搜索引擎 开发 实例 源码

    本文将深入探讨基于Java的开源搜索引擎框架——Lucene和Nutch，以及如何通过源码学习它们的开发实践。 Lucene是一个全文检索库，它提供了一个简单的API，开发者可以使用这些API来构建自己的搜索功能。Lucene的核心...

    lucene4.6实例

    3. **Lucene 4.6实例——LuceneDemo** - 创建索引：首先，我们需要创建一个`IndexWriter`实例，将文档和字段添加到索引中。`Analyzer`负责分词，可以选择不同的分析器来处理不同语言或需求。 - 搜索：使用`...

    Lucene-Demo.rar Lucene分词的demo

    Lucene是一个强大的全文搜索引擎库，广泛应用于各种文本检索和分析系统中。这个名为"Lucene-Demo.rar"的压缩包提供了一个基于Lucene的分词演示项目，可以帮助开发者快速理解和应用Lucene的分词功能。在这个压缩包中...

    Lucene初探，一个初级的LuceneDemo

    Apache Lucene就是这样一款强大的开源全文搜索引擎库，它为开发者提供了构建自定义搜索引擎所需的全部工具。这篇博客将带你初探Lucene，通过一个初级的LuceneDemo来了解其基本概念和操作。 首先，让我们了解一下...

    搜索引擎开发工具包--lucene

    总之，Lucene是一个功能强大、易于集成的搜索引擎开发工具包，通过它，开发者可以轻松地为自己的应用程序添加高质量的搜索功能，提高用户体验，并且节省大量的开发时间。无论是小型项目还是大型企业级应用，Lucene都...

    lucene solr框架代码实例（可直接运行）

    《深入理解Lucene与Solr：Java搜索框架的实践指南》 ...通过学习和实践"lucene solr框架代码实例（可直接运行）"，开发者可以快速掌握这两款工具，并应用于各种搜索应用场景，提升数据检索的效率和用户体验。

    lucene全文检索资源包

    这个“lucene全文检索资源包”包含了 Lucene 的一个早期版本——1.4.3，虽然版本较老，但对于了解 Lucene 的基本原理和操作仍然具有一定的参考价值。 **一、全文检索概述** 全文检索是一种能够在大量文本数据中快速...

    lucene开发实例

    Lucene 是一个开源的Java库，主要用于文本检索和分析。它支持索引和搜索大量数据，提供分词、文档分析、评分和排序等功能。Lucene 广泛应用于网站搜索、企业内部信息检索、大数据分析等领域。 二、Lucene 的核心...

    简单的lucene demo

    4. **Lucene的简单demo**：这个项目包含两个关键文件——`TestLuceneSearch.java`和`TestLuceneIndex.java`，分别代表了Lucene的索引创建和搜索功能的示例代码。通过这两个文件，我们可以了解如何初始化索引器、添加...

    lucene实现 源代码，里面还含有索引创建，搜索等功能

    总结来说，这个压缩包中的源代码提供了Lucene索引创建和搜索的实践示例，对于学习Java和Lucene的开发者来说，这是一个宝贵的资源。通过深入理解并实践这些代码，你可以掌握如何在实际项目中应用Lucene来构建高效的...

    lucene3.5全文检索案例lucene+demo

    总结，Lucene 3.5作为一个强大的全文检索工具，提供了高效、灵活的解决方案。通过理解其核心概念和功能，结合实际案例进行实践，我们可以快速地在自己的项目中集成全文检索功能，提升用户搜索体验。

    Lucene实战

    《Lucene实战》第二版是一本深入探讨Apache Lucene搜索引擎库的权威指南。这本书主要针对开发者，特别是那些希望在自己的应用程序中集成全文搜索功能的人。Lucene是一个高性能、全文本检索库，它允许开发人员轻松地...

    Apache Lucene3.0 入门实例介绍

    Apache Lucene是一个高性能、全文本搜索库，由Java编写，被广泛应用于各种搜索引擎的开发中。这个入门实例将引导我们了解如何使用Lucene 3.0版本进行基本的索引和搜索操作。以下是对Lucene 3.0关键知识点的详细讲解...

Magicbox
Global site tag (gtag.js) - Google Analytics