发表于 | 分类于 ，

假设有一批文档，文档格式有 DOC、DOCX、PPT、PPTX、TXT、PDF

要实现类似于百度文库的文件检索系统。

需求如下：

  1. 能够对文件名进行检索；
  2. 能够对文件内容进行检索；
  3. 能够下载检索到的文件；
  4. 能够实现关键字的高亮；

发表于 | 分类于 ，

2.7.1、问题提出

2.7.2、需求分析

2.7.3、编程实现

-———————————————-

2.7.1、问题提出

统计 一篇新闻文档，统计出现频率最高的哪些词语

2.7.2、需求分析

文本关键词提取算法、开源工具很多

本文：《从Lucene索引中 提取 词项频率Top N》

词条化：从文本中 去除 标点、停用词等；

索引过程的本质：词条化 生成 倒排索引的过程；

代码思路：IndexReader的getTermVector获取文档的某一个字段 Terms，从 terms 中获取 tf（term frequency），拿到词项的 tf 以后，放到map中 降序排序，取出 Top-N.

2.7.3、编程实现

网上找到新闻稿《李开复：无人驾驶进入黄金时代 AI有巨大投资机会》，放在 testfile/news.txt 文件中。

对 testfile/news.txt 生成索引：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package com.learn.lucene.chapter2.highfrequency;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.FieldType;
import org.apache.lucene.index.IndexOptions;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.*;
import java.nio.file.Paths;

/**
 * 2.7.1、问题提出
 * 统计 一篇新闻文档，统计出现频率最高的哪些词语
 * 2.7.2、需求分析
 * 文本关键词提取算法、开源工具很多
 * 本文：《从Lucene索引中 提取 词项频率Top N》
 * 词条化：从文本中 去除 标点、停用词等；
 * 索引过程的本质：词条化 生成 倒排索引的过程；
 * 代码思路：IndexReader的getTermVector获取文档的某一个字段 Terms，从 terms 中获取 tf（term frequency），拿到词项的 tf 以后，放到map中 降序排序，取出 Top-N.
 * 2.7.3、编程实现
 * 网上找到新闻稿《李开复：无人驾驶进入黄金时代 AI有巨大投资机会》，放在 testfile/news.txt 文件中。
 *
 * 索引文档
 */
public class IndexDocs {

	public static void main(String[] args) throws IOException {
		File newfile = new File("testfile/news.txt");
		String text1 = textToString(newfile);
		Analyzer smcAnalyzer = new IKAnalyzer8x(true);
		IndexWriterConfig indexWriterConfig = new IndexWriterConfig(smcAnalyzer);
		indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
		// 索引的存储路径
		Directory directory = FSDirectory.open(Paths.get("indexdir"));
		// 索引的增删改由 IndexWriter 创建
		IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);
		// 新建 FieldType，用于指定字段索引时的信息
		FieldType type = new FieldType();
		type.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
		type.setStored(true);  // 原始字符串全部被保存在索引中
		type.setStoreTermVectors(true);  // 存储词项 量
		type.setTokenized(true);  // 词条化
		Document doc1 = new Document();
		Field field1 = new Field("content", text1, type);
		doc1.add(field1);
		indexWriter.addDocument(doc1);
		indexWriter.close();
		directory.close();

	}

	public static String textToString(File file) {
		StringBuilder result = new StringBuilder();
		try {
			// 构造一个 BufferedReader 类来读取文件
			BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
			String str = null;
			// 使用 readline 方法，一次读一行
			while (null != (str = bufferedReader.readLine())) {
				result.append(System.lineSeparator() + str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result.toString();
	}

}

运行。

提取高频词：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package com.learn.lucene.chapter2.highfrequency;

import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Terms;
import org.apache.lucene.index.TermsEnum;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.BytesRef;

import java.io.IOException;
import java.nio.file.Paths;
import java.util.*;

/**
 * 提取高频词
 */
public class GetTopTerms {
	public static void main(String[] args) throws IOException {
		Directory directory = FSDirectory.open(Paths.get("indexdir"));
		IndexReader reader = DirectoryReader.open(directory);
		// 因为之索引了一个文档，所以DocID为0
		// 通过 getTermVector 获取 content 字段的词项
		Terms terms = reader.getTermVector(0, "content");
		// 遍历词项
		TermsEnum termsEnum = terms.iterator();
		Map<String, Integer> map = new HashMap<String, Integer>();
		BytesRef thisTerm;
		while (null != (thisTerm = termsEnum.next())) {
			String termText = thisTerm.utf8ToString();  // 词项
			// 通过 totalTermFreq() 方法获取词项频率
			map.put(termText, (int) termsEnum.totalTermFreq());
		}
		// 按 value 排序
		List<Map.Entry<String, Integer>> sortedMap = new ArrayList<>(map.entrySet());
		Collections.sort(sortedMap, new Comparator<Map.Entry<String, Integer>>() {
			@Override
			public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
				return (o2.getValue() - o1.getValue());
			}
		});

		getTopN(sortedMap, 10);
	}

	public static void getTopN(List<Map.Entry<String, Integer>> sortedMap, int N) {
		for (int i = 0; i < N; i++) {
			System.out.println(sortedMap.get(i).getKey() + ":" + sortedMap.get(i).getValue());
		}
	}
}

发表于 | 分类于 ，

找到需要高亮的片段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package com.learn.lucene.chapter2.hignlight;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
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.search.highlight.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 找到需要高亮的片段
 */
public class HighlighterTest {
   public static void main(String[] args) throws IOException, ParseException, InvalidTokenOffsetsException {
      String field = "title";
      Path indexPath = Paths.get("indexdir");
      Directory directory = FSDirectory.open(indexPath);
      IndexReader reader = DirectoryReader.open(directory);
      IndexSearcher searcher = new IndexSearcher(reader);
      Analyzer analyzer = new IKAnalyzer8x();
      QueryParser parser = new QueryParser(field, analyzer);
      Query query = parser.parse("北大");
      System.out.println("Query: " + query);
      QueryScorer scorer = new QueryScorer(query, field);
      SimpleHTMLFormatter htmlFormatter = new SimpleHTMLFormatter("<span style=\"color:red;\">", "</span>");
      Highlighter highlighter = new Highlighter(htmlFormatter, scorer);
      // 高亮分词器
      TopDocs topDocs = searcher.search(query, 10);
      for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
         Document doc = searcher.doc(scoreDoc.doc);
         System.out.println("DocID: " + scoreDoc.doc);
         System.out.println("id: " + doc.get("id"));
         System.out.println("title: " + doc.get("title"));
         System.out.println("content: " + doc.get("content"));
         System.out.println("reply: " + doc.get("reply_display"));
         System.out.println("文档评分: " + scoreDoc.score);
         TokenStream tokenStream = TokenSources.getAnyTokenStream(searcher.getIndexReader(), scoreDoc.doc, field, analyzer);
         Fragmenter fragmenter = new SimpleSpanFragmenter(scorer);
         highlighter.setTextFragmenter(fragmenter);
         String str = highlighter.getBestFragment(tokenStream, doc.get(field));
         System.out.println("高亮的片段：" + str);
      }
      directory.close();
      reader.close();
   }
}

1566709467482

发表于 | 分类于 ，

目录

2.5.1、搜索入门

2.5.2、多域搜索（MultiFieldQueryParse）

2.5.3、词项搜索（TermQuery）

2.5.4、布尔搜索（BooleanQuery）

2.5.5、范围搜索（RangeQuery）

2.5.6、前缀搜索（PrefixQuery）

2.5.7、多关键字搜索（PhraseQuery）

2.5.8、模糊搜索（FuzzyQuery）

2.5.9、通配符搜索（WildcardQuery）

-—————————————————

文档索引完成以后就能对其进行搜索；

当用户输入一个关键字，

​ –> 首先 对这个关键字 进行 分析和处理， 转化成后台可以理解的形式

​ –> 进行检索

2.5.1、搜索入门

处理关键词 <==> 构建Query对象的过程；

搜索文档 <==> 实例化 IndexSearcher 对象，使用search()方法完成；

​ 参数：Query对象

​ 结果：保存在 TopDocs 类型的文档集合中；

删除indexdir下的索引文件后，重新使用CreateIndex.java 生成索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.learn.lucene.chapter2.queries;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
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 java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.1、查询
 */
public class QueryParseTest {
	public static void main(String[] args) throws IOException, ParseException {
		String field = "title";
		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		Analyzer analyzer = new IKAnalyzer8x();
		QueryParser parser = new QueryParser(field, analyzer);
		parser.setDefaultOperator(QueryParser.Operator.AND);
		Query query = parser.parse("农村学生");
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}

}

运行结果：

修改后再运行：

​

2.5.2、多域搜索（MultiFieldQueryParse）

根据多个字段搜索

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package com.learn.lucene.chapter2.queries;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
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 java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.2、多域搜索
 */
public class MultiFieldQueryParseTest {
	public static void main(String[] args) throws IOException, ParseException {
		String[] field = {"title", "content"};
		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		Analyzer analyzer = new IKAnalyzer8x(true);
		MultiFieldQueryParser parser = new MultiFieldQueryParser(field, analyzer);
		parser.setDefaultOperator(QueryParser.Operator.AND);
		Query query = parser.parse("美国");
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("content: " + doc.get("content"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}
}

运行结果：

​

2.5.3、词项搜索（TermQuery）

TermQuery 是 最常用的 Query

TermQuery 是 Lucene中搜索的最基本单位

本质上：一个词条就是一个 key/value 对

使用TermQuery：

  • 首先构造一个 Term对象；Term term = new Term(“title”, “美国”);
  • 然后使用Term对象为参数，构造一个TermQuery对象；TermQuery query = new TermQuery(term);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.learn.lucene.chapter2.queries;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.3 词项搜索
 */
public class TermQueryTest {
	public static void main(String[] args) throws IOException, ParseException {

		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		Term term = new Term("title", "美国");
		TermQuery query = new TermQuery(term);
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}
}

运行结果：

​

2.5.4、布尔搜索（BooleanQuery）

BooleanQuery 可以 组合 其他 Query，并标明他们的逻辑关系；

例如：查询 content 中包含美国，并且 title 不包含美国的文档；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package com.learn.lucene.chapter2.queries;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.4、布尔搜索（BooleanQuery）
 * 查询 content 中包含美国，并且 title 不包含美国的文档；
 */
public class BooleanQueryTest {
	public static void main(String[] args) throws IOException, ParseException {
		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		TermQuery query1 = new TermQuery(new Term("title", "美国"));
		TermQuery query2 = new TermQuery(new Term("content", "美国"));
		BooleanClause booleanClause1 = new BooleanClause(query1, BooleanClause.Occur.MUST_NOT);
		BooleanClause booleanClause2 = new BooleanClause(query2, BooleanClause.Occur.MUST);
		BooleanQuery query = new BooleanQuery.Builder().add(booleanClause1).add(booleanClause2).build();

		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("content: " + doc.get("content"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}

}

运行结果：

​

2.5.5、范围搜索（RangeQuery）

举例：查询新闻回复条数在 500~1000 之间的文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.learn.lucene.chapter2.queries;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.IntPoint;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryparser.classic.ParseException;
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 java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.5、范围搜索（RangeQuery）
 * 举例：查询新闻回复条数在 500~1000 之间的文档
 */
public class RangeQueryTest {
	public static void main(String[] args) throws IOException, ParseException {

		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		Query query = IntPoint.newRangeQuery("reply", 500, 1000);
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("content: " + doc.get("content"));
			System.out.println("reply: " + doc.get("reply_display"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}
}

​

2.5.6、前缀搜索（PrefixQuery）

举例：搜索 包含以“学”开头的词项 的文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.learn.lucene.chapter2.queries;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.6、前缀搜索（PrefixQuery）
 * 举例：搜索 包含以“学”开头的词项 的文档
 */
public class PrefixQueryTest {
	public static void main(String[] args) throws IOException, ParseException {

		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		Term term = new Term("title", "学");
		Query query = new PrefixQuery(term);
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}
}

运行结果：

​

2.5.7、多关键字搜索（PhraseQuery）

  • PhraseQuery 可以 通过add方法添加多个关键字
  • 还可以通过 setSlop() 设定“坡度”，允许关键字之间 无关词汇存在量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package com.learn.lucene.chapter2.queries;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.PhraseQuery;
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 java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.7、多关键字搜索（PhraseQuery）
 * PhraseQuery 可以 通过add方法添加多个关键字
 * 还可以通过 setSlop() 设定“坡度”，允许关键字之间 无关词汇存在量
 */
public class PhraseQueryTest {
	public static void main(String[] args) throws IOException, ParseException {
		String str = "习近平会见奥巴马，学习国外经验";

		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		PhraseQuery.Builder builder = new PhraseQuery.Builder();
		builder.add(new Term("title", "奥巴马"), str.indexOf("奥巴马"));
		builder.add(new Term("title", "学习国外经验"), str.indexOf("学习国外经验"));
		PhraseQuery query = builder.build();
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("content: " + doc.get("content"));
			System.out.println("reply: " + doc.get("reply_display"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}
}

运行结果(感觉没有成功)：

​

2.5.8、模糊搜索（FuzzyQuery）

它可以简单的识别两个相近的词语。

举例：“Trump”，写成“Trmp”，拼写错误，仍然可以搜索得到正确的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.learn.lucene.chapter2.queries;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.8、模糊搜索（FuzzyQuery）
 * 它可以简单的识别两个相近的词语。
 * 举例：“Trump”，写成“Trmp”，拼写错误，仍然可以搜索得到正确的结果
 */
public class FuzzyQueryTest {
	public static void main(String[] args) throws IOException, ParseException {
		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		Query query = new FuzzyQuery(new Term("title", "Trmp"));
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("content: " + doc.get("content"));
			System.out.println("reply: " + doc.get("reply_display"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}
}

​

2.5.9、通配符搜索（WildcardQuery）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.learn.lucene.chapter2.queries;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 2.5.9、通配符搜索（WildcardQuery）
 */
public class WildcardQueryTest {
	public static void main(String[] args) throws IOException, ParseException {
		Path indexPath = Paths.get("indexdir");
		Directory directory = FSDirectory.open(indexPath);
		IndexReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		Query query = new WildcardQuery(new Term("title", "习?平"));
		System.out.println("Query: " + query.toString());  // 查询关键词
		// 返回前10条
		TopDocs topDocs = searcher.search(query, 10);
		for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
			Document doc = searcher.doc(scoreDoc.doc);
			System.out.println("DocID: " + scoreDoc.doc);
			System.out.println("id: " + doc.get("id"));
			System.out.println("title: " + doc.get("title"));
			System.out.println("content: " + doc.get("content"));
			System.out.println("reply: " + doc.get("reply_display"));
			System.out.println("文档评分: " + scoreDoc.score);
		}
		directory.close();
		reader.close();
	}
}

发表于

人群一：学生【中高考，大学生，考研生】

1、中高考【应对考试】

时间规划：每周2小时词汇速记【每次上课30分钟即可】

学习策略：1~300词根是中高考的核心

学习顺序：

① 词根词缀完全默写：汉语意思完全掌握【结合词元理解词根】

② 总结：根据每个词根下历次进行重复的词缀统计

③ 熟记核心词：模仿老师的教学笔记，尝试通过词根词缀拆分核心词，之后根据核心词的含义和词性

④ 根据教学内容：准确划分思维导图【不需要增加汉语意思】

⑤ 读单词必须依据音标：学音标没有为什么，只有是什么

2、大学生【口语和应用为主】

学习强度：每周至少3小时词汇速记【3节课】

学习策略：

① 思维导图务必采用软件制作

② 单词的发音务必及时掌握

③ 要在固定的英语文章当中刻意寻找刻意拆分的单词

④ 针对考研学生：所有的考研历年真题都是拆分单词的核心试题，最好通过词源网站的英文解释来加深考研词汇的印象。abbreviate 查词元 -> 拆单词：ab-brev-i-ate

考研单词很多词频都在10000~20000之间 = 400 词根

人群二：职场人士 —— 学习顺序同上（中高考）

时间规划：一周零碎时间学习

模式一（特别忙）：

  • 每天中午20分钟 —— 一周保证2节课
  • 每天速记笔记，完成作业的时间 —— 睡前30分钟

模式二：

  • 选择周六日的时间，一天一节课，课后1小时完成作业

人群三：完全出于兴趣，自我提升，没有压力

① 通过枚举和BBC类型的纪录片 学习词根和词缀。凡是出现再片中的词根都是高频词根

② 每周的学习频率至少保持在2~4节课

人群四：出国人群

学习策略

① 强度：

  • 如果在国外的学生，每天务必学习单词1小时

  • 如果实在国内备战的学生：雅思托福的准备时间：3~6个月（不能再长）

  • 单词速记要求一周之内：

    • 5节课 + 作业（每个词根化思维导图）+ 真题答案单词的拆分
    • 替换高级词汇： difficult = complicated

②

上课听讲 - 记笔记， 下课回放 看三轮

每节作业保质量，课后作业要自觉；

分布考查要自信，分级练习要坚持；

思维导图是核心

发表于 | 分类于 ，

目录

2.4.1、Lucene 字段类型

2.4.2、索引文档示例

2.4.3、在Luke中查看索引

2.4.4、索引的删除

2.4.5 索引的更新

-———————————————–

上一节 介绍完了 Lucene 分词器，这节介绍 Lucene 是如何索引文档的。

​

2.4.1、Lucene 字段类型

文档：文档是 Lucene索引的基本单位；

字段：比文档更小的单位，字段是文档的一部分；

​ 每个字段 由 3部分组成：名称（name），类型（type），取值（value）；

​ 字段的取值（value）一般为：文本、二进制、数值

Lucene的主要字段类型：

  • TextField：字段内容 -> 索引并词条化 -> 不保存 词向量 -> 整篇文档的body字段，常用TextField进行索引；
  • StringField：只 索引 -> 不词条化 -> 不保存 词向量；
  • IntPoint：适合 int类型 的索引；
  • LongPoint：适合 long类型的 索引；
  • FloatPoint：
  • DoublePoint：
  • SortedDocValuesField：存储值为 文本内容的 DocValue字段，且需要 按值排序；
  • SortedSetDocValuesField：多值域为 DocValue字段，值为文本内容，且 需要 按值分组、聚合；
  • NumbericDocValuesField： DocValue为（int，long，float，double）
  • SortedNumbericDocValuesField：需要排序的 （int，long，float，double）
  • SortedField：索引 保存字段值，不进行其他操作

Lucene 使用 倒排索引 快速搜索 <===> 建立 词项和文档id的关系映射；

搜索过程：

​ 通过 类似hash算法 -> 定位到 搜索关键词 -> 读取文档id集合

上述过程的缺陷：

​ 当我们需要对数据做 聚合操作，排序、分组时，Lucene会提取所有出现在文档集合中的排序字段，再次构建一个排好序的文件集合；这个过程全部在内存中进行，如果数据量巨大，会造成 内存溢出 和 性能缓慢；

Lucene 4.X 之后出现了 DocValues，DocValues是 Lucene 构建索引时，额外建立的一个有序的基于 document => field/value 的映射列表。

​

2.4.2、索引文档示例

代表新闻的实例类 News.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package com.learn.lucene.chapter2.index;

/**
 * 代表新闻的实例类 News.java
 */
public class News {

	private int id;
	private String title;
	private String content;
	private int reply;

	public News() {
	}

	public News(int id, String title, String content, int reply) {
		super();
		this.id = id;
		this.title = title;
		this.content = content;
		this.reply = reply;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	public int getReply() {
		return reply;
	}

	public void setReply(int reply) {
		this.reply = reply;
	}
}

创建索引文件的CreateIndex.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package com.learn.lucene.chapter2.index;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.IndexOptions;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Date;

/**
 * 创建索引
 */
public class CreateIndex {

	public static void main(String[] args) {
		// 创建 3 个News对象
		News news1 = new News();
		news1.setId(1);
		news1.setTitle("习近平会见美国总统奥巴马，学习国外经验");
		news1.setContent("国家主席习近平9月3日在杭州西湖宾馆会见前来出席二十国集团领导人杭州峰会的美国总统奥巴马");
		news1.setReply(672);

		News news2 = new News();
		news2.setId(2);
		news2.setTitle("北大迎4380名新生，农村学生700多人今年最多");
		news2.setContent("昨天，北京大学迎来4380名来自全国各地及数十个国家的本科新生。其中，农村学生工700余名，为今年最多...");
		news2.setReply(995);

		News news3 = new News();
		news3.setId(3);
		news3.setTitle("特朗普宣誓（Donald Trump）就任美国第45任总统");
		news3.setContent("当地时机1月20日，唐纳德·特朗普在美国国会宣誓就职，正式成为美国第45任总统。");
		news3.setReply(1872);

		// 创建IK分词器
		Analyzer analyzer = new IKAnalyzer8x();
		IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
		iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
		Directory directory = null;
		IndexWriter indexWriter = null;
		// 索引目录
		Path indexPath = Paths.get("indexdir");
		// 开始时间
		Date start = new Date();
		try {
			if (!Files.isReadable(indexPath)) {
				System.out.println("Document directory '" + indexPath.toAbsolutePath() + "' is not readable! please check");
				System.exit(1);
			}
			directory = FSDirectory.open(indexPath);
			indexWriter = new IndexWriter(directory, iwc);
			// 设置新闻ID 索引 并存储
			FieldType idType = new FieldType();
			idType.setIndexOptions(IndexOptions.DOCS);
			idType.setStored(true);
			// 设置新闻标题索引文档，词项频率，位移信息，和偏移量，存储并词条化
			FieldType titleType = new FieldType();
			titleType.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
			titleType.setStored(true);
			titleType.setTokenized(true);

			FieldType contentType = new FieldType();
			contentType.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
			contentType.setStored(true);
			contentType.setTokenized(true);
			contentType.setStoreTermVectors(true);
			contentType.setStoreTermVectorPositions(true);
			contentType.setStoreTermVectorOffsets(true);
			contentType.setStoreTermVectorPayloads(true);

			Document doc1 = new Document();
			doc1.add(new Field("id", String.valueOf(news1.getId()), idType));
			doc1.add(new Field("title", news1.getTitle(), titleType));
			doc1.add(new Field("content", news1.getContent(), contentType));
			doc1.add(new IntPoint("reply", news1.getReply()));
			doc1.add(new StoredField("reply_display", news1.getReply()));

			Document doc2 = new Document();
			doc2.add(new Field("id", String.valueOf(news2.getId()), idType));
			doc2.add(new Field("title", news2.getTitle(), titleType));
			doc2.add(new Field("content", news2.getContent(), contentType));
			doc2.add(new IntPoint("reply", news2.getReply()));
			doc2.add(new StoredField("reply_display", news2.getReply()));

			Document doc3 = new Document();
			doc3.add(new Field("id", String.valueOf(news3.getId()), idType));
			doc3.add(new Field("title", news3.getTitle(), titleType));
			doc3.add(new Field("content", news3.getContent(), contentType));
			doc3.add(new IntPoint("reply", news3.getReply()));
			doc3.add(new StoredField("reply_display", news3.getReply()));

			indexWriter.addDocument(doc1);
			indexWriter.addDocument(doc2);
			indexWriter.addDocument(doc3);
			indexWriter.commit();
			indexWriter.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		Date end = new Date();
		System.out.println("索引文档用时：" + (end.getTime() - start.getTime()) + " milliseconds.");
	}
}

运行结果：

生成对应的索引文件

​

2.4.3、在Luke中查看索引

打开索引文件目录：D:\java\oschina\lucene-learn\lucene-chapter2\indexdir

​

2.4.4、索引的删除

索引同样存在 CRUD 操作

本节演示 根据 Term 来删除点单个或多个Document，删除 title 中 包含关键词“美国”的文档。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.learn.lucene.chapter2.index;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 删除索引
 */
public class DeleteIndex {
	public static void main(String[] args) {
		// 删除 title 中含有关键字“美国”的文档
		deleteDoc("title", "美国");
	}

	public static void deleteDoc(String field, String key) {
		Analyzer analyzer = new IKAnalyzer8x();
		IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);
		Path indexPath = Paths.get("indexdir");
		Directory directory;
		try {
			directory = FSDirectory.open(indexPath);
			IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);
			indexWriter.deleteDocuments(new Term(field, key));
			indexWriter.commit();
			indexWriter.close();
			System.out.println("删除完成");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

运行结果：

除此之外，IndexWriter还提供了以下方法：

  • DeleteDocuments(Query query)：根据Query条件来删除单个或多个Document。
  • DeleteDocuments(Query[] queries)：根据Query条件来删除单个或多个Document。
  • DeleteDocuments(Term term)：根据Term条件来删除单个或多个Document。
  • DeleteDocuments(Term[] terms)：根据Term条件来删除单个或多个Document。
  • DeleteAll()：删除所有的Document。

使用IndexWriter进行Document删除操作时，文档并不会立即被删除，而是把这个删除动作缓存起来，当IndexWriter.Commit() 或 IndexWriter.Close()时，删除操作才会真正执行。

​

使用Luke 重新打开 索引之后，只剩下了一个索引文档：

​

2.4.5 索引的更新

本质：先删除索引，再建立新的文档。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.learn.lucene.chapter2.index;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.FieldType;
import org.apache.lucene.index.IndexOptions;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 更新索引
 */
public class UpdateIndex {

	public static void main(String[] args) {
		Analyzer analyzer = new IKAnalyzer8x();
		IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);
		Path indexPath = Paths.get("indexdir");
		Directory directory;
		try {
			directory = FSDirectory.open(indexPath);
			IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);
			Document doc = new Document();

			// 设置新闻ID 索引 并存储
			FieldType idType = new FieldType();
			idType.setIndexOptions(IndexOptions.DOCS);
			idType.setStored(true);
			// 设置新闻标题索引文档，词项频率，位移信息，和偏移量，存储并词条化
			FieldType titleType = new FieldType();
			titleType.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
			titleType.setStored(true);
			titleType.setTokenized(true);

			FieldType contentType = new FieldType();
			contentType.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
			contentType.setStored(true);
			contentType.setTokenized(true);
			contentType.setStoreTermVectors(true);
			contentType.setStoreTermVectorPositions(true);
			contentType.setStoreTermVectorOffsets(true);
			contentType.setStoreTermVectorPayloads(true);

			doc.add(new Field("id", "2", idType));
			doc.add(new Field("title", "北大迎4380名新生", titleType));
			doc.add(new Field("content", "昨天，北京大学迎来4380名来自全国各地及数十个国家的本科新生。其中，农村学生工700余名，为今年最多...", contentType));
			indexWriter.updateDocument(new Term("title", "北大"), doc);
			indexWriter.commit();
			indexWriter.close();
			System.out.println("更新完成");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

运行结果：

修改前：

修改后：

发表于 | 分类于 ，

目录

2.3.1、Lucene分词系统

2.3.2、分词测试

2.3.3、IK分词器配置

2.3.4、中文分词器对比

2.3.5、扩展停用词词典

2.3.6、扩展自定义词典

-——————————————————————

​

2.3.1、Lucene分词系统

索引和查询 都是以 词项 为基本单位

Lucene中，分词 主要依靠 Analyzer类 解析实现

Analyzer是抽象类，内部调用 TokenStream 实现

​

2.3.2、分词测试

StandardAnalyzer 分词器测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.learn.lucene.chapter2.analyzer;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;

import java.io.IOException;
import java.io.StringReader;

/**
 * StandardAnalyzer demo
 */
public class StdAnalyzerDemo {
	private static String strCh = "中华人名共和国简称中国，是一个有13亿人口的国家";
	private static String strEn = "Dogs can not achieve a place, eyes can reach;";
	public static void main(String[] args) throws IOException {
		System.out.println("StandardAnalyzer 对中文分词：");
		stdAnalyzer(strCh);
		System.out.println("StandardAnalyzer 对英文分词：");
		stdAnalyzer(strEn);
	}

	public static void stdAnalyzer(String str) throws IOException {
		Analyzer analyzer = null;
		analyzer = new StandardAnalyzer();
		StringReader reader = new StringReader(str);
		TokenStream tokenStream = analyzer.tokenStream(str, reader);
		tokenStream.reset();
		CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
		System.out.println("分词结果：");
		while (tokenStream.incrementToken()) {
			System.out.print(charTermAttribute.toString() + "|");
		}
		System.out.println("\n");
		analyzer.close();
	}
}

运行结果：

测试多种Analyzer，注意要特意指定 jdk8： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package com.learn.lucene.chapter2.analyzer;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.cjk.CJKAnalyzer;
import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
import org.apache.lucene.analysis.core.KeywordAnalyzer;
import org.apache.lucene.analysis.core.SimpleAnalyzer;
import org.apache.lucene.analysis.core.StopAnalyzer;
import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;

import java.io.IOException;
import java.io.StringReader;
import java.util.StringJoiner;

/**
 * 测试多种分词器
 */
public class VariousAnalyzersDemo {

	private static String strCh = "中华人民共和国简称中国，是一个有13亿人口的国家";
	private static String strEn = "Dogs can not achieve a place, eyes can reach;";

	public static void main(String[] args) throws IOException {
		System.out.println("标准分词：" + printAnalyzer(new StandardAnalyzer(), strCh));
		System.out.println("空格分词：" + printAnalyzer(new WhitespaceAnalyzer(), strCh));
		System.out.println("简单分词：" + printAnalyzer(new SimpleAnalyzer(), strCh));
		System.out.println("二分法分词：" + printAnalyzer(new CJKAnalyzer(), strCh));
		System.out.println("关键字分词：" + printAnalyzer(new KeywordAnalyzer(), strCh));
		System.out.println("停用词分词：" + printAnalyzer(new StopAnalyzer(new StringReader(strCh)), strCh));
		System.out.println("中文智能分词：" + printAnalyzer(new SmartChineseAnalyzer(), strCh));
	}

	public static String printAnalyzer(Analyzer analyzer, String str) throws IOException {
		StringReader reader = new StringReader(str);
		TokenStream tokenStream = analyzer.tokenStream(str, reader);
		tokenStream.reset();
		CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
		StringJoiner stringJoiner = new StringJoiner("|");
		while (tokenStream.incrementToken()) {
			stringJoiner.add(charTermAttribute.toString());
		}
		analyzer.close();
		return stringJoiner.toString();
	}
}

运行结果：

​

2.3.3、IK分词器配置

Lucene 8.0 实用 IK分词器需要修改 IKTokenizer 和 IKAnalyzer

在 com.learn.lucene.chapter2.ik 下 新建 IKTokenizer8x.java 和 IKAnalyzer8x.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.learn.lucene.chapter2.ik;

import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;

import java.io.IOException;

/**
 * 修改 IKTokenizer —— incrementToken()
 */
public class IKTokenizer8x extends Tokenizer {
	// IK分词器实现
	private IKSegmenter _IKIkSegmenter;
	// 词元文本属性
	private final CharTermAttribute termAttribute;
	// 词元位移属性
	private final OffsetAttribute offsetAttribute;
	// 词元分类属性
	// (该属性分类参考 org.wltea.analyzer.core.Lexeme 中的分类常量)
	private final TypeAttribute typeAttribute;
	// 记录最后一个词元的结束位置
	private int endPosttion;

	// Lucene 8.x Tokenizer适配器类构造函数，实现最新的 Tokenizer 接口
	public IKTokenizer8x(boolean useSmart) {
		super();
		offsetAttribute = addAttribute(OffsetAttribute.class);
		termAttribute = addAttribute(CharTermAttribute.class);
		typeAttribute = addAttribute(TypeAttribute.class);
		_IKIkSegmenter = new IKSegmenter(input, useSmart);
	}

	@Override
	public boolean incrementToken() throws IOException {
		clearAttributes();      // 清除所有的词元属性
		Lexeme nextLexeme = _IKIkSegmenter.next();
		if (nextLexeme != null) {
			// 将 Lexeme 转化成 Attributes
			termAttribute.append(nextLexeme.getLexemeText());  // 设置词元文本
			termAttribute.setLength(nextLexeme.getLength());  // 设置词元长度
			offsetAttribute.setOffset(nextLexeme.getBeginPosition(), nextLexeme.getEndPosition());  // 设置词元位移
			endPosttion = nextLexeme.getEndPosition();  // 记录 分词的最后位置
			typeAttribute.setType(nextLexeme.getLexemeText()); // 记录词元分分类
			return true; // 返回true 告知 还有下个词元
		}
		return false;
	}

	@Override
	public void reset() throws IOException {
		super.reset();
		_IKIkSegmenter.reset(input);
	}

	@Override
	public final void end() throws IOException {
		int finalOffset = correctOffset(this.endPosttion);
		offsetAttribute.setOffset(finalOffset, finalOffset);
	}
}

​ 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.learn.lucene.chapter2.ik;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.Tokenizer;

/**
 * 修改IKAnalyzer —— createComponents(String fieldName)
 */
public class IKAnalyzer8x extends Analyzer {

	private boolean useSmart;

	public IKAnalyzer8x() {
		this(false);
	}

	public IKAnalyzer8x(boolean useSmart) {
		super();
		this.useSmart = useSmart;
	}

	@Override
	protected TokenStreamComponents createComponents(String fieldName) {
		Tokenizer _IKTokenizer = new IKTokenizer8x(this.isUseSmart());
		return new TokenStreamComponents(_IKTokenizer);
	}

	public boolean isUseSmart() {
		return useSmart;
	}

	public void setUseSmart(boolean useSmart) {
		this.useSmart = useSmart;
	}
}

实例化 IKAnalyzer8x 就能实用IK分词器了

1、 默认使用细粒度切分算法：

​ Analyzer analyzer = new IKAnalyzer8x();

2、创建智能切分算法的 IKAnalyzer：

​ Analyzer analyzer = new IKAnalyzer8x(true);

​

2.3.4、中文分词器对比

​ 分词效果会直接影响文档搜索的准确性

​ 我们对比一下 Lucene自带的 SmartChineseAnalyzer 和 IK Analyzer的效率。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package com.learn.lucene.chapter2.analyzer;

import com.learn.lucene.chapter2.ik.IKAnalyzer8x;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;

import java.io.IOException;
import java.io.StringReader;
import java.util.StringJoiner;

/**
 * 中文分词器效果对比
 * 1、Lucene 自带的 SmartChineseAnalyzer 分词器
 * 2、IKAnalyzer8x分词器
 */
public class IkVSSmartchDemo {

	private static String str1 = "公路局正在治理解放大道路面积水问题。";
	private static String str2 = "IKAnalyzer 是一个开源的，基于java语言开发的轻量级的中文分词工具包。";

	public static void main(String[] args) throws IOException {
		System.out.println("句子一：" + str1);
		System.out.println("SmartChineseAnalyzer分词结果：" + printAnalyzer(new SmartChineseAnalyzer(), str1));
		System.out.println("IKAnalyzer8x分词结果：" + printAnalyzer(new IKAnalyzer8x(true), str1));
//		System.out.println("IKAnalyzer分词结果(bug)：" + printAnalyzer(new IKAnalyzer(), str1));
		System.out.println("----------------------------------------");
		System.out.println("句子二：" + str2);
		System.out.println("SmartChineseAnalyzer分词结果：" + printAnalyzer(new SmartChineseAnalyzer(), str2));
		System.out.println("IKAnalyzer8x分词结果：" + printAnalyzer(new IKAnalyzer8x(true), str2));
//		System.out.println("IKAnalyzer分词结果(bug)：" + printAnalyzer(new IKAnalyzer(true), str2));
	}

	public static String printAnalyzer(Analyzer analyzer, String str) throws IOException {
		StringReader reader = new StringReader(str);
		TokenStream tokenStream = analyzer.tokenStream(str, reader);
		tokenStream.reset();
		CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
		StringJoiner stringJoiner = new StringJoiner("|");
		while (tokenStream.incrementToken()) {
			stringJoiner.add(charTermAttribute.toString());
		}
		analyzer.close();
		return stringJoiner.toString();
	}
}

​

2.3.5、扩展停用词词典

IK Analyzer 默认的停用词词典为 IKAnalyzer2012_u6/stopword.dic

这个词典只有30多个英文停用词，并不完整

推荐使用扩展额停用词词表：https://github.com/cseryp/stopwords

在工程中新建 ext_stopword.dic，放在IKAnalyzer.cfg.xml同一目录；

编辑IKAnalyzer.cfg.xml，

​

发表于 | 分类于 ，

目录

  1. 官网
  2. 下载Lucune文件库
  3. 下载Luke——查看索引的GUI工具
  4. 下载 IK 分词工具 —— 轻量级中文分词工具包
  5. 工程搭建

-—————————————————

​

官网

http://lucene.apache.org/

下载Lucune文件库

https://mirrors.tuna.tsinghua.edu.cn/apache/lucene/java/8.0.0/

或者在工程中添加maven依赖

https://mvnrepository.com/artifact/org.apache.lucene/lucene-core/

1
2
3
4
5
<dependency>
​    <groupId>org.apache.lucene</groupId>
​    <artifactId>lucene-core</artifactId>
​    <version>8.0.0</version>
</dependency>

​

下载Luke——查看索引的GUI工具

主要功能：

  • 查看文档和分析字段内容；
  • 搜索索引；
  • 执行索引维护；
  • 从HDFS读取索引；
  • 将全部或部分索引转换为XML格式导出；
  • 测试自定义的Lucene分词器；

注意：Luke的版本要跟Lucene保持一致

项目地址：https://github.com/DmitryKey/luke/releases

​

下载 IK 分词工具 —— 轻量级中文分词工具包

独立于Lucene，面向Java的公用分词组件

同时提供了 对Lucene的默认优化实现

IK Analyzer2012的特性：

  1. 采用“正向迭代最细力度切分算法”，支持细粒度和智能分词两种切分模式；
  2. 具有 160万字/s 的高速处理能力，i73.4G双核、4G内存，win7 64位，jdk1.6；
  3. 支持简单的分词排歧义处理、数量词合并输出；
  4. 多子处理器分析模式，支持英文字母、数字、中文词汇等分词处理、兼容韩文、日文字符；
  5. 优化词典存储，更小的内存占用。

下载地址（需要翻墙）：https://code.google.com/p/ik-analyzer/downloads/list

也可有上我的 oschina上下载：

安装包文件列表：

  • drwxr-xr-x 1 doc/ —— API 文档说明
  • -rw-r–r– 1 IKAnalyzer.cfg.xml —— 分词器扩展配置文件
  • -rw-r–r– 1 IKAnalyzer2012_u6.jar —— 主jar包
  • -rw-r–r– 1 IKAnalyzer中文分词器V2012_U5使用手册.pdf
  • -rw-r–r– 1 IKAnalyzer中文分词器V2012使用手册.pdf
  • -rw-r–r– 1 LICENSE.txt —— Apache版权申明
  • -rw-r–r– 1 NOTICE.txt —— Apache版权申明
  • -rw-r–r– 1 stopword.dic —— 停止词典

部署步骤：

把 IKAnalyzer2012_u6.jar 放在部署项目的lib目录下

把 stopword.dic 和 IKAnalyzer.cfg.xml 放在 class根目录，对于web工程时 WEB-INFO/classes 目录下

​

工程搭建

1、maven 安装 IKAnalyzer2012_u6.jar

mvn install:install-file -Dfile=D:\java\oschina\lucene-learn\lucene-chapter2\lib\IKAnalyzer2012_u6.jar -DgroupId=org.wltea.analyzer -DartifactId=IKAnalyzer -Dversion=2012_u6 -Dpackaging=jar -DgeneratePom=true -DcreateChecksum=true

2、在pom.xml中添加

1
2
3
4
5
<dependency>
​    <groupId>org.wltea.analyzer</groupId>
​    <artifactId>IKAnalyzer</artifactId>
​    <version>2012_u6</version>
</dependency>

3、 stopword.dic 和 IKAnalyzer.cfg.xml 放在 src\main\resources 目录下

这样编译完成后，它就会放在 classes 目录下

发表于 | 分类于 ，

Lucene 3个优点

1、稳定、索引性能高

2、高效、准确、高性能的搜索算法

3、跨平台解决方案

​

Lucene架构

1、信息采集 —— 文件、数据库、万维网、及手工输入，都能作为采集对象

2、索引文档 —— 即倒排序索引的构建过程

3、搜索文档 —— 用户发起查询 到 拿到结果的过程