1、pom.xml

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>commons-io</groupId>
  4.     <artifactId>commons-io</artifactId>
  5.     <version>2.6</version>
  6.   </dependency>
  7.   <dependency>
  8.     <groupId>org.apache.lucene</groupId>
  9.     <artifactId>lucene-core</artifactId>
  10.     <version>7.7.2</version>
  11.   </dependency>
  12.   <dependency>
  13.     <groupId>org.apache.lucene</groupId>
  14.     <artifactId>lucene-analyzers-common</artifactId>
  15.     <version>7.7.2</version>
  16.   </dependency>
  17.   <dependency>
  18.     <groupId>org.apache.lucene</groupId>
  19.     <artifactId>lucene-queryparser</artifactId>
  20.     <version>7.7.2</version>
  21.   </dependency>
  23.   <!-- 测试 -->
  24.   <dependency>
  25.     <groupId>junit</groupId>
  26.     <artifactId>junit</artifactId>
  27.     <version>4.12</version>
  28.   </dependency>
  29.   <!-- mysql数据库驱动 -->
  30.   <dependency>
  31.     <groupId>mysql</groupId>
  32.     <artifactId>mysql-connector-java</artifactId>
  33.     <version>5.1.48</version>
  34.   </dependency>
  36.   <!-- IK中文分词器 -->
  37.   <!-- https://mvnrepository.com/artifact/com.github.magese/ik-analyzer -->
  38.   <dependency>
  39.     <groupId>com.github.magese</groupId>
  40.     <artifactId>ik-analyzer</artifactId>
  41.     <version>8.5.0</version>
  42.   </dependency>
  44. </dependencies>

2、索引操作

2.1、创建索引库

  1. @org.junit.Test
  2.     public void createIndexTest() throws Exception {
  3.         //1. 采集数据
  4.         SkuDao skuDao = new SkuDaoImpl();
  5.         List<Sku> skuList = skuDao.querySkuList();
  7.         //文档集合
  8.         List<Document> docList = new ArrayList<>();
  10.         for (Sku sku : skuList) {
  11.             //2. 创建文档对象
  12.             Document document = new Document();
  14.             //创建域对象并且放入文档对象中
  15.             /**
  16.              * 是否分词: 否, 因为主键分词后无意义
  17.              * 是否索引: 是, 如果根据id主键查询, 就必须索引
  18.              * 是否存储: 是, 因为主键id比较特殊, 可以确定唯一的一条数据, 在业务上一般有重要所用, 所以存储
  19.              *      存储后, 才可以获取到id具体的内容
  20.              */
  21.             document.add(new StringField("id", sku.getId(), Field.Store.YES));
  23.             /**
  24.              * 是否分词: 是, 因为名称字段需要查询, 并且分词后有意义所以需要分词
  25.              * 是否索引: 是, 因为需要根据名称字段查询
  26.              * 是否存储: 是, 因为页面需要展示商品名称, 所以需要存储
  27.              */
  28.             document.add(new TextField("name", sku.getName(), Field.Store.YES));
  30.             /**
  31.              * 是否分词: 是(因为lucene底层算法规定, 如果根据价格范围查询, 必须分词)
  32.              * 是否索引: 是, 需要根据价格进行范围查询, 所以必须索引
  33.              * 是否存储: 是, 因为页面需要展示价格
  34.              */
  35.             document.add(new IntPoint("price", sku.getPrice()));
  36.             document.add(new StoredField("price", sku.getPrice()));
  38.             /**
  39.              * 是否分词: 否, 因为不查询, 所以不索引, 因为不索引所以不分词
  40.              * 是否索引: 否, 因为不需要根据图片地址路径查询
  41.              * 是否存储: 是, 因为页面需要展示商品图片
  42.              */
  43.             document.add(new StoredField("image", sku.getImage()));
  45.             /**
  46.              * 是否分词: 否, 因为分类是专有名词, 是一个整体, 所以不分词
  47.              * 是否索引: 是, 因为需要根据分类查询
  48.              * 是否存储: 是, 因为页面需要展示分类
  49.              */
  50.             document.add(new StringField("categoryName", sku.getCategoryName(), Field.Store.YES));
  52.             /**
  53.              * 是否分词: 否, 因为品牌是专有名词, 是一个整体, 所以不分词
  54.              * 是否索引: 是, 因为需要根据品牌进行查询
  55.              * 是否存储: 是, 因为页面需要展示品牌
  56.              */
  57.             document.add(new StringField("brandName", sku.getBrandName(), Field.Store.YES));
  59.             //将文档对象放入到文档集合中
  60.             docList.add(document);
  61.         }
  62.         //3. 创建分词器, StandardAnalyzer标准分词器, 对英文分词效果好, 对中文是单字分词, 也就是一个字就认为是一个词.
  63.         Analyzer analyzer = new IKAnalyzer();
  64.         //4. 创建Directory目录对象, 目录对象表示索引库的位置
  65.         Directory dir = FSDirectory.open(Paths.get("D:\\dir"));
  66.         //5. 创建IndexWriterConfig对象, 这个对象中指定切分词使用的分词器
  67.         IndexWriterConfig config = new IndexWriterConfig(analyzer);
  68.         //6. 创建IndexWriter输出流对象, 指定输出的位置和使用的config初始化对象
  69.         IndexWriter indexWriter = new IndexWriter(dir, config);
  70.         //7. 写入文档到索引库
  71.         for (Document doc : docList) {
  72.             indexWriter.addDocument(doc);
  73.         }
  74.         //8. 释放资源
  75.         indexWriter.close();
  76.     }

2.2、索引库修改操作

  1.  @org.junit.Test
  2.     public void updateIndexTest() throws Exception {
  3.         //需要变更成的内容
  4.         Document document = new Document();
  6.         document.add(new StringField("id", "100000003145", Field.Store.YES));
  7.         document.add(new TextField("name", "xxxx", Field.Store.YES));
  8.         document.add(new IntPoint("price", 123));
  9.         document.add(new StoredField("price", 123));
  10.         document.add(new StoredField("image", "xxxx.jpg"));
  11.         document.add(new StringField("categoryName", "手机", Field.Store.YES));
  12.         document.add(new StringField("brandName", "华为", Field.Store.YES));
  15.         //3. 创建分词器, StandardAnalyzer标准分词器, 对英文分词效果好, 对中文是单字分词, 也就是一个字就认为是一个词.
  16.         Analyzer analyzer = new StandardAnalyzer();
  17.         //4. 创建Directory目录对象, 目录对象表示索引库的位置
  18.         Directory  dir = FSDirectory.open(Paths.get("D:\\dir"));
  19.         //5. 创建IndexWriterConfig对象, 这个对象中指定切分词使用的分词器
  20.         IndexWriterConfig config = new IndexWriterConfig(analyzer);
  21.         //6. 创建IndexWriter输出流对象, 指定输出的位置和使用的config初始化对象
  22.         IndexWriter indexWriter = new IndexWriter(dir, config);
  25.         //修改, 第一个参数: 修改条件, 第二个参数: 修改成的内容
  26.         indexWriter.updateDocument(new Term("id", "100000003145"), document);
  28.         //8. 释放资源
  29.         indexWriter.close();
  30.     }

2.3、测试根据条件删除

  1. @org.junit.Test
  2.     public void deleteIndexTest() throws Exception {
  3.         //3. 创建分词器, StandardAnalyzer标准分词器, 对英文分词效果好, 对中文是单字分词, 也就是一个字就认为是一个词.
  4.         Analyzer analyzer = new StandardAnalyzer();
  5.         //4. 创建Directory目录对象, 目录对象表示索引库的位置
  6.         Directory  dir = FSDirectory.open(Paths.get("D:\\dir"));
  7.         //5. 创建IndexWriterConfig对象, 这个对象中指定切分词使用的分词器
  8.         IndexWriterConfig config = new IndexWriterConfig(analyzer);
  9.         //6. 创建IndexWriter输出流对象, 指定输出的位置和使用的config初始化对象
  10.         IndexWriter indexWriter = new IndexWriter(dir, config);
  13.         //测试根据条件删除
  14.         //indexWriter.deleteDocuments(new Term("id", "100000003145"));
  16.         //测试删除所有内容
  17.         indexWriter.deleteAll();
  19.         //8. 释放资源
  20.         indexWriter.close();
  21.     }

2.4、测试创建索引速度优化

  1.  @org.junit.Test
  2.     public void createIndexTest2() throws Exception {
  3.         //1. 采集数据
  4.         SkuDao skuDao = new SkuDaoImpl();
  5.         List<Sku> skuList = skuDao.querySkuList();
  7.         //文档集合
  8.         List<Document> docList = new ArrayList<>();
  10.         for (Sku sku : skuList) {
  11.             //2. 创建文档对象
  12.             Document document = new Document();
  13.             document.add(new StringField("id", sku.getId(), Field.Store.YES));
  14.             document.add(new TextField("name", sku.getName(), Field.Store.YES));
  15.             document.add(new IntPoint("price", sku.getPrice()));
  16.             document.add(new StoredField("price", sku.getPrice()));
  17.             document.add(new StoredField("image", sku.getImage()));
  18.             document.add(new StringField("categoryName", sku.getCategoryName(), Field.Store.YES));
  19.             document.add(new StringField("brandName", sku.getBrandName(), Field.Store.YES));
  21.             //将文档对象放入到文档集合中
  22.             docList.add(document);
  23.         }
  25.         long start = System.currentTimeMillis();
  27.         //3. 创建分词器, StandardAnalyzer标准分词器, 对英文分词效果好, 对中文是单字分词, 也就是一个字就认为是一个词.
  28.         Analyzer analyzer = new StandardAnalyzer();
  29.         //4. 创建Directory目录对象, 目录对象表示索引库的位置
  30.         Directory  dir = FSDirectory.open(Paths.get("D:\\dir"));
  31.         //5. 创建IndexWriterConfig对象, 这个对象中指定切分词使用的分词器
  32.         /**
  33.          * 没有优化 小100万条数据, 创建索引需要7725ms
  34.          *
  35.          */
  36.         IndexWriterConfig config = new IndexWriterConfig(analyzer);
  37.         //设置在内存中多少个文档向磁盘中批量写入一次数据
  38.         //如果设置的数字过大, 会过多消耗内存, 但是会提升写入磁盘的速度
  39.         //config.setMaxBufferedDocs(500000);
  40.         //6. 创建IndexWriter输出流对象, 指定输出的位置和使用的config初始化对象
  41.         IndexWriter indexWriter = new IndexWriter(dir, config);
  42.         //设置多少给文档合并成一个段文件,数值越大索引速度越快, 搜索速度越慢;  值越小索引速度越慢, 搜索速度越快
  43.         //indexWriter.forceMerge(1000000);
  44.         //7. 写入文档到索引库
  45.         for (Document doc : docList) {
  46.             indexWriter.addDocument(doc);
  47.         }
  48.         //8. 释放资源
  49.         indexWriter.close();
  50.         long end = System.currentTimeMillis();
  51.         System.out.println("=====消耗的时间为:==========" + (end - start) + "ms");
  52.     }

3、高级搜索

3.1、关键字查询

  1.  @Test
  2.     public void testIndexSearch() throws Exception {
  4.         //1. 创建分词器(对搜索的关键词进行分词使用)
  5.         //注意: 分词器要和创建索引的时候使用的分词器一模一样
  6.         Analyzer analyzer = new StandardAnalyzer();
  8.         //2. 创建查询对象,
  9.         //第一个参数: 默认查询域, 如果查询的关键字中带搜索的域名, 则从指定域中查询, 如果不带域名则从, 默认搜索域中查询
  10.         //第二个参数: 使用的分词器
  11.         QueryParser queryParser = new QueryParser("name", analyzer);
  13.         //3. 设置搜索关键词
  14.         //华 OR  为   手   机
  15.         Query query = queryParser.parse("华为手机");
  17.         //4. 创建Directory目录对象, 指定索引库的位置
  18.         Directory dir = FSDirectory.open(Paths.get("D:\\dir"));
  19.         //5. 创建输入流对象
  20.         IndexReader indexReader = DirectoryReader.open(dir);
  21.         //6. 创建搜索对象
  22.         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
  23.         //7. 搜索, 并返回结果
  24.         //第二个参数: 是返回多少条数据用于展示, 分页使用
  25.         TopDocs topDocs = indexSearcher.search(query, 10);
  27.         //获取查询到的结果集的总数, 打印
  28.         System.out.println("=======count=======" + topDocs.totalHits);
  30.         //8. 获取结果集
  31.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  33.         //9. 遍历结果集
  34.         if (scoreDocs != null) {
  35.             for (ScoreDoc scoreDoc : scoreDocs) {
  36.                 //获取查询到的文档唯一标识, 文档id, 这个id是lucene在创建文档的时候自动分配的
  37.                 int  docID = scoreDoc.doc;
  38.                 //通过文档id, 读取文档
  39.                 Document doc = indexSearcher.doc(docID);
  40.                 System.out.println("==================================================");
  41.                 //通过域名, 从文档中获取域值
  42.                 System.out.println("===id==" + doc.get("id"));
  43.                 System.out.println("===name==" + doc.get("name"));
  44.                 System.out.println("===price==" + doc.get("price"));
  45.                 System.out.println("===image==" + doc.get("image"));
  46.                 System.out.println("===brandName==" + doc.get("brandName"));
  47.                 System.out.println("===categoryName==" + doc.get("categoryName"));
  49.             }
  50.         }
  51.         //10. 关闭流
  52.     }

3.2、数值范围查询

  1.  @Test
  2.     public void testRangeQuery() throws Exception {
  3.         //1. 创建分词器(对搜索的关键词进行分词使用)
  4.         //注意: 分词器要和创建索引的时候使用的分词器一模一样
  5.         Analyzer analyzer = new StandardAnalyzer();
  7.         //2. 创建查询对象,
  8.         Query query = IntPoint.newRangeQuery("price", 100, 1000);
  10.         //4. 创建Directory目录对象, 指定索引库的位置
  11.         Directory dir = FSDirectory.open(Paths.get("D:\\dir"));
  12.         //5. 创建输入流对象
  13.         IndexReader indexReader = DirectoryReader.open(dir);
  14.         //6. 创建搜索对象
  15.         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
  16.         //7. 搜索, 并返回结果
  17.         //第二个参数: 是返回多少条数据用于展示, 分页使用
  18.         TopDocs topDocs = indexSearcher.search(query, 10);
  20.         //获取查询到的结果集的总数, 打印
  21.         System.out.println("=======count=======" + topDocs.totalHits);
  23.         //8. 获取结果集
  24.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  26.         //9. 遍历结果集
  27.         if (scoreDocs != null) {
  28.             for (ScoreDoc scoreDoc : scoreDocs) {
  29.                 //获取查询到的文档唯一标识, 文档id, 这个id是lucene在创建文档的时候自动分配的
  30.                 int  docID = scoreDoc.doc;
  31.                 //通过文档id, 读取文档
  32.                 Document doc = indexSearcher.doc(docID);
  33.                 System.out.println("==================================================");
  34.                 //通过域名, 从文档中获取域值
  35.                 System.out.println("===id==" + doc.get("id"));
  36.                 System.out.println("===name==" + doc.get("name"));
  37.                 System.out.println("===price==" + doc.get("price"));
  38.                 System.out.println("===image==" + doc.get("image"));
  39.                 System.out.println("===brandName==" + doc.get("brandName"));
  40.                 System.out.println("===categoryName==" + doc.get("categoryName"));
  42.             }
  43.         }
  44.         //10. 关闭流
  45.     }

3.3、组合查询

  1.  @Test
  2.     public void testBooleanQuery() throws Exception {
  4.         //1. 创建分词器(对搜索的关键词进行分词使用)
  5.         //注意: 分词器要和创建索引的时候使用的分词器一模一样
  6.         Analyzer analyzer = new StandardAnalyzer();
  8.         //2. 创建查询对象,
  9.         Query query1 = IntPoint.newRangeQuery("price", 100, 1000);
  11.         QueryParser queryParser = new QueryParser("name", analyzer);
  12.         //3. 设置搜索关键词
  13.         //华 OR  为   手   机
  14.         Query query2 = queryParser.parse("华为手机");
  16.         //创建布尔查询对象(组合查询对象)
  17.         /**
  18.          *  BooleanClause.Occur.MUST 必须相当于and, 也就是并且的关系
  19.          *  BooleanClause.Occur.SHOULD 应该相当于or, 也就是或者的关系
  20.          *  BooleanClause.Occur.MUST_NOT 不必须, 相当于not, 非
  21.          *  注意: 如果查询条件都是MUST_NOT, 或者只有一个查询条件, 然后这一个查询条件是MUST_NOT则
  22.          *  查询不出任何数据.
  23.          */
  24.         BooleanQuery.Builder query = new BooleanQuery.Builder();
  25.         query.add(query1, BooleanClause.Occur.MUST);
  26.         query.add(query2, BooleanClause.Occur.MUST);
  29.         //4. 创建Directory目录对象, 指定索引库的位置
  30.         Directory dir = FSDirectory.open(Paths.get("D:\\dir"));
  31.         //5. 创建输入流对象
  32.         IndexReader indexReader = DirectoryReader.open(dir);
  33.         //6. 创建搜索对象
  34.         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
  35.         //7. 搜索, 并返回结果
  36.         //第二个参数: 是返回多少条数据用于展示, 分页使用
  37.         TopDocs topDocs = indexSearcher.search(query.build(), 10);
  39.         //获取查询到的结果集的总数, 打印
  40.         System.out.println("=======count=======" + topDocs.totalHits);
  42.         //8. 获取结果集
  43.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  46.         //9. 遍历结果集
  47.         if (scoreDocs != null) {
  48.             for (ScoreDoc scoreDoc : scoreDocs) {
  49.                 //获取查询到的文档唯一标识, 文档id, 这个id是lucene在创建文档的时候自动分配的
  50.                 int  docID = scoreDoc.doc;
  51.                 //通过文档id, 读取文档
  52.                 Document doc = indexSearcher.doc(docID);
  53.                 System.out.println("==================================================");
  54.                 //通过域名, 从文档中获取域值
  55.                 System.out.println("===id==" + doc.get("id"));
  56.                 System.out.println("===name==" + doc.get("name"));
  57.                 System.out.println("===price==" + doc.get("price"));
  58.                 System.out.println("===image==" + doc.get("image"));
  59.                 System.out.println("===brandName==" + doc.get("brandName"));
  60.                 System.out.println("===categoryName==" + doc.get("categoryName"));
  62.             }
  63.         }
  64.         //10. 关闭流
  65.     }

3.4、测试相关度排序

  1. @Test
  2.     public void testIndexSearch2() throws Exception {
  4.         //1. 创建分词器(对搜索的关键词进行分词使用)
  5.         //注意: 分词器要和创建索引的时候使用的分词器一模一样
  6.         Analyzer analyzer = new IKAnalyzer();
  8.         //需求: 不管是名称域还是品牌域或者是分类域有关于手机关键字的查询出来
  9.         //查询的多个域名
  10.         String[] fields = {"name", "categoryName", "brandName"};
  12.         //设置影响排序的权重, 这里设置域的权重
  13.         Map<String, Float> boots = new HashMap<>();
  14.         boots.put("categoryName", 10000000000f);
  16.         //从多个域查询对象
  17.         MultiFieldQueryParser multiFieldQueryParser = new MultiFieldQueryParser(fields, analyzer, boots);
  18.         //设置查询的关键词
  19.         Query query = multiFieldQueryParser.parse("手机");
  21.         //4. 创建Directory目录对象, 指定索引库的位置
  22.         Directory dir = FSDirectory.open(Paths.get("D:\\dir"));
  23.         //5. 创建输入流对象
  24.         IndexReader indexReader = DirectoryReader.open(dir);
  25.         //6. 创建搜索对象
  26.         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
  27.         //7. 搜索, 并返回结果
  28.         //第二个参数: 是返回多少条数据用于展示, 分页使用
  29.         TopDocs topDocs = indexSearcher.search(query, 10);
  31.         //获取查询到的结果集的总数, 打印
  32.         System.out.println("=======count=======" + topDocs.totalHits);
  34.         //8. 获取结果集
  35.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  37.         //9. 遍历结果集
  38.         if (scoreDocs != null) {
  39.             for (ScoreDoc scoreDoc : scoreDocs) {
  40.                 //获取查询到的文档唯一标识, 文档id, 这个id是lucene在创建文档的时候自动分配的
  41.                 int  docID = scoreDoc.doc;
  42.                 //通过文档id, 读取文档
  43.                 Document doc = indexSearcher.doc(docID);
  44.                 System.out.println("==================================================");
  45.                 //通过域名, 从文档中获取域值
  46.                 System.out.println("===id==" + doc.get("id"));
  47.                 System.out.println("===name==" + doc.get("name"));
  48.                 System.out.println("===price==" + doc.get("price"));
  49.                 System.out.println("===image==" + doc.get("image"));
  50.                 System.out.println("===brandName==" + doc.get("brandName"));
  51.                 System.out.println("===categoryName==" + doc.get("categoryName"));
  53.             }
  54.         }
  55.         //10. 关闭流
  56.     }