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

 1 public class LuenceFirsrt {
 2 
 3 
 4     /**
 5      * 1创建一个Director对象，指定索引库保存的位置
 6      * 2.基于Director对象创建一个IndexWrite对象
 7      * 3.读取磁盘上文件，对应每个文件创建一个文档对象
 8      * 4.向文档对象中添加域
 9      * 5.向文档对象中写入索引库
10      * 6.关闭indexwrite对象
11      */
12     //创建索引库
13     @Test
14     public void createIndex() throws Exception{
15         Directory directory = FSDirectory.open(new File("D:\\lucene\\demo\\index").toPath());
16         
17         IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig());
18         
19         File dir = new File("D:\\lucene\\demo\\searchsource");
20         File[] files = dir.listFiles();
21         
22         for(File f :files) {
23             String fileName = f.getName();
24             String filePath = f.getPath();
25             
26             String fileContent = FileUtils.readFileToString(f, "utf-8");
27             long fileSize = FileUtils.sizeOf(f);
28             
29             Field fieldName = new TextField("name",fileName,Field.Store.YES);
30             
31             Field fieldPath = new TextField("path",filePath,Field.Store.YES);
32             
33             Field fieldContent = new TextField("content",fileContent,Field.Store.YES);
34             
35             Field fieldSize = new TextField("size",fileSize+"",Field.Store.YES);
36             
37             Document document = new Document();
38             document.add(fieldName);
39             document.add(fieldPath);
40             document.add(fieldContent);
41             document.add(fieldSize);
42             
43             
44             indexWriter.addDocument(document);
45             
46                         
47         }
48         indexWriter.close();
49     }
50 }

查询索引

 1 //查询索引库
 2     /**
 3      *         /**
 4          * 1.创建一个Director对象，指定索引库位置
 5          * 2.创建一个IndexReader对象
 6          * 3.创建一个IndexSearch 对象，构造方法中的参数indexReader对象
 7          * 4.创建一个Query对象，TermQuery
 8          * 5.执行查询，得到一个TopDocs对象
 9          * 6.取查询结果的总记录数
10          * 7.取文档列表
11          * 8.打印文档内容
12          * 9.关闭indexReader对象
13     */
14     @Test
15     public void searchIndex() throws Exception{
16 
17         
18         Directory directory = FSDirectory.open(new File("D:\\lucene\\demo\\index").toPath());
19         
20         IndexReader indexReader = DirectoryReader.open(directory);
21         
22         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
23         
24         Query query = new TermQuery(new Term("content","spring"));
25         
26         TopDocs topDocs = indexSearcher.search(query, 10);
27         
28         System.out.println("查询记录总数为"+ topDocs.totalHits);
29         
30         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
31         
32         for(ScoreDoc doc : scoreDocs) {
33             int docId = doc.doc;
34             Document document = indexSearcher.doc(docId);
35             System.out.println(document.get("name"));
36             System.out.println(document.get("path")); 
37             System.out.println(document.get("size")); 
38             System.out.println(document.get("content")); 
39             System.out.println("----------------------");
40         }
41         
42         indexReader.close();
43     }
44

查看分词效果

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

查看中文分词器效果

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

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

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

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

索引库的维护

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

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的策略.

添加文档

 1 public class IndexManager {
 2     
 3 
 4     /**
 5      * 添加文档
 6      *创建一个indexWriter对象，需要使用ik作为分词器
 7      *创建一个Document对象
 8      *向document对象添加域
 9      *把文档写入索引库
10      *关闭索引库 
11      */
12     @Test
13     public void addDocument() throws Exception{
14         IndexWriter indexWriter = 
15                 new IndexWriter(FSDirectory.open(new File("D:\\lucene\\demo\\index").toPath()), 
16                         new IndexWriterConfig(new IKAnalyzer()));
17         
18         Document document = new Document();
19         document.add(new TextField("name","新添加的文件",Field.Store.YES));
20         document.add(new TextField("content","新添加的文件内容",Field.Store.NO));
21         document.add(new StoredField("path","D:\\lucene\\demo\\path"));
22         
23         
24         indexWriter.addDocument(document);
25         indexWriter.close();
26     }

删除索引

 1 public class Delete {
 2     
 3     private IndexWriter indexWriter;
 4 
 5     @Before
 6     public void init() throws Exception {
 7          indexWriter = 
 8                  new IndexWriter(FSDirectory.open(new File("D:\\lucene\\demo\\index").toPath()), 
 9                         new IndexWriterConfig(new IKAnalyzer()));
10     }
11     
12     @Test
13     public void deleteAllDocument() throws Exception {
14         indexWriter.deleteAll();
15         indexWriter.close();
16         
17     }
18     
19     //根据查询条件删除索引
20     @Test
21     public void deleteDocumentByQuery() throws Exception {
22         indexWriter.deleteDocuments(new Term("name","apache"));
23         indexWriter.close();
24     }
25 
26 }

修改索引

先删除后添加

 1 /**
 2  *1.创建Document对象
 3  *2.向Document中添加域
 4  *3.不同的Document中有不同的域，同一个document中有相同的域
 5  *4.关闭IndexWriter
 6  */
 7 public class Update {
 8     
 9     private IndexWriter indexWriter;
10 
11     @Before
12     public void init() throws Exception {
13          indexWriter = 
14                  new IndexWriter(FSDirectory.open(new File("D:\\lucene\\demo\\index").toPath()), 
15                         new IndexWriterConfig(new IKAnalyzer()));
16     }
17     
18     @Test
19     public  void updateDocument() throws Exception {
20         Document document = new Document();
21         
22         document.add(new TextField("name","更新后的文档",Field.Store.YES));;
23         
24         indexWriter.updateDocument(new Term("name","spring"),document);
25         
26         indexWriter.close();
27         
28         
29     }
30 
31 }

索引库查询

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 /**
 2  *1.创建QueryParser对象，两个参数
 3  *            参数一，默认搜索域 。 第二 ，分析器对象
 4  *2.使用QueryPaser对象创建一个Query对象
 5  *3.执行查询
 6  *
 7  */
 8 public class Paser  {
 9     
10     private IndexReader indexReader;
11     
12     private IndexSearcher indexSearcher;
13     
14     @Before
15     public void init() throws Exception {
16         indexReader = DirectoryReader.open(FSDirectory.open(new File("D:\\lucene\\demo\\index").toPath()));
17         indexSearcher = new IndexSearcher(indexReader);
18     }
19     
20     @Test
21     public void testQueryParser() throws Exception {
22 
23         //创建queryparser对象
24         //第一个参数默认搜索的域
25         //第二个参数就是分析器对象
26         QueryParser queryParser = new QueryParser("content", new IKAnalyzer());
27         Query query = queryParser.parse("Lucene是java开发的");
28         //执行查询
29         printResult(query, indexSearcher);
30     }
31 
32     private void printResult(Query query, IndexSearcher indexSearcher) throws Exception {
33         //执行查询
34         TopDocs topDocs = indexSearcher.search(query, 10);
35         //共查询到的document个数
36         System.out.println("查询结果总数量：" + topDocs.totalHits);
37         //遍历查询结果
38         for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
39             Document document = indexSearcher.doc(scoreDoc.doc);
40             System.out.println(document.get("filename"));
41             System.out.println(document.get("content"));
42             System.out.println(document.get("path"));
43             System.out.println(document.get("size"));
44         }
45         //关闭indexreader
46         indexSearcher.getIndexReader().close();
47     }
48 }

完

posted @ 2019-08-07 12:54 曲阳阳阅读(145) 评论(0) 编辑收藏举报

刷新页面返回顶部

曲阳阳

Lucene01

公告