Lucene 全功能

package com.diyi.util;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FuzzyQuery;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MultiSearcher;
import org.apache.lucene.search.PrefixQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.RangeQuery;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.search.highlight.Highlighter;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.SimpleFragmenter;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
import org.mira.lucene.analysis.IK_CAnalyzer;

import com.diyi.core.web.BaseAction;
public class LuceneTest extends BaseAction{
    
        private static final long serialVersionUID = 1L;
    /*
     * lucene全功能，几乎包含了大部分查询综合起来。，
     */
        static String path="e:\\Lucene测试\\";
        static String ArticleTitle="ArticleTitle";
        static String ArticleText="ArticleText";
        static String ArticleTime="ArticleTime";
        public static void index() throws Exception {
            /* 创建索引初始化，执行这些语句将创建或清空d:\\save\\目录下所有索引 */
            File file=new File(path);
            if(file.isDirectory())
            {
                file.delete();
            }
            IK_CAnalyzer ikAnalyzer=new IK_CAnalyzer();
            IndexWriter writer1 = new IndexWriter(path,ikAnalyzer, true);
             writer1.close();
//              IndexReader indexReader=IndexReader.open(path);
//              indexReader.deleteDocument(1);
            /*
             * 往创建的初始化索引中添加索引内容，StandardAnalyzer表示用lucene自带的标准分词机制，
             * false表示不覆盖原来该目录的索引，细心的读者可能已经发现， 这句话和上面的那句就这个false不一样
             */
            IndexWriter writer2 = new IndexWriter(path,
                    ikAnalyzer, false);
            /* 创建一份文件 */
            Document doc1 = new Document();
            /*
             * 创建一个域ArticleTitle，并往这个域里面添加内容 "Field.Store.YES"表示域里面的内容将被存储到索引
             * "Field.Index.TOKENIZED"表示域里面的内容将被索引，以便用来搜索
             *  Lucene给文档的字段设定三个布尔变量: 索引(indexed), 存储(stored), 切词(tokenized) ,
             */
            Field field1 = new Field(ArticleTitle, "上海2010年世博会,hot,GOOGLE和Yahoo 赞助,test,中华人民共和国万岁", Field.Store.YES,
                    Field.Index.TOKENIZED);
            /* 往文件里添加这个域 */
            doc1.add(field1);
            /* 同理：创建另外一个域ArticleText，并往这个域里面添加内容 */
            Field field2 = new Field(ArticleText, "这是一届创造绿色环境,点燃激情,影响深远的博览会....god..Hotmail,text,foam,OpenOffica",
                    Field.Store.YES, Field.Index.TOKENIZED);
            doc1.add(field2);
           
            Field field3 = new Field(ArticleTime, "2009",
                    Field.Store.YES, Field.Index.TOKENIZED);
            doc1.add(field3);
            // 在这里还可以添加其他域
            /* 添加这份文件到索引 */
            writer2.addDocument(doc1);

            /* 同理：创建第二份文件 */
            Document doc2 = new Document();
            field1 = new Field(ArticleTitle, "中国获得全球赞誉,世界人民大团结万岁,text", Field.Store.YES,
                    Field.Index.TOKENIZED);
            doc2.add(field1);
            field2 = new Field(ArticleText, "中国上海世博馆雄踞东方,傲视全球........,roams,OpenOffice",
                    Field.Store.YES, Field.Index.TOKENIZED);
            doc2.add(field2);
            field3 = new Field(ArticleTime, "2010",
                    Field.Store.YES, Field.Index.TOKENIZED);
            doc2.add(field3);
          /*
           *
           *
           */
            writer2.addDocument(doc2);

            // 在这里可以添加其他文件
            //writer2.optimize();
            /* 关闭 */
            writer2.close();
        }

        public  String  searchIndex() throws Exception {
             LuceneTest.index();
             String keywords=getRequest().getParameter("serchString");
            /* 创建一个搜索，搜索刚才创建的目录下的索引 */
            IndexSearcher indexSearcher = new IndexSearcher(path);
            /* 在这里我们只需要搜索一个目录 */
            IndexSearcher indexSearchers[] = { indexSearcher };
            /* 我们需要搜索两个域ArticleTitle, ArticleText里面的内容 */
            String[] fields = {ArticleTitle,
                    ArticleText ,ArticleTime};
            /* 下面这个表示要同时搜索这两个域，而且只要一个域里面有满足我们搜索的内容就行
            BooleanClause.Occur[]数组,它表示多个条件之间的关系,BooleanClause.Occur.MUST表示and,
            BooleanClause.Occur.MUST_NOT表示not,BooleanClause.Occur.SHOULD表示or.
            1、MUST和MUST表示“与”的关系，即“并集”。
            2、MUST和MUST_NOT前者包含后者不包含。
            3、MUST_NOT和MUST_NOT没意义
            4、SHOULD与MUST表示MUST，SHOULD失去意义；
            5、SHOUlD与MUST_NOT相当于MUST与MUST_NOT。
            6、SHOULD与SHOULD表示“或”的概念*/
            BooleanClause.Occur[] clauses = { BooleanClause.Occur.SHOULD,
                    BooleanClause.Occur.SHOULD,BooleanClause.Occur.SHOULD};
            /*
             * MultiFieldQueryParser表示多个域解析，
             * 同时可以解析含空格的字符串，如果我们搜索"上海 中国"
             */
            Analyzer analyzer=new  IK_CAnalyzer();
            Query multiFieldQuery = MultiFieldQueryParser.parse(keywords, fields, clauses,
                    analyzer);
            Query termQuery= new TermQuery(new Term(ArticleTitle, keywords));//词语搜索,完全匹配,搜索具体的域
           
            Query wildqQuery=new WildcardQuery(new Term(ArticleTitle,keywords));//通配符查询
           
            Query prefixQuery=new PrefixQuery(new Term(ArticleText,keywords));//字段前缀搜索
           
            Query fuzzyQuery=new FuzzyQuery(new Term(ArticleText,keywords));//相似度查询,模糊查询比如OpenOffica，OpenOffice
             
            Query rangQuery=new RangeQuery(new Term(ArticleTime,keywords), new Term(ArticleTime,keywords), true);//数字范围查询
            /* Multisearcher表示多目录搜索，在这里我们只有一个目录 */
            MultiSearcher searcher = new MultiSearcher(indexSearchers);
            //多条件搜索
            BooleanQuery multiQuery=new BooleanQuery();
           
            multiQuery.add(wildqQuery, BooleanClause.Occur.SHOULD);
            multiQuery.add(multiFieldQuery, BooleanClause.Occur.SHOULD);
            multiQuery.add(termQuery, BooleanClause.Occur.SHOULD);
            multiQuery.add(prefixQuery, BooleanClause.Occur.SHOULD);
            multiQuery.add(fuzzyQuery, BooleanClause.Occur.SHOULD);
            multiQuery.add(rangQuery, BooleanClause.Occur.SHOULD);
           
            Sort sort=new Sort(ArticleTime);//排序
            /* 开始搜索 */
            Hits h = searcher.search(multiQuery,sort);
            String highTitle="";
            String highText="";
            List<String> list=new ArrayList<String>();
             /* 把搜索出来的所有文件打印出来 */
            for (int i = 0; i < h.length(); i++) {
                 //打印出文件里面ArticleTitle域里面的内容
                String title=h.doc(i).get(ArticleTitle);
                // 打印出文件里面ArticleText域里面的内容 
                String text=h.doc(i).get(ArticleText);
                SimpleHTMLFormatter format=new SimpleHTMLFormatter("<b><font color='red'>","</font></b>");
                Highlighter light=new Highlighter(format, new QueryScorer(multiQuery));//高亮
                light.setTextFragmenter(new SimpleFragmenter(200));
                if(title!=null)
                {
                TokenStream stream=analyzer.tokenStream(ArticleTitle, new StringReader(title));
                highTitle=light.getBestFragment(stream, title);
                System.out.println(highTitle);
                }
                if(text!=null)
                {
                TokenStream streamText=analyzer.tokenStream(ArticleText, new StringReader(text));
                highText=light.getBestFragment(streamText, text);
                System.out.println(highText);
                }
              //为了在页面好遍历，把它放入集合中
                if(highTitle!=null)
                {
                    list.add("标题中包含关键字："+highTitle+"<br/>");
                }
                if(highText!=null)
                {
                    list.add("内容中包含关键字："+highText+"<br/>");
                }
               
               
            }
            getRequest().setAttribute("list",list);
            /* 关闭 */
            searcher.close();
            return SUCCESS;
        }
        public String goToSearch()
        {
            return SUCCESS;
        }
          
         // 通配符搜索 WildcardQuery    
         // 通配符包括’?’匹配一个任意字符和’*’匹配零个或多个任意字符，例如你搜索’use*’，你可能找到’user’或者’uses’：    
         public static void wildcardSearcher() throws Exception{ 
               index();
                 IndexSearcher searcher = new IndexSearcher(path); 
                  
                 // 与正则一样,*代表0个或多个字母,?代表0个或一个字母 
                 // WildcardQuery与QueryParser不同的是:WildcardQuery的前缀可以为*,而QueryParser不行 
                 Query query = new WildcardQuery(new Term(ArticleText,"te*")); 
                  
                 Hits hits = searcher.search(query); 
                  
                 printResult(hits); 
                  
                 searcher.close(); 
         } 
         public static void printResult(Hits hits) throws IOException{ 
             for(int i = 0; i < hits.length(); i++){ 
                 Document d = hits.doc(i);
                 String title=d.get(ArticleTitle);
                 String text=d.get(ArticleText);
                 String time=d.get(ArticleTime);
                 if(title!=null)
                 {
                     System.out.println(title);
                 }
                 if(text!=null)
                 {
                     System.out.println(text);
                 }
                 if(time!=null)
                 {
                     System.out.println(time);
                 }
              
             } 
         } 
        public static void main(String[] args) throws Exception {
            LuceneTest test=new LuceneTest();
            test.wildcardSearcher();
           LuceneTest .searchIndex();
        }
    }