day65_Lucene学习笔记

drop table if exists book;

create table book
(
   id                     int(11) not null,
   name                 varchar(192),
   privce               double,
   pic                   varchar(96),
   description          text,
   primary key (id)
);

package com.itheima.lucene.po;

public class Book {
    // 图书ID
    private Integer id;
    // 图书名称
    private String name;
    // 图书价格
    private Float price;
    // 图书图片
    private String pic;
    // 图书描述
    private String description;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Float getPrice() {
        return price;
    }
    public void setPrice(Float price) {
        this.price = price;
    }
    public String getPic() {
        return pic;
    }
    public void setPic(String pic) {
        this.pic = pic;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

public interface BookDao {
    // 图书查询
    public List<Book> queryBookList();
}

public class BookDaoImpl implements BookDao {

    @Override
    public List<Book> queryBookList()  {
        // 数据库连接
        Connection connection = null;

        // 预编译statement
        PreparedStatement preparedStatement = null;

        // 结果集
        ResultSet resultSet = null;

        // 图书列表
        List<Book> list = new ArrayList<Book>();

        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 连接数据库
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/solr", "root", "root");

            // SQL语句
            String sql = "SELECT * FROM book";
            // 创建preparedStatement
            preparedStatement = connection.prepareStatement(sql);

            // 获取结果集
            resultSet = preparedStatement.executeQuery();

            // 结果集解析
            while (resultSet.next()) {
                Book book = new Book();
                book.setId(resultSet.getInt("id"));
                book.setName(resultSet.getString("name"));
                book.setPrice(resultSet.getFloat("price"));
                book.setPic(resultSet.getString("pic"));
                book.setDescription(resultSet.getString("description"));
                list.add(book);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return list;
    }

@Override
  protected TokenStreamComponents createComponents(final String fieldName, final Reader reader) {
    final StandardTokenizer src = new StandardTokenizer(getVersion(), reader);
    src.setMaxTokenLength(maxTokenLength);
    TokenStream tok = new StandardFilter(getVersion(), src);
    tok = new LowerCaseFilter(getVersion(), tok);
    tok = new StopFilter(getVersion(), tok, stopwords);
    return new TokenStreamComponents(src, tok) {
      @Override
      protected void setReader(final Reader reader) throws IOException {
        src.setMaxTokenLength(StandardAnalyzer.this.maxTokenLength);
        super.setReader(reader);
      }
    };
  }

/**
 * 将采集到的数据list集合封装到Document对象中，创建索引库库
 * @author Bruce
 *
 */
public class IndexManager {
    /**
     * 创建索引
     * @throws Exception
     */
    @Test
    public void createIndex() throws Exception {
        // 1、采集数据
        BookDao dao = new BookDaoImpl();
        List<Book> list = dao.queryBookList();

        // 2、将采集到的数据list封装到Document对象中
        // 先创建Document对象集合
        List<Document> docList = new ArrayList<>();
        Document document = null; // 开发时建议这么做，因为这样每次地址指向是同一片内存，省内存
        for (Book book : list) {
            // 创建Document对象，同时要创建field对象
            document = new Document();
            Field id = new TextField("id", book.getId().toString(), Store.YES);
            Field name = new TextField("name", book.getName(), Store.YES);
            Field price = new TextField("price", book.getPrice().toString(), Store.YES);
            Field pic = new TextField("pic", book.getPic(), Store.YES);
            Field description = new TextField("description", book.getDescription(), Store.YES);

            // 把域（Field）添加到文档（Document）中
            document.add(id);
            document.add(name);
            document.add(price);
            document.add(pic);
            document.add(description);

            docList.add(document);
        }

        // 3、创建分词器对象：标准分词器
        Analyzer analyzer = new StandardAnalyzer();

        // 4、创建索引写对象：IndexWriter
        // 指定索引库的地址
        File indexFile = new File("E:\\index\\hm19");
        // 创建索引目录流对象：Directory
        Directory directory = FSDirectory.open(indexFile);
        IndexWriterConfig cfg = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
        IndexWriter indexWriter = new IndexWriter(directory, cfg);

        // 5、通过索引写对象：IndexWriter，将Document写入到索引库中
        for (Document doc : docList) {
            indexWriter.addDocument(doc);
        }

        // 6、关闭索引写对象：IndexWriter
        indexWriter.close();
    }
}

/**
 * 搜索索引
 * @author Bruce
 *
 */
public class IndexSearch {
    @Test
    public void searchIndex() throws Exception {
        // 1、 创建查询对象（Query对象）
        // 使用QueryParser搜索时，需要指定分词器，搜索索引时使用的分词器要和创建索引时使用的分词器一致
        // 创建分析器对象
        Analyzer analyzer = new StandardAnalyzer();
        QueryParser queryParser = new QueryParser("description", analyzer); // 第一个参数：是默认搜索的域的名称
        // 通过QueryParser来创建Query对象
        Query query = queryParser.parse("description:java AND spring"); // 参数：输入的是lucene的查询语句(注意：关键字一定要大写)

        // 2、创建IndexSearcher（索引搜索对象）
        File indexFile = new File("E:\\index\\hm19\\");
        Directory directory = FSDirectory.open(indexFile);
        IndexReader indexReader = DirectoryReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader );

        // 3、通过IndexSearcher（索引搜索对象）来搜索索引库
        TopDocs topDocs = indexSearcher.search(query, 10); // 第二个参数：指定需要显示的顶部记录的N条
        int totalHits = topDocs.totalHits; // 根据查询条件匹配出的记录总数
        System.out.println("匹配出的记录总数:" + totalHits);

        ScoreDoc[] scoreDocs = topDocs.scoreDocs;// 根据查询条件匹配出的记录
        for (ScoreDoc scoreDoc : scoreDocs) {
            int docId = scoreDoc.doc; // 获取文档的ID
            Document document = indexSearcher.doc(docId); // 通过ID获取文档

            System.out.println("商品ID：" + document.get("id"));
            System.out.println("商品名称：" + document.get("name"));
            System.out.println("商品价格：" + document.get("price"));
            System.out.println("商品图片地址：" + document.get("pic"));
            System.out.println("商品描述：" + document.get("description"));
        }

        // 关闭IndexReader
        indexReader.close();
    }
}

图书id：
    是否分词：不分词。
    是否索引：要索引，因为需要根据图书id进行搜索。
    是否存储：要存储，因为查询结果页面需要使用id这个值。

图书名称：
    是否分词：要分词，因为要将图书的名称内容分词索引，根据关键搜索图书名称抽取的词。
    是否索引：要索引。
    是否存储：要存储。

图书价格：
    是否分词：要分词，`lucene对数字型的值只要有搜索需求的都要分词和索引`，因为`lucene对数字型的内容要特殊分词处`理，本例子可能要根据价格范围搜索，需要分词和索引。
    是否索引：要索引。
    是否存储：要存储。

图书图片地址：
    是否分词：不分词。
    是否索引：不索引。
    是否存储：要存储。

图书描述：
    是否分词：要分词。
    是否索引：要索引。
    是否存储：不存储，因为图书描述内容量大，不在查询结果页面直接显示。

`不存储是用来不在lucene的索引文件中记录`，`节省lucene的索引文件空间`，如果要在详情页面显示描述：
思路：从lucene中取出图书的id，根据图书的id查询关系数据库中book表得到描述信息。

    /**
     * 删除指定索引
     * @throws Exception
     */
    @Test
    public void deleteIndex() throws Exception {
        // 4、创建索引写对象：IndexWriter
        // 指定索引库的地址
        File indexFile = new File("E:\\index\\hm19");
        // 创建索引目录流对象：Directory
        Directory directory = FSDirectory.open(indexFile);
        IndexWriterConfig cfg = new IndexWriterConfig(Version.LUCENE_4_10_3, new StandardAnalyzer());
        IndexWriter indexWriter = new IndexWriter(directory, cfg);

        // 通过IndexWriter来删除指定索引
        indexWriter.deleteDocuments(new Term("id", "1"));

        // 关闭索引写对象：IndexWriter
        indexWriter.close();
    }

    /**
     * 删除全部索引（慎用）
     * @throws Exception
     */
    @Test
    public void deleteAllIndex() throws Exception {
        // 4、创建索引写对象：IndexWriter
        // 指定索引库的地址
        File indexFile = new File("E:\\index\\hm19");
        // 创建索引目录流对象：Directory
        Directory directory = FSDirectory.open(indexFile);
        IndexWriterConfig cfg = new IndexWriterConfig(Version.LUCENE_4_10_3, new StandardAnalyzer());
        IndexWriter indexWriter = new IndexWriter(directory, cfg);

        // 通过IndexWriter来删除全部索引（慎用）
        indexWriter.deleteAll();;

        // 关闭索引写对象：IndexWriter
        indexWriter.close();
    }

    /**
     * 修改索引
     * @throws Exception
     */
    @Test
    public void updateIndex() throws Exception {
        // 4、创建索引写对象：IndexWriter
        // 指定索引库的地址
        File indexFile = new File("E:\\index\\hm19");
        // 创建索引目录流对象：Directory
        Directory directory = FSDirectory.open(indexFile);
        IndexWriterConfig cfg = new IndexWriterConfig(Version.LUCENE_4_10_3, new StandardAnalyzer());
        IndexWriter indexWriter = new IndexWriter(directory, cfg);

        // 创建修改后的文档对象
        Document document = new Document();
        Field name = new TextField("name", "黑泽", Store.YES); // 文件名称
        document.add(name);

        // 通过IndexWriter来修改索引
        // 第一个参数：指定的查询条件
        // 第二个参数：修改之后的对象
        // 修改时如果根据查询条件，可以查询出结果，则将以前的删掉，然后覆盖新的Document对象，如果没有查询出结果，则新增一个Document
        // 修改流程即：先查询，再删除，再添加
        indexWriter.updateDocument(new Term("name", "晓艺"), document);

        // 关闭索引写对象：IndexWriter
        indexWriter.close();
    }

1）使用Lucene提供的Query子类，不能输入lucene的查询语法，不需要指定分词器
    Query是一个抽象类，lucene提供了很多查询对象，比如：TermQuery精确词项查询、NumericRangeQuery数字范围查询、BooleanQuery布尔查询(实现组合查询)等。
    如下代码：
    Query query = new TermQuery(new Term("name", "lucene"));

2）使用QueryParse解析查询表达式（常用）、MultiFieldQueryParser多域查询，可以输入lucene的查询语法、需要指定分词器
    QueryParser会将用户输入的查询表达式解析成Query对象实例。
    如下代码：
    QueryParser queryParser = new QueryParser("name", new IKAnalyzer());
    Query query = queryParser.parse("name:lucene");

/**
 * 搜索索引
 * @author Bruce
 *
 */
public class IndexSearch {

    /**
     * 优化代码，抽取成通用搜索方法
     * @param query
     */
    private void doSearch(Query query) {
        IndexReader indexReader = null; // 好的编程习惯
        try {
            // 2、创建IndexSearcher（索引搜索对象）
            File indexFile = new File("E:\\index\\hm19\\");
            Directory directory = FSDirectory.open(indexFile);
            indexReader = DirectoryReader.open(directory);
            IndexSearcher indexSearcher = new IndexSearcher(indexReader );

            // 3、通过IndexSearcher（索引搜索对象）来搜索索引库
            TopDocs topDocs = indexSearcher.search(query, 10); // 第二个参数：指定需要显示的顶部记录的N条
            int totalHits = topDocs.totalHits; // 根据查询条件匹配出的记录总数
            System.out.println("匹配出的记录总数:" + totalHits);

            ScoreDoc[] scoreDocs = topDocs.scoreDocs;// 根据查询条件匹配出的记录
            Document document; // 好的编程习惯
            for (ScoreDoc scoreDoc : scoreDocs) {
                int docId = scoreDoc.doc; // 获取文档的ID
                document = indexSearcher.doc(docId); // 通过ID获取文档

                System.out.println("商品ID：" + document.get("id"));
                System.out.println("商品名称：" + document.get("name"));
                System.out.println("商品价格：" + document.get("price"));
                System.out.println("商品图片地址：" + document.get("pic"));
                System.out.println("商品描述：" + document.get("description"));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (indexReader != null) { // 好的编程习惯
                try { // 好的编程习惯
                    // 关闭IndexReader
                    indexReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 使用QueryParse解析查询表达式（常用），可以输入lucene的查询语法、需要指定分词器
     * @throws Exception
     */
    @Test
    public void searchIndex() throws Exception {
        // 1、 创建查询对象（Query对象）
        // 使用QueryParser搜索时，需要指定分词器，搜索索引时使用的分词器要和创建索引时使用的分词器一致
        // 创建分析器对象
        Analyzer analyzer = new StandardAnalyzer();
        QueryParser queryParser = new QueryParser("description", analyzer); // 第一个参数：是默认搜索的域的名称
        // 通过QueryParser来创建Query对象
        Query query = queryParser.parse("description:java AND spring"); // 参数：输入的是lucene的查询语句(注意：关键字一定要大写)

        // 这里优化代码，抽取成通用搜索方法了

        // 执行搜索
        doSearch(query);
    }

    /**
     * TermQuery 精确项查询，TermQuery 不需要指定分析器
     */
    @Test
    public void testTermQuery() {
        // 1、 创建查询对象（Query对象）
        Query query = new TermQuery(new Term("description", "java"));
        // 2、执行搜索
        doSearch(query);
    }
}

    /**
     * NumericRangeQuery 指定数字范围查询，NumericRangeQuery不使用指定分析器
     */
    @Test
    public void testNumericRangeQuery() {
        // 1、 创建查询对象（NumericRangeQuery对象）
        // 第一个参数：域名
        // 第二个参数：最小值
        // 第三个参数：最大值
        // 第四个参数：是否包含最小值
        // 第五个参数：是否包含最大值
        Query query = NumericRangeQuery.newFloatRange("price",50f, 70f, true, true);
        // 2、执行搜索
        doSearch(query);
    }

    /**
     * BooleanQuery 布尔查询，实现组合条件查询。BooleanQuery不使用指定分析器
     */
    @Test
    public void testBooleanQuery() {
        // 1、 创建查询对象（BooleanQuery对象）
        BooleanQuery query = new BooleanQuery();
        Query query1 = new TermQuery(new Term("description", "java"));
        Query query2 = NumericRangeQuery.newFloatRange("price", 50f, 70f, true, true);

        // MUST：查询条件必须满足，相当于AND
        // SHOULD:查询条件可选，相当于OR
        // MUST_NOT：查询条件不能满足，相当于NOT非
        // 组合关系代表的意思如下:
        //  1、MUST和MUST 表示“与”的关系，即“交集”。
        //  2、MUST和MUST_NOT 前者包含后者不包含。
        //  3、MUST_NOT和MUST_NOT 没意义。
        //  4、SHOULD和MUST 表示MUST，SHOULD失去意义。
        //  5、SHOUlD和MUST_NOT 相当于MUST与MUST_NOT。
        //  6、SHOULD和SHOULD 表示“或”的关系，即“并集”。
        query.add(query1, Occur.MUST);
        query.add(query2, Occur.SHOULD);
        System.out.println(query);

        // 2、执行搜索
        doSearch(query);
    }

    /**
     * 使用QueryParse解析查询表达式（常用），可以输入lucene的查询语法、需要指定分词器
     * @throws Exception
     */
    @Test
    public void searchIndex() throws Exception {
        // 1、 创建查询对象（Query对象）
        // 使用QueryParser搜索时，需要指定分词器，搜索索引时使用的分词器要和创建索引时使用的分词器一致
        // 创建分析器对象
        Analyzer analyzer = new StandardAnalyzer();
        QueryParser queryParser = new QueryParser("description", analyzer); // 第一个参数：是默认搜索的域的名称
        // 通过QueryParser来创建Query对象
        Query query = queryParser.parse("description:java AND spring"); // 参数：输入的是lucene的查询语句(注意：关键字一定要大写)

        // 这里优化代码，抽取成通用搜索方法了

        // 执行搜索
        doSearch(query);
    }

    /**
     * 使用MultiFieldQueryParser 多域查询，解析查询表达式，可以输入lucene的查询语法、需要指定分词器
     * @throws Exception
     */
    @Test
    public void testMultiFieldQueryParser() throws Exception {
        // 1、 创建查询对象（MultiFieldQueryParser对象）
        // 可以指定默认搜索的域是多个
        String[] fields = {"name", "description"}; // 或的关系：两个条件满足其一即可。
        // 创建分析器对象
        Analyzer analyzer = new StandardAnalyzer();
        // 创建一个MulitFiledQueryParser对象
        QueryParser queryParser = new MultiFieldQueryParser(fields, analyzer);
        Query query = queryParser.parse("java");
        System.out.println(query);

        // 执行搜索
        doSearch(query);
    }

1、基础的查询语法，关键词查询：
    域名+":"+搜索的关键字
    例如：description:java
2、范围查询
    域名+":"+[最小值 TO 最大值]
    例如：price:[1 TO 1000]
    `注意`：QueryParser不支持对数字范围的搜索，它支持字符串范围。
            数字范围搜索建议使用NumericRangeQuery。
3、组合条件查询
第一种写法：
    Occur.MUST          查询条件必须满足，相当于and         +（加号）
    Occur.SHOULD        查询条件可选，相当于or              空（不用符号）
    Occur.MUST_NOT      查询条件不能满足，相当于not非       -（减号）
    1）+条件1 +条件2：两个条件之间是并且的关系and
        例如：+name:java +description:java
    2）+条件1 条件2：必须满足第一个条件，忽略第二个条件
        例如：+name:java description:java
    3）条件1 条件2：两个条件满足其一即可。
        例如：name:java description:java
    4）-条件1 条件2：必须不满足条件1，要满足条件2
        例如：-name:java description:java
第二种写法：
    条件1 AND 条件2
    条件1 OR 条件2
    条件1 NOT 条件2

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">  
<properties>  

    <comment>IK Analyzer 扩展配置</comment>
    <!-- 用户可以在这里配置自己的扩展字典 -->
     <entry key="ext_dict">dicdata/mydict.dic</entry> 
     <!-- 用户可以在这里配置自己的扩展停用词字典 -->
    <entry key="ext_stopwords">dicdata/ext_stopword.dic</entry> 
</properties>