国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

  //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;
                        }
                        }