public void createIndex() throws IOException {
	// 获取原文档数据，比如File、mysql等
	List<MyData> myDataList = getData();
	// 1.将采集到的数据封装到Document对象中
    List<Document> docList = new ArrayList<>();
	for (MyData data : myDataList) {
		// 创建document对象
		Document document = new Document();
		// Field类型，不同子类存储类型不同，且：是否分词、索引、存储
		Field id = new StringField("id", data.getId().toString(), Field.Store.YES);
        Field title = new TextField("title", data.getTitle(), Field.Store.YES);
		Field author = new TextField("author", data.getAuthor(), Field.Store.YES);
        Field price = new StoredField("price", data.getPrice().toString());
		Field num = new StoredField("num", data.getNum().toString());
		Field imagePath = new StoredField("imagePath", data.getImagePath());
		Field status = new StoredField("status", data.getStatus().toString());
		
		// 将field域设置到Document对象中
        document.add(id);
        document.add(title);
        document.add(author);
		document.add(price);
		document.add(num);
		document.add(imagePath);
		document.add(status);
        docList.add(document);
	}
	
	// 2.指定一个标准分析器，主要有分词和过滤两个步骤：
	// 将field域中的内容一个个的分词；将分好的词进行过滤，比如去掉标点符号、大写转小写、词的型还原、停用词过滤
    Analyzer analyzer = new StandardAnalyzer();
	// 3.创建IndexWriterConfig对象
	IndexWriterConfig config = new IndexWriterConfig(analyzer);
	// 4.指定索引库的存放位置Directory对象
	Path path = Paths.get("indexDB");	// 项目相对路径
	Directory directory = FSDirectory.open(path);	
	// 5.创建IndexWriter对象(核心)
    IndexWriter indexWriter = new IndexWriter(directory, config);	
	
	// 可以使用IndexWriter来更新和删除索引
	// 修改时如果根据查询条件可以查出结果，则将其删掉覆盖新的doc；否则直接新增一个doc
	// indexWriter.updateDocument(new Term("author", "jack"), newDocument);
	// Term是索引域中最小的单位。根据条件删除时，建议根据唯一键来进行删除。在solr中就是根据ID来进行删除和修改操作的
	// indexWriter.deleteDocuments(new Term("id", "23333"));
	
	// 通过IndexWriter对象将Document写入到索引库中，此过程进行索引创建，并将索引和document对象写入索引库
    for (Document document : docList) {
        indexWriter.addDocument(document);
    }
    // 关闭indexWriter
    indexWriter.close();
}

public void searchIndex() throws Exception {
    // 1.创建QueryParser对象，默认搜索title，需要指定分词器，搜索时的分词器要和索引时的分词器一致
    QueryParser parser = new QueryParser("title", new StandardAnalyzer());
	// 2.创建Query对象，输入的lucene的查询语句(关键字要大写)
    Query query = parser.parse("lucene AND solr");	
	
	
	// 3.指定索引库的存放位置Directory对象
	Path indexPath = Paths.get("indexDB");
	Directory directory = FSDirectory.open(indexPath);
	// 4.创建IndexReader对象
	IndexReader reader = DirectoryReader.open(directory);
	// 5.创建IndexSearcher对象(核心)
	IndexSearcher indexSearcher = new IndexSearcher(reader);
	
	// 6.通过IndexSearcher的searcher方法来搜索索引库，返回顶部10条结果集
	TopDocs topDocs = indexSearcher.search(query, 10);
	// 顶部匹配记录
    ScoreDoc[] scoreDocs = topDocs.scoreDocs;
    for (ScoreDoc scoreDoc : scoreDocs) {
		// 获取文档的ID
		int docId = scoreDoc.doc;
		// 7.通过ID获取文档
		Document doc = indexSearcher.doc(docId);
		System.out.println(doc.get("id"));
		System.out.println(doc.get("title"));
		System.out.println(doc.get("price"));
		System.out.println(doc.get("num"));
		System.out.println(scoreDoc.score);
		System.out.println("=================");
	}
	// 关闭资源
	reader.close();
}

public class Field implements IndexableField {
	// Field's type 类型
	protected final IndexableFieldType type;
	// Field's name 名称
	protected final String name;
	// Field's value 值
	protected Object fieldsData;
	// Pre-analyzed tokenStream for indexed fields 定义fieldsData怎么分词
	protected TokenStream tokenStream;
}

public final class TextField extends Field {

  /** Indexed, tokenized, not stored. */
  public static final FieldType TYPE_NOT_STORED = new FieldType();

  /** Indexed, tokenized, stored. */
  public static final FieldType TYPE_STORED = new FieldType();

  static {
    TYPE_NOT_STORED.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
    TYPE_NOT_STORED.setTokenized(true);
    TYPE_NOT_STORED.freeze();	// 冻结

    TYPE_STORED.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
    TYPE_STORED.setTokenized(true);
    TYPE_STORED.setStored(true);	// 存储
    TYPE_STORED.freeze();	// 冻结
  }
  
  public TextField(String name, String value, Store store) {
    super(name, value, store == Store.YES ? TYPE_STORED : TYPE_NOT_STORED);
  }
}

Query query1 = new TermQuery(new Term("title", "lucene"));
Query query2 = new TermQuery(new Term("author", "jack"));
// 利用BoostQuery包装Query
BoostQuery highQuery1 = new BoostQuery(query1, 100f);

BooleanQuery.Builder builder = new BooleanQuery.Builder();
builder.add(highQuery1, BooleanClause.Occur.MUST);
builder.add(query2, BooleanClause.Occur.MUST);
BooleanQuery query = builder.build();


String[] fields = {"title", "auther"};
Map<String, Float> boosts = new HashMap<>();
boosts.put("title", 100f);
// 利用MultiFieldQueryParser构造函数传参
MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, new StandardAnalyzer(), boosts);
Query query = parser.parse("java"); 

Sort sort = new Sort();
// true表示降序
SortField f1 = new SortField("author", SortField.Type.STRING, true);
SortField f2 = new SortField("num", SortField.Type.INT, false);
sort.setSort(new SortField[]{f1, f2});
TopDocs topDocs = indexSearcher.search(query, 10, sort);

public final TokenStream tokenStream(final String fieldName, final Reader reader) {
    // 分词处理的组件，封装有供外部使用的TokenStream分词处理器。提供了对source(源)和sink(供外部使用分词处理器)两个属性的访问方法
	TokenStreamComponents components = reuseStrategy.getReusableComponents(this, fieldName);
    final Reader r = initReader(fieldName, reader);
    if (components == null) {
		// Analizer中唯一的抽象方法，扩展点，通过提供该方法的实现可以实现自己的Analyzer
		// fieldName：如果我们需要为不同的字段创建不同的分词处理器组件，则可根据这个参数来判断，否则就用不到这个参数
		components = createComponents(fieldName);
		reuseStrategy.setReusableComponents(this, fieldName, components);
    }
	// 最终给了Tokenizer(sink)的inputPending (source.setReader(reader))
    components.setReader(r);
	// 返回sink
    return components.getTokenStream();
}

// Tokenizer extends TokenStream
public TokenStreamComponents(final Tokenizer source, final TokenStream result) {
	this.source = source;
	this.sink = result;
}

String text = "春眠不觉晓，处处闻啼鸟";
Analyzer analyzer = new StandardAnalyzer();
testAnalyzer(analyzer, text);


public void testAnalyzer(Analyzer analyzer, String text) throws IOException {
	System.out.println("当前使用的分词器：" + analyzer.getClass().getSimpleName());
	// 获取真正的分词处理器，负责对输入文本完成分词、处理：域的名称，要分析的文本
	TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(text));
	// 存储分项属性，可以是关键词的引用，偏移量等等，重复调用add方法添加它返回已存储的实例对象
	// 加入的每一个Attribute实现类在AttributeSource中只会有一个实例，分词过程中，分项是重复使用这一实例来存放分项的属性信息
	CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
	// 进行重置，因为tokenStream是重复利用的
	tokenStream.reset();
	// 循环调用incrementToken方法，一个一个分词，直到它返回false
	while (tokenStream.incrementToken()) {
		// 要获取分项的某属性信息，则需持有某属性的实例对象，通过addAttribute方法或getAttribure方法获得Attribute对象，再调用实例的方法来获取、设置值
		System.out.println(new String(charTermAttribute.toString()));
	}
	// 执行任务需要的结束处理
	tokenStream.end();
	// 释放占有的资源
    tokenStream.close();
}