Detailed description of Lucene core classes

Http://gaowenming.iteye.com/blog/937963

Create an index

To index documents, Lucene provides five basic classes: Document, field, indexwriter, analyzer, and directory. The following describes the usage of these five classes:

Document

Document is used to describe a document. The document here can refer to an HTML page, an email, or a text file. A document object consists of multiple field objects. You can think of a document object as a record in the database, and each Field object is a record field.

Field

The Field object is used to describe a certain attribute of a document. For example, the title and content of an email can be described by two Field objects.

Analyzer

Before a document is indexed, you must first perform word segmentation on the document content, which is done by analyzer. The analyzer class is an abstract class that has multiple implementations. Select the appropriate analyzer for different languages and applications. Analyzer submits the segmented content to indexwriter to create an index.

Indexwriter

Indexwriter is a core class used by Lucene to create indexes. It is used to add document objects to indexes.

Directory

This class represents the storage location of Lucene indexes. This is an abstract class. It currently has two implementations. The first is fsdirectory, which represents the location of an index stored in the file system. The second is ramdirectory, which indicates the location of an index stored in the memory.

After getting familiar with the classes required to create an index, we began to index the text files under a directory, listing 1 shows the source code for indexing text files in a directory.

Instance:

Java code

1. // Ik tokenizer
2. Private analyzer = new ikanalyzer (false );
3. Private document;
4. Private indexwriter writer;
5. Private Static file indexfile = new file ("D: \ Index ");
6. // Word Segmentation
7. Tokenstream = analyzer. reusabletokenstream ("text ",
8. New stringreader ("People's Republic of China "));
9. Termattribute term = (termattribute) tokenstream
10. . Getattribute (termattribute. Class );
11. While (tokenstream. incrementtoken ()){
12. System. Out. println (term. term ());
13. }
14. // Create an index
15. /**
16. *
17. * Fsdirectory. Open (indexfile) the path where the index file is stored by analyzer.
18. * True indicates creation, and false indicates appending indexwriter. maxfieldlength. Limited indicates the maximum value of word segmentation.
19. * For example, new maxfieldlength (2) indicates two words in one minute. Generally
20. * Indexwriter. maxfieldlength. Limited
21. */
22. Writer = new indexwriter (fsdirectory. Open (indexfile), analyzer, false,
23. Indexwriter. maxfieldlength. Limited );
24. Document = new document ();
25. /**
26. * Create a field object and write the name: Field object name (content) in the document)
27. * Value: Field object value (People's Republic of China) store: whether to store index: Word Segmentation Index
28. */
29. Document. Add (new field ("content ",
30. "Hello Beijing ",
31. Field. Store. Yes, field. Index. Analyzed ));
32. Document
33. . Add (new field ("ID", "3", field. Store. Yes, field. Index. Analyzed ));
34. Writer. adddocument (document );
35. Writer. Close ();

Tokenstream is the result of word segmentation. You can obtain the result set of the current word segmentation.

Search documents

Using Lucene for search is just as convenient as creating an index. In the above section, we have created an index for text documents in a directory. Now we need to search for documents containing a keyword or phrase on this index. Lucene provides several basic classes to complete this process. They are indexsearcher, term, query, termquery, and hits. The functions of these classes are described below.

Query

This is an abstract class. It has multiple implementations, such as termquery, booleanquery, and prefixquery. This class aims to encapsulate the query string entered by the user into a query that Lucene can recognize.

Indexsearcher

Indexsearcher is used to search for a created index. It can only open one index in read-only mode, so multiple indexsearcher instances can operate on one index.

Sort

When using sort, the object is instantiated as a parameter and implemented through the search interface of the searcher class. The sorting function supported by sort is based on the fields in the document. This method can be used to sort values of one or more different fields in multiple forms.

Sort by object sort. There are two main modes: one is to use a string to indicate the name of the document domain as the parameter to specify the domain order, and the other is to directly sort the packaging class of the packaging domain of the sorting domain as the parameter.

Topdocs

The search result set that stores the document set of the composite condition.

Highlighter

Highlight of the matching value. When the document matches the keyword, the result is highlighted.

Java code

1. /**
2. * The query object is provided by IK.
3. *
4. */
5. Query query = ikqueryparser. parse ("content", "Beijing ");
6. // Index queryer
7. Indexsearcher searcher = new indexsearcher (fsdirectory. Open (indexfile ));
8. Searcher. setsimilarity (New iksimilarity ());
9. /**
10. * Sort search results field: Field Type type:. sortfield type boolean: false ascending, true: Descending
11. */
12. Sort = new sort ();
13. Sort. setsort (New sortfield ("ID", sortfield. Int, false ));
14. Topdocs docs = searcher. Search (query, null, 10, sort );
15. System. Out. println ("Number of matched objects:" + docs. totalhits );
16. Scoredoc [] S = docs. scoredocs;
17. Highlighter = NULL;
18. Simplehtmlformatter = new simplehtmlformatter (
19. "<B> <font color = 'red'>", "</font> </B> ");
20. Highlighter = new highlighter (simplehtmlformatter, new queryscorer (
21. Query ));
22. // This 100 is the length of the context of the specified keyword string
23. Highlighter. settextfragmenter (New simplefragmenter (100 ));
24. List <message> List = new arraylist <message> ();
25. For (INT I = 0; I <S. length; I ++ ){
26. Document d = searcher.doc(spolici2.16.doc );
27. System. Out. println (D. Get ("ID "));
28. System. Out. println (D. Get ("content "));
29. String content = highlighter. getbestfragment (analyzer, "content", d
30. . Get ("content "));
31. System. Out. println (content );
32. List. Add (New message (D. Get ("ID"), content ));
33. }
34. System. Out. println (list. Size ());
35. Searcher. Close ();
36. }