//Test boolean operator
            public void testOperator(String indexDirectory) throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String[] searchWords = {"Java AND Lucene", "Java NOT Lucene", "Java OR Lucene",
            "+Java +Lucene", "+Java -Lucene"};
            Analyzer language = new StandardAnalyzer();
            Query query;
            for(int i = 0; i < searchWords.length; i++){
            query = QueryParser.parse(searchWords[i], "title", language);
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords[i]);
            }
            }
            

//Test field search
            public void testFieldSearch(String indexDirectory) throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String searchWords = "title:Lucene AND content:Java";
            Analyzer language = new StandardAnalyzer();
            Query query = QueryParser.parse(searchWords, "title", language);
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords);
            }
            

//Test wildcard search
            public void testWildcardSearch(String indexDirectory)throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String[] searchWords = {"tex*", "tex?", "?ex*"};
            Query query;
            for(int i = 0; i < searchWords.length; i++){
            query = new WildcardQuery(new Term("title",searchWords[i]));
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords[i]);
            }
            }
            

//Test fuzzy search
            public void testFuzzySearch(String indexDirectory)throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String[] searchWords = {"text", "funny"};
            Query query;
            for(int i = 0; i < searchWords.length; i++){
            query = new FuzzyQuery(new Term("title",searchWords[i]));
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords[i]);
            }
            }
            

//Test range search
            public void testRangeSearch(String indexDirectory)throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            Term begin = new Term("birthDay","20000101");
            Term end   = new Term("birthDay","20060606");
            Query query = new RangeQuery(begin,end,true);
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results is returned");
            }
            

package sample.dw.paper.lucene.servlet;
            import java.io.IOException;
            import java.util.List;
            import javax.servlet.RequestDispatcher;
            import javax.servlet.ServletException;
            import javax.servlet.http.HttpServlet;
            import javax.servlet.http.HttpServletRequest;
            import javax.servlet.http.HttpServletResponse;
            import sample.dw.paper.lucene.search.SearchManager;
            /**
            * This servlet is used to deal with the search request
            * and return the search results to the client
            */
            public class SearchController extends HttpServlet{
            private static final long serialVersionUID = 1L;
            public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException{
            String searchWord = request.getParameter("searchWord");
            SearchManager searchManager = new SearchManager(searchWord);
            List searchResult = null;
            searchResult = searchManager.search();
            RequestDispatcher dispatcher = request.getRequestDispatcher("search.jsp");
            request.setAttribute("searchResult",searchResult);
            dispatcher.forward(request, response);
            }
            public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException{
            doPost(request, response);
            }
            }
            

package sample.dw.paper.lucene.search;
            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.queryParser.ParseException;
            import org.apache.lucene.queryParser.QueryParser;
            import org.apache.lucene.search.Hits;
            import org.apache.lucene.search.IndexSearcher;
            import org.apache.lucene.search.Query;
            import sample.dw.paper.lucene.index.IndexManager;
            /**
            * This class is used to search the
            * Lucene index and return search results
            */
            public class SearchManager {
            private String searchWord;
            private IndexManager indexManager;
            private Analyzer analyzer;
            public SearchManager(String searchWord){
            this.searchWord   =  searchWord;
            this.indexManager =  new IndexManager();
            this.analyzer     =  new StandardAnalyzer();
            }
            /**
            * do search
            */
            public List search(){
            List searchResult = new ArrayList();
            if(false == indexManager.ifIndexExist()){
            try {
            if(false == indexManager.createIndex()){
            return searchResult;
            }
            } catch (IOException e) {
            e.printStackTrace();
            return searchResult;
            }
            }
            IndexSearcher indexSearcher = null;
            try{
            indexSearcher = new IndexSearcher(indexManager.getIndexDir());
            }catch(IOException ioe){
            ioe.printStackTrace();
            }
            QueryParser queryParser = new QueryParser("content",analyzer);
            Query query = null;
            try {
            query = queryParser.parse(searchWord);
            } catch (ParseException e) {
            e.printStackTrace();
            }
            if(null != query >> null != indexSearcher){
            try {
            Hits hits = indexSearcher.search(query);
            for(int i = 0; i < hits.length(); i ++){
            SearchResultBean resultBean = new SearchResultBean();
            resultBean.setHtmlPath(hits.doc(i).get("path"));
            resultBean.setHtmlTitle(hits.doc(i).get("title"));
            searchResult.add(resultBean);
            }
            } catch (IOException e) {
            e.printStackTrace();
            }
            }
            return searchResult;
            }
            }
            

package sample.dw.paper.lucene.index;
            import java.io.File;
            import java.io.IOException;
            import java.io.Reader;
            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.index.IndexWriter;
            import org.apache.lucene.store.Directory;
            import org.apache.lucene.store.FSDirectory;
            import sample.dw.paper.lucene.util.HTMLDocParser;
            /**
            * This class is used to create an index for HTML files
            *
            */
            public class IndexManager {
            //the directory that stores HTML files
            private final String dataDir  = "c:\\dataDir";
            //the directory that is used to store a Lucene index
            private final String indexDir = "c:\\indexDir";
            /**
            * create index
            */
            public boolean createIndex() throws IOException{
            if(true == ifIndexExist()){
            return true;
            }
            File dir = new File(dataDir);
            if(!dir.exists()){
            return false;
            }
            File[] htmls = dir.listFiles();
            Directory fsDirectory = FSDirectory.getDirectory(indexDir, true);
            Analyzer  analyzer    = new StandardAnalyzer();
            IndexWriter indexWriter = new IndexWriter(fsDirectory, analyzer, true);
            for(int i = 0; i < htmls.length; i++){
            String htmlPath = htmls[i].getAbsolutePath();
            if(htmlPath.endsWith(".html") || htmlPath.endsWith(".htm")){
            addDocument(htmlPath, indexWriter);
            }
            }
            indexWriter.optimize();
            indexWriter.close();
            return true;
            }
            /**
            * Add one document to the Lucene index
            */
            public void addDocument(String htmlPath, IndexWriter indexWriter){
            HTMLDocParser htmlParser = new HTMLDocParser(htmlPath);
            String path    = htmlParser.getPath();
            String title   = htmlParser.getTitle();
            Reader content = htmlParser.getContent();
            Document document = new Document();
            document.add(new Field("path",path,Field.Store.YES,Field.Index.NO));
            document.add(new Field("title",title,Field.Store.YES,Field.Index.TOKENIZED));
            document.add(new Field("content",content));
            try {
            indexWriter.addDocument(document);
            } catch (IOException e) {
            e.printStackTrace();
            }
            }
            /**
            * judge if the index exists already
            */
            public boolean ifIndexExist(){
            File directory = new File(indexDir);
            if(0 < directory.listFiles().length){
            return true;
            }else{
            return false;
            }
            }
            public String getDataDir(){
            return this.dataDir;
            }
            public String getIndexDir(){
            return this.indexDir;
            }
            }
            

package sample.dw.paper.lucene.util;
            import java.io.FileInputStream;
            import java.io.FileNotFoundException;
            import java.io.IOException;
            import java.io.InputStream;
            import java.io.InputStreamReader;
            import java.io.Reader;
            import java.io.UnsupportedEncodingException;
            import org.apache.lucene.demo.html.HTMLParser;
            public class HTMLDocParser {
            private String htmlPath;
            private HTMLParser htmlParser;
            public HTMLDocParser(String htmlPath){
            this.htmlPath = htmlPath;
            initHtmlParser();
            }
            private void initHtmlParser(){
            InputStream inputStream = null;
            try {
            inputStream = new FileInputStream(htmlPath);
            } catch (FileNotFoundException e) {
            e.printStackTrace();
            }
            if(null != inputStream){
            try {
            htmlParser = new HTMLParser(new InputStreamReader(inputStream, "utf-8"));
            } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            }
            }
            }
            public String getTitle(){
            if(null != htmlParser){
            try {
            return htmlParser.getTitle();
            } catch (IOException e) {
            e.printStackTrace();
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
            }
            return "";
            }
            public Reader getContent(){
            if(null != htmlParser){
            try {
            return htmlParser.getReader();
            } catch (IOException e) {
            e.printStackTrace();
            }
            }
            return null;
            }
            public String getPath(){
            return this.htmlPath;
            }
            }
            

package TestLucene;
            import java.io.File;
            import java.io.FileReader;
            import java.io.Reader;
            import java.util.Date;
            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.index.IndexWriter;
            /**
            * This class demonstrate the process of creating index with Lucene
            * for text files
            */
            public class TxtFileIndexer {
            public static void main(String[] args) throws Exception{
            //indexDir is the directory that hosts Lucene's index files
            File   indexDir = new File("D:\\luceneIndex");
            //dataDir is the directory that hosts the text files that to be indexed
            File   dataDir  = new File("D:\\luceneData");
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            File[] dataFiles  = dataDir.listFiles();
            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
            long startTime = new Date().getTime();
            for(int i = 0; i < dataFiles.length; i++){
            if(dataFiles[i].isFile() && dataFiles[i].getName().endsWith(".txt")){
            System.out.println("Indexing file " + dataFiles[i].getCanonicalPath());
                    		Document document = new Document();
            Reader txtReader = new FileReader(dataFiles[i]);
            document.add(Field.Text("path",dataFiles[i].getCanonicalPath()));
            document.add(Field.Text("contents",txtReader));
            indexWriter.addDocument(document);
            }
            }
            indexWriter.optimize();
            indexWriter.close();
            long endTime = new Date().getTime();
            System.out.println("It takes " + (endTime - startTime)
            + " milliseconds to create index for the files in directory "
            + dataDir.getPath());
            }
            }
            

package TestLucene;
            import java.io.File;
            import org.apache.lucene.document.Document;
            import org.apache.lucene.index.Term;
            import org.apache.lucene.search.Hits;
            import org.apache.lucene.search.IndexSearcher;
            import org.apache.lucene.search.TermQuery;
            import org.apache.lucene.store.FSDirectory;
            /**
            * This class is used to demonstrate the
            * process of searching on an existing
            * Lucene index
            *
            */
            public class TxtFileSearcher {
            public static void main(String[] args) throws Exception{
            String queryStr = "lucene";
            //This is the directory that hosts the Lucene index
            File indexDir = new File("D:\\luceneIndex");
            FSDirectory directory = FSDirectory.getDirectory(indexDir,false);
            IndexSearcher searcher = new IndexSearcher(directory);
            if(!indexDir.exists()){
            System.out.println("The Lucene index is not exist");
            return;
            }
            Term term = new Term("contents",queryStr.toLowerCase());
            TermQuery luceneQuery = new TermQuery(term);
            Hits hits = searcher.search(luceneQuery);
            for(int i = 0; i < hits.length(); i++){
            Document document = hits.doc(i);
            System.out.println("File: " + document.get("path"));
            }
            }
            }