Lucene01

数据分类

结构化数据和非结构化数据

结构化数据搜索

sql

非结构化数据查询方法

顺序扫描法

全文检索

lucene实现全文检索的流程

创建索引

　　对文档索引的过程，将用户要搜索的文档内容进行索引，索引存在索引库中，

获取原始文档

创建文档对象，文档中包括一个一个的域（Field），域中存储内容，可以将磁盘上的一个文件当成一个document，                     　　　　Document中包括一些Field（file_name文件名称、file_path文件路径、file_size文件大小、file_content文件内容）

　　　　每个Document可以有多个Field，不同的Document可以有不同的Field，同一个Document可以有相同的Field（域名和               域值都相同）

　　　　每个文档都有一个唯一的编号，就是文档id。

分析文档

　　　　将原始内容创建为包含域（Field）的文档（document），需要再对域中的内容进行分析，分析的过程是经过对原始文                 档提取单词、将字母转为小写、去除标点符号、去除停用词等过程生成最终的语汇单元，可以将语汇单元理解为一个                   一个的单词

创建索引

　　　　对所有文档分析得出的语汇单元进行索引，索引的目的是为了搜索，最终要实现只搜索被索引的语汇单元从而找到                      Document（文档）

              创建索引是对语汇单元索引，通过词语找文档，这种索引的结构叫倒排索引结构。

举例：通过关键字搜索文件

jar文件

commons-io-2.6.jar
IK-Analyzer-1.0-SNAPSHOT.jar
lucene-analyzers-common-7.4.0.jar
lucene-core-7.4.0.jar
lucene-queryparser-7.4.0.jar

public class LuenceFirsrt {


    /**
     * 1创建一个Director对象，指定索引库保存的位置
     * 2.基于Director对象创建一个IndexWrite对象
     * 3.读取磁盘上文件，对应每个文件创建一个文档对象
     * 4.向文档对象中添加域
     * 5.向文档对象中写入索引库
     * 6.关闭indexwrite对象
     */
    //创建索引库
    @Test
    public void createIndex() throws Exception{
        Directory directory = FSDirectory.open(new File("D:\lucene\demo\index").toPath());
        
        IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig());
        
        File dir = new File("D:\lucene\demo\searchsource");
        File[] files = dir.listFiles();
        
        for(File f :files) {
            String fileName = f.getName();
            String filePath = f.getPath();
            
            String fileContent = FileUtils.readFileToString(f, "utf-8");
            long fileSize = FileUtils.sizeOf(f);
            
            Field fieldName = new TextField("name",fileName,Field.Store.YES);
            
            Field fieldPath = new TextField("path",filePath,Field.Store.YES);
            
            Field fieldContent = new TextField("content",fileContent,Field.Store.YES);
            
            Field fieldSize = new TextField("size",fileSize+"",Field.Store.YES);
            
            Document document = new Document();
            document.add(fieldName);
            document.add(fieldPath);
            document.add(fieldContent);
            document.add(fieldSize);
            
            
            indexWriter.addDocument(document);
            
                        
        }
        indexWriter.close();
    }
}

查询索引

//查询索引库
    /**
     *         /**
         * 1.创建一个Director对象，指定索引库位置
         * 2.创建一个IndexReader对象
         * 3.创建一个IndexSearch 对象，构造方法中的参数indexReader对象
         * 4.创建一个Query对象，TermQuery
         * 5.执行查询，得到一个TopDocs对象
         * 6.取查询结果的总记录数
         * 7.取文档列表
         * 8.打印文档内容
         * 9.关闭indexReader对象
    */
    @Test
    public void searchIndex() throws Exception{

        
        Directory directory = FSDirectory.open(new File("D:\lucene\demo\index").toPath());
        
        IndexReader indexReader = DirectoryReader.open(directory);
        
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        
        Query query = new TermQuery(new Term("content","spring"));
        
        TopDocs topDocs = indexSearcher.search(query, 10);
        
        System.out.println("查询记录总数为"+ topDocs.totalHits);
        
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        
        for(ScoreDoc doc : scoreDocs) {
            int docId = doc.doc;
            Document document = indexSearcher.doc(docId);
            System.out.println(document.get("name"));
            System.out.println(document.get("path")); 
            System.out.println(document.get("size")); 
            System.out.println(document.get("content")); 
            System.out.println("----------------------");
        }
        
        indexReader.close();
    }
    

查看分词效果

    @Test
    public void testTokenStream() throws Exception {
        /**
         * 1.创建一个Analyzer对象，StandardAnalyzer
         * 2.使用分析器对象的tokenStream方法获得tokenStream对象
         * 3.向TokenStream对象中设置一个引用，相当于数一个指针
         * 4.调用TokenStream对象的rest方法
         * 5.使用while循环遍历ToeknStream对象
         * 6.关闭TokenStream对象
         */
        
        Analyzer analyzer = new StandardAnalyzer();
        TokenStream tokenStream = analyzer.tokenStream("", "The Spring Framework provides a comprehensive programming and configuration model.");
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        tokenStream.reset();
        
        while(tokenStream.incrementToken()) {
            System.out.println(charTermAttribute.toString());
        }
    
        tokenStream.close();
    }
    

查看中文分词器效果

第一步：把jar包添加到工程中

第二步：把配置文件和扩展词典和停用词词典添加到classpath下

注意：hotword.dic和ext_stopword.dic文件的格式为UTF-8

public class Ikanalyzer {
    @Test
    public void testCHTokenStream() throws Exception {
        /**
         * 1.创建一个Analyzer对象，StandardAnalyzer
         * 2.使用分析器对象的tokenStream方法获得tokenStream对象
         * 3.向TokenStream对象中设置一个引用，相当于数一个指针
         * 4.调用TokenStream对象的rest方法
         * 5.使用while循环遍历ToeknStream对象
         * 6.关闭TokenStream对象
         */
        
        Analyzer analyzer = new IKAnalyzer();
        TokenStream tokenStream = analyzer.tokenStream("", "由于日前美方宣称拟对3000亿美元中国输美商品加征10%关税，严重违背中美两国元首大阪会晤共识");
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        tokenStream.reset();
        
        while(tokenStream.incrementToken()) {
            System.out.println(charTermAttribute.toString());
        }
    
        tokenStream.close();
    }

}

索引库的维护

是否分析，是否索引，是否存储

Field类	数据类型	Analyzed 是否分析	Indexed 是否索引	Stored 是否存储	说明
StringField(FieldName, FieldValue,Store.YES))	字符串	N	Y	Y或N	这个Field用来构建一个字符串Field，但是不会进行分析，会将整个串存储在索引中，比如(订单号,姓名等) 是否存储在文档中用Store.YES或Store.NO决定
LongPoint(String name, long... point)	Long型	Y	Y	N	可以使用LongPoint、IntPoint等类型存储数值类型的数据。让数值类型可以进行索引。但是不能存储数据，如果想存储数据还需要使用StoredField。
StoredField(FieldName, FieldValue)	重载方法，支持多种类型	N	N	Y	这个Field用来构建不同类型Field 不分析，不索引，但要Field存储在文档中
TextField(FieldName, FieldValue, Store.NO) 或 TextField(FieldName, reader)	字符串 或 流	Y	Y	Y或N	如果是一个Reader, lucene猜测内容比较多,会采用Unstored的策略.

                                                                                                                                                                                                                                                                                  

添加文档

public class IndexManager {
    

    /**
     * 添加文档
     *创建一个indexWriter对象，需要使用ik作为分词器
     *创建一个Document对象
     *向document对象添加域
     *把文档写入索引库
     *关闭索引库 
     */
    @Test
    public void addDocument() throws Exception{
        IndexWriter indexWriter = 
                new IndexWriter(FSDirectory.open(new File("D:\lucene\demo\index").toPath()), 
                        new IndexWriterConfig(new IKAnalyzer()));
        
        Document document = new Document();
        document.add(new TextField("name","新添加的文件",Field.Store.YES));
        document.add(new TextField("content","新添加的文件内容",Field.Store.NO));
        document.add(new StoredField("path","D:\lucene\demo\path"));
        
        
        indexWriter.addDocument(document);
        indexWriter.close();
    }

删除索引

public class Delete {
    
    private IndexWriter indexWriter;

    @Before
    public void init() throws Exception {
         indexWriter = 
                 new IndexWriter(FSDirectory.open(new File("D:\lucene\demo\index").toPath()), 
                        new IndexWriterConfig(new IKAnalyzer()));
    }
    
    @Test
    public void deleteAllDocument() throws Exception {
        indexWriter.deleteAll();
        indexWriter.close();
        
    }
    
    //根据查询条件删除索引
    @Test
    public void deleteDocumentByQuery() throws Exception {
        indexWriter.deleteDocuments(new Term("name","apache"));
        indexWriter.close();
    }

}

修改索引

先删除后添加

/**
 *1.创建Document对象
 *2.向Document中添加域
 *3.不同的Document中有不同的域，同一个document中有相同的域
 *4.关闭IndexWriter
 */
public class Update {
    
    private IndexWriter indexWriter;

    @Before
    public void init() throws Exception {
         indexWriter = 
                 new IndexWriter(FSDirectory.open(new File("D:\lucene\demo\index").toPath()), 
                        new IndexWriterConfig(new IKAnalyzer()));
    }
    
    @Test
    public  void updateDocument() throws Exception {
        Document document = new Document();
        
        document.add(new TextField("name","更新后的文档",Field.Store.YES));;
        
        indexWriter.updateDocument(new Term("name","spring"),document);
        
        indexWriter.close();
        
        
    }

}

索引库查询

         1）使用Lucene提供Query子类

         2）使用QueryParse解析查询表达式

Query

public class testRangeQuery{
    
    private IndexReader indexReader;
    
    private IndexSearcher indexSearcher;

    @Before
    public void init() throws Exception {
        indexReader = DirectoryReader.open(FSDirectory.open(new File("D:\lucene\demo\index").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
    }

    
    @Test
    public void testRangleQuery() throws Exception {
        
        Query query = LongPoint.newRangeQuery("size", 0l, 10000l);
        TopDocs topDocs = indexSearcher.search(query, 10);
        System.out.println("总记录数："+topDocs.totalHits);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for(ScoreDoc doc:scoreDocs) {
            int docId = doc.doc;
            Document document = indexSearcher.doc(docId);
            System.out.println(document.get("name"));
            System.out.println(document.get("path")); 
            System.out.println(document.get("size")); 
            System.out.println(document.get("content")); 
            System.out.println("----------------------");
            
        }
        indexReader.close();
    }

}

QueryParser提供一个Parse方法，此方法可以直接根据查询语法来查询

/**
 *1.创建QueryParser对象，两个参数
 *            参数一，默认搜索域 。 第二 ，分析器对象
 *2.使用QueryPaser对象创建一个Query对象
 *3.执行查询
 *
 */
public class Paser  {
    
    private IndexReader indexReader;
    
    private IndexSearcher indexSearcher;
    
    @Before
    public void init() throws Exception {
        indexReader = DirectoryReader.open(FSDirectory.open(new File("D:\lucene\demo\index").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
    }
    
    @Test
    public void testQueryParser() throws Exception {

        //创建queryparser对象
        //第一个参数默认搜索的域
        //第二个参数就是分析器对象
        QueryParser queryParser = new QueryParser("content", new IKAnalyzer());
        Query query = queryParser.parse("Lucene是java开发的");
        //执行查询
        printResult(query, indexSearcher);
    }

    private void printResult(Query query, IndexSearcher indexSearcher) throws Exception {
        //执行查询
        TopDocs topDocs = indexSearcher.search(query, 10);
        //共查询到的document个数
        System.out.println("查询结果总数量：" + topDocs.totalHits);
        //遍历查询结果
        for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
            Document document = indexSearcher.doc(scoreDoc.doc);
            System.out.println(document.get("filename"));
            System.out.println(document.get("content"));
            System.out.println(document.get("path"));
            System.out.println(document.get("size"));
        }
        //关闭indexreader
        indexSearcher.getIndexReader().close();
    }
}

完