一个自己用lucene写的敏感词查询

lucenepackage ddd.cms.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.nio.charset.StandardCharsets;

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.LongField;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

/**
 * 敏感词管理，查询所有的敏感词，查看是否存在
 * @author Administrator
 *
 */
public class SensitiveWordUtil {
    private static String docsPath = "D:\\CMSDocs";
    private static String fileName = "analysis.txt";
    private static String indexPath = "D:\\CMSIndex";
    private static double baseScore = 0.02;
    
    public static void main(String[] args) throws Exception {

        /*String docsPath = "D:\\CMSDocs";
        String fileName = "analysis.txt";
        String indexPath = "D:\\CMSIndex";*/
        
        //startWork( indexPath,docsPath,fileName, content);
        String [] allSensitiveWord = {"使命","持续创新","没出事","十二号","辈数儿","否存在"};
        /*String sensitiveWord =  null;
        for (int i = 0; i < allSensitiveWord.length; i++) {
            sensitiveWord = allSensitiveWord[i];
            judeIsExsist(sensitiveWord,indexPath);
        }*/
        //judeIsExsist(sensitiveWord,indexPath);
        String content = "bseurhg87e略后来持续改了良好社会了十二和谁零售额好了粉色，哦然否存在后首尔玫我们的使命：让IT更简单 数据是未来商业的核心，IT是企业数据存储和分析的基础，SMARTX让IT更简单，帮助企业挖掘数据价值，让商业更有效率。 我们相信： 1. 持续创新 SMARTX由热爱挑战的团队组建，永远解决用户最痛、最难的问题，不断创新为用户创造价值。 2. 简胜于繁 不论是产品的设计实现，还是用户体验，我们把简单原则贯彻如一。让企业用更直觉、更简单的红色还是摩尔佛爱问还是没饿坏了分数而肥瘦儿";
        
        Map<String,Boolean> resMap = getSearchResult(allSensitiveWord,content);
        System.out.println(resMap);
        
    }
    /**
     * 将所有的敏感词纳入文件中查询，返回所有的敏感词的存在情况
     * @param allSensitiveWord
     * @param content
     * @return
     * @throws IOException
     * @throws ParseException
     */
    
    public static  Map<String,Boolean> getSearchResult(String []allSensitiveWord,String content) throws IOException, ParseException{
        Map<String,Boolean> resultMap = new HashMap<String,Boolean>();
        if (content == null) {
            return null;
        }
        else{
            startWork( indexPath,docsPath,fileName, content);   //先做准备工作
            String sensitiveWord =  null;
            for (int i = 0; i < allSensitiveWord.length; i++) {
                boolean isFind = false;
                sensitiveWord = allSensitiveWord[i];
                Map<String, Object> resMap= judeIsExsist(sensitiveWord,indexPath);
                ScoreDoc scoreDoc = (ScoreDoc) resMap.get("scoreDoc");
                int totalHits = (int) resMap.get("totalHits");
                if (totalHits >= 1 && scoreDoc.score >= baseScore) {
                    isFind = true;
                }
                else{
                    isFind = false;
                }
                resultMap.put(sensitiveWord, isFind);
            }
        }
        return resultMap;
    }
    
    /**
     * 做一些准备工作，将内容写入txt文件，并建立索引
     * @param indexPath
     * @param docsPath
     * @param fileName
     * @param content
     * @return
     */
    private static boolean startWork(String indexPath, String docsPath,String fileName,String content) {
        boolean create = true;
        String getContent = writeContentTotxt(docsPath, fileName, content);
        if(getContent != null){
            createIndex(indexPath,docsPath,create);
            return true;
        }
        else{
            System.out.println("写入文件失败！");
        }
        return false;
    }
    
    /**
     * 将文章写入txt文件的方法
     * @param filePath
     * @param fileName
     * @param content
     * @return
     */
    
    private static String writeContentTotxt(String filePath, String fileName,String content) {
        File fileFolder = new File(filePath);
        if (!fileFolder.exists() || !fileFolder.isDirectory()) {
            createFolder(filePath);
        }
        File contentFile = new File(filePath + "\\" + fileName);
        if (!contentFile.exists() || contentFile.isDirectory()) {
            try {
                createFile(filePath, fileName);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        else{
            //如果没有该文件就要先创建该文件，如果有了就直接进行交给下一步
        }
        try {
            boolean isSuccess = printStream(filePath + "\\" + fileName, content, false);  //将要搜索的文章先写入到txt临时文件中
            if (isSuccess) {
                return content;
            }
            else{
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 用字符流写入的具体实现
     * @param filePath
     * @param content
     * @param isTrue
     * @return
     * @throws IOException
     */
    private static boolean printStream(String filePath, String content,boolean isTrue) throws IOException {
        boolean isSuccess = false;
        FileOutputStream out = new FileOutputStream(filePath, isTrue); // true意为是在其后追加，false会将原有的内容覆盖
        PrintStream p = new PrintStream(out, true);
        if (content != null) {
            p.println(content);
            isSuccess = true;
        } else {
            System.out.println("对不起你的要写入的内容为空");
        }
        out.close();
        p.close();
        return isSuccess;
    }
    /**
     * 建立索引的具体实现
     * @param indexPath
     * @param docsPath
     * @param create
     */
    private static void createIndex(String indexPath,String docsPath,boolean create){
        final File docDir = new File(docsPath);
        if (!docDir.exists() || !docDir.canRead()) {
            System.out.println("资源文件目录 '" + docDir.getAbsolutePath() + "' 不存在或不可读，请检查！");
            System.exit(1);
        }else{
            Date start = new Date();
            try {
                System.out.println("建立索引文件到该目录 '" + indexPath + "'...");
     
                Directory dir = FSDirectory.open(new File(indexPath));
                Analyzer analyzer = new StandardAnalyzer();
                IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_4_10_2, analyzer);
                if (create) {
                    // 创建新的索引文件，删除所有其他的索引文件
                    //（指的是该资源文件目录下的旧的索引文件，其他资源的索引文件不影响）
                    iwc.setOpenMode(OpenMode.CREATE);
                } else {
                    // 如果有旧的索引文件，则更新索引文件
                    iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
                }
                IndexWriter writer = new IndexWriter(dir, iwc);
                indexDocs(writer, docDir);
                writer.close();
                Date end = new Date();
                System.out.println(end.getTime() - start.getTime() + " total milliseconds");
            } catch (IOException e) {
                System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());
            }
        }
    }
    
    /**
     * 索引文件的义务处理
     * @param writer
     * @param file
     * @throws IOException
     */
    private static void indexDocs(IndexWriter writer, File file) throws IOException {
        if (!file.canRead()) {
            return;
        }
        else if (file.isDirectory()) {
            String[] files = file.list();
            if (files != null) {
                for (int i = 0; i < files.length; i++) {
                    indexDocs(writer, new File(file, files[i]));
                }
            }
        } else {
            FileInputStream fis;
            try {
                fis = new FileInputStream(file);
            } catch (FileNotFoundException fnfe) {
                return;
            }
            try {
 
                // 每一个文档最终被封装成了一个 Document 对象
                // Document 是用来描述文档的，这里的文档可以指一个 HTML 页面，一封电子邮件，或者是一个文本文件。
                // 一个 Document 对象由多个 Field 对象组成的。
                // 可以把一个 Document 对象想象成数据库中的一个记录，而每个 Field 对象就是记录的一个字段。
                Document doc = new Document();
                // Field 对象是用来描述一个文档的某个属性的，比如一封电子邮件的标题和内容可以用两个 Field 对象分别描述。
                Field pathField = new StringField("path", file.getPath(),Field.Store.YES);
                // pathField指的是资源文件的路径的field
                doc.add(pathField);
                // 这个field指的是最后的修改时间
                doc.add(new LongField("modified", file.lastModified(),Field.Store.NO));
 
                // 把资源文件中的内容分词后，索引到索引文件中，指定为UTF-8编码
                doc.add(new TextField("contents", new BufferedReader(new InputStreamReader(fis, StandardCharsets.UTF_8))));
 
                if (writer.getConfig().getOpenMode() == OpenMode.CREATE) {
                    System.out.println("adding " + file);
                    writer.addDocument(doc);
                } else {
                    System.out.println("updating " + file);
                    writer.updateDocument(new Term("path", file.getPath()), doc);
                }
            } finally {
                fis.close();
            }
            }
        }
    /**
     * 创建文件
     * @param filePath
     * @param fileName
     * @throws IOException
     */
    private static void createFile(String filePath, String fileName) throws IOException {
        File file = new File(filePath+"\\"+fileName);
        if (!file.exists())
            file.createNewFile();
        else{
            return;
        }
    }

    /**
     * 创建文件夹
     * @param filePath
     * @return
     */
    private static String createFolder(String filePath) {
        File indexFile = new File(filePath);
        if (!indexFile.exists() || !indexFile.isDirectory()) {
            indexFile.mkdir();
        }
        else{
            //文件夹已经存在，直接返回
        }
        return filePath;
    }
    
    /**
     * lucene的具体查询方法
     * @param in
     * @param searcher
     * @param query
     * @param hitsPerPage
     * @param raw
     * @param interactive
     * @return
     * @throws IOException
     */
    public static Map<String, Object> doPagingSearch(BufferedReader in,IndexSearcher searcher, Query query, int hitsPerPage, boolean raw,boolean interactive) throws IOException {
        Map<String,Object> resMap = new HashMap<String,Object>();
        TopDocs results = searcher.search(query, 5 * hitsPerPage); // 对应的每一页
        ScoreDoc[] hitDocs = results.scoreDocs;

        int numTotalHits = results.totalHits;
        resMap.put("totalHits", numTotalHits);
        if (hitDocs.length!=0 && numTotalHits > 0 && hitDocs[0]!=null) {
            resMap.put("scoreDoc", hitDocs[0]);
            System.out.println(hitDocs[0].toString());
            System.out.println(numTotalHits + " total matching documents");
        }else{
            resMap.put("scoreDoc", null);
        }
        return resMap;
    }

    /**
     * 根据索引与关键字来查询是否存在
     * @param sensitiveWord
     * @param indexPath
     * @return
     * @throws IOException
     * @throws ParseException
     */
    private static Map<String,Object> judeIsExsist(String sensitiveWord, String indexPath)throws IOException, ParseException {
        String field = "contents";
        String queries = null;
        int repeat = 0;
        boolean raw = false;
        String queryString = null;
        int hitsPerPage = 10;
        
        IndexReader reader = DirectoryReader.open(FSDirectory.open(new File(indexPath)));
        IndexSearcher searcher = new IndexSearcher(reader);
        Analyzer analyzer = new StandardAnalyzer();

        BufferedReader in = null;
        in = new BufferedReader(new InputStreamReader(System.in,StandardCharsets.UTF_8));
        QueryParser parser = new QueryParser(field, analyzer);
        sensitiveWord = sensitiveWord.trim(); // 去除两边的看的空格
        Query query = parser.parse(sensitiveWord); // 创建查询器
        System.out.println("Searching for: " + query.toString(field));
        if (repeat > 0) { // repeat & time as benchmark
            Date start = new Date();
            for (int j = 0; j < repeat; j++) {    
                searcher.search(query, null, 100);
            }
            Date end = new Date();
            System.out.println("Time: " + (end.getTime() - start.getTime()) + "ms");
        }
        Map<String, Object> resMap = doPagingSearch(in, searcher, query, hitsPerPage, raw, queries == null && queryString == null);
        reader.close();
        return resMap;
    }
}