lucene&solr 基础使用

傷城~ 2021-11-10 08:00 317阅读 0赞

lucene和solr：官网下载地址http://lucene.apache.org/

一般网站用solr比较多，但是想要了解solr的用法，我们需要首先了解一下lucene的使用方法。因为solr底层使用lucene开发的。

lucene

全文检索：
将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对快的目的。这部分从
非结构化数据中提取出的，然后重新组织的信息，我们称之为索引。
这种先建立索引，再对索引进行搜索的过程就叫做全文检索。

lucene实现全文检索的流程：
创建索引：
获取文档：通过io操作获取磁盘文档。
创建文档：
文档对象：每一个字段（属性）就是一个域
分析文档：
将一段原始内容分析后得到语汇单元。
每一个单词是一个Term，不同域中的相同单词，不是同一个Term。Term是一个map结构。
创建索引：
在索引库中保存了两个部分。1、索引 2、文档对象 

  1. 查询索引：  
  2.     用户查询入口  
  3.     创建查询  
  4.     执行查询  
  5.     渲染结果

lucene全文检索流程

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ROVF9E_size_16_color_FFFFFF_t_70

要是用lucene，首先要在项目中导入常用的jar包。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ROVF9E_size_16_color_FFFFFF_t_70 1

Lucene 入门 创建索引 查询索引

  1. /**
  2.  * Lucene 入门 创建索引 查询索引
  3.  * 
  4.  * @author lx
  5.  *
  6.  */
  7. public class FirstLucene {
  9.     // 创建索引
  10.     @Test
  11.     public void testIndex() throws Exception {
  12.         // 第一步：创建一个java工程，并导入jar包。
  13.         // 第二步：创建一个indexwriter对象。
  14.         Directory directory = FSDirectory.open(new File("D:\\temp\\index"));
  15.         // Directory directory = new RAMDirectory();//保存索引到内存中 （内存索引库）
  16. //        Analyzer analyzer = new StandardAnalyzer();// 官方推荐
  17.         Analyzer analyzer = new IKAnalyzer();// 官方推荐
  18.         IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, analyzer);
  19.         IndexWriter indexWriter = new IndexWriter(directory, config);
  20.         // 1）指定索引库的存放位置Directory对象
  21.         // 2）指定一个分析器，对文档内容进行分析。
  22.         // 第三步：创建field对象，将field添加到document对象中。
  23.         File f = new File("D:\\Lucene&solr\\searchsource");
  24.         File[] listFiles = f.listFiles();
  25.         for (File file : listFiles) {
  26.             // 第三步：创建document对象。
  27.             Document document = new Document();
  28.             // 文件名称
  29.             String file_name = file.getName();
  30.             Field fileNameField = new TextField("fileName", file_name, Store.YES);
  31.             // 文件大小
  32.             long file_size = FileUtils.sizeOf(file);
  33.             Field fileSizeField = new LongField("fileSize", file_size, Store.YES);
  34.             // 文件路径
  35.             String file_path = file.getPath();
  36.             Field filePathField = new StoredField("filePath", file_path);
  37.             // 文件内容
  38.             String file_content = FileUtils.readFileToString(file);
  39.             Field fileContentField = new TextField("fileContent", file_content, Store.NO);
  41.             document.add(fileNameField);
  42.             document.add(fileSizeField);
  43.             document.add(filePathField);
  44.             document.add(fileContentField);
  45.             // 第四步：使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写入索引库。
  46.             indexWriter.addDocument(document);
  48.         }
  49.         // 第五步：关闭IndexWriter对象。
  50.         indexWriter.close();
  51.     }
  53.     // 搜索索引
  54.     @Test
  55.     public void testSearch() throws Exception {
  56.         // 第一步：创建一个Directory对象，也就是索引库存放的位置。
  57.         Directory directory = FSDirectory.open(new File("D:\\temp\\index"));// 磁盘
  58.         // 第二步：创建一个indexReader对象，需要指定Directory对象。
  59.         IndexReader indexReader = DirectoryReader.open(directory);
  60.         // 第三步：创建一个indexsearcher对象，需要指定IndexReader对象
  61.         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
  62.         // 第四步：创建一个TermQuery对象，指定查询的域和查询的关键词。
  63.         Query query = new TermQuery(new Term("fileName", "lucene"));
  64.         // 第五步：执行查询。
  65.         TopDocs topDocs = indexSearcher.search(query, 10);
  66.         // 第六步：返回查询结果。遍历查询结果并输出。
  67.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  68.         for (ScoreDoc scoreDoc : scoreDocs) {
  69.             int doc = scoreDoc.doc;
  70.             Document document = indexSearcher.doc(doc);
  71.             // 文件名称
  72.             String fileName = document.get("fileName");
  73.             System.out.println(fileName);
  74.             // 文件内容
  75.             String fileContent = document.get("fileContent");
  76.             System.out.println(fileContent);
  77.             // 文件大小
  78.             String fileSize = document.get("fileSize");
  79.             System.out.println(fileSize);
  80.             // 文件路径
  81.             String filePath = document.get("filePath");
  82.             System.out.println(filePath);
  83.             System.out.println("------------");
  84.         }
  85.         // 第七步：关闭IndexReader对象
  86.         indexReader.close();
  88.     }
  90.     // 查看标准分析器的分词效果
  91.     @Test
  92.     public void testTokenStream() throws Exception {
  93.         // 创建一个标准分析器对象
  94. //        Analyzer analyzer = new StandardAnalyzer();
  95. //        Analyzer analyzer = new CJKAnalyzer();
  96. //        Analyzer analyzer = new SmartChineseAnalyzer();
  97.         Analyzer analyzer = new IKAnalyzer();
  98.         // 获得tokenStream对象
  99.         // 第一个参数：域名，可以随便给一个
  100.         // 第二个参数：要分析的文本内容
  101. //        TokenStream tokenStream = analyzer.tokenStream("test",
  102. //                "The Spring Framework provides a comprehensive programming and configuration model.");
  103.         TokenStream tokenStream = analyzer.tokenStream("test",
  104.                 "高富帅可以用二维表结构来逻辑表达实现的数据");
  105.         // 添加一个引用，可以获得每个关键词
  106.         CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
  107.         // 添加一个偏移量的引用，记录了关键词的开始位置以及结束位置
  108.         OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
  109.         // 将指针调整到列表的头部
  110.         tokenStream.reset();
  111.         // 遍历关键词列表，通过incrementToken方法判断列表是否结束
  112.         while (tokenStream.incrementToken()) {
  113.             // 关键词的起始位置
  114.             System.out.println("start->" + offsetAttribute.startOffset());
  115.             // 取关键词
  116.             System.out.println(charTermAttribute);
  117.             // 结束位置
  118.             System.out.println("end->" + offsetAttribute.endOffset());
  119.         }
  120.         tokenStream.close();
  121.     }
  123. }

lucene索引维护，其实也就是索引的增、删、改、查。

  1. /**
  2.  * 索引维护
  3.  * 添加  入门程序
  4.  * 删除
  5.  * 修改
  6.  * 查询  入门程序 精准查询 
  7.  * @author lx
  8.  *
  9.  */
  10. public class LuceneManager {
  12.     //
  13.     public IndexWriter getIndexWriter() throws Exception{
  14.         // 第一步：创建一个java工程，并导入jar包。
  15.         // 第二步：创建一个indexwriter对象。
  16.         Directory directory = FSDirectory.open(new File("D:\\temp\\index"));
  17.         // Directory directory = new RAMDirectory();//保存索引到内存中 （内存索引库）
  18.         Analyzer analyzer = new StandardAnalyzer();// 官方推荐
  19.         IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, analyzer);
  20.         return new IndexWriter(directory, config);
  21.     }
  22.     //全删除
  23.     @Test
  24.     public void testAllDelete() throws Exception {
  25.         IndexWriter indexWriter = getIndexWriter();
  26.         indexWriter.deleteAll();
  27.         indexWriter.close();
  28.     }
  29.     //根据条件删除
  30.     @Test
  31.     public void testDelete() throws Exception {
  32.         IndexWriter indexWriter = getIndexWriter();
  33.         Query query = new TermQuery(new Term("fileName","apache"));
  34.         indexWriter.deleteDocuments(query);
  35.         indexWriter.close();
  36.     }
  37.     //修改
  38.     @Test
  39.     public void testUpdate() throws Exception {
  40.         IndexWriter indexWriter = getIndexWriter();
  41.         Document doc = new Document();
  42.         doc.add(new TextField("fileN", "测试文件名",Store.YES));
  43.         doc.add(new TextField("fileC", "测试文件内容",Store.YES));
  44.         indexWriter.updateDocument(new Term("fileName","lucene"), doc, new IKAnalyzer());
  45.         indexWriter.close();
  46.     }
  47.     //IndexReader  IndexSearcher
  48.     public IndexSearcher getIndexSearcher() throws Exception{
  49.         // 第一步：创建一个Directory对象，也就是索引库存放的位置。
  50.         Directory directory = FSDirectory.open(new File("D:\\temp\\index"));// 磁盘
  51.         // 第二步：创建一个indexReader对象，需要指定Directory对象。
  52.         IndexReader indexReader = DirectoryReader.open(directory);
  53.         // 第三步：创建一个indexsearcher对象，需要指定IndexReader对象
  54.         return new IndexSearcher(indexReader);
  55.     }
  56.     //执行查询的结果
  57.     public void printResult(IndexSearcher indexSearcher,Query query)throws Exception{
  58.         // 第五步：执行查询。
  59.         TopDocs topDocs = indexSearcher.search(query, 10);
  60.         // 第六步：返回查询结果。遍历查询结果并输出。
  61.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  62.         for (ScoreDoc scoreDoc : scoreDocs) {
  63.             int doc = scoreDoc.doc;
  64.             Document document = indexSearcher.doc(doc);
  65.             // 文件名称
  66.             String fileName = document.get("fileName");
  67.             System.out.println(fileName);
  68.             // 文件内容
  69.             String fileContent = document.get("fileContent");
  70.             System.out.println(fileContent);
  71.             // 文件大小
  72.             String fileSize = document.get("fileSize");
  73.             System.out.println(fileSize);
  74.             // 文件路径
  75.             String filePath = document.get("filePath");
  76.             System.out.println(filePath);
  77.             System.out.println("------------");
  78.         }
  79.     }
  80.     //查询所有
  81.     @Test
  82.     public void testMatchAllDocsQuery() throws Exception {
  83.         IndexSearcher indexSearcher = getIndexSearcher();
  84.         Query query = new MatchAllDocsQuery();
  85.         System.out.println(query);
  86.         printResult(indexSearcher, query);
  87.         //关闭资源
  88.         indexSearcher.getIndexReader().close();
  89.     }
  90.     //根据数值范围查询
  91.     @Test
  92.     public void testNumericRangeQuery() throws Exception {
  93.         IndexSearcher indexSearcher = getIndexSearcher();
  95.         Query query = NumericRangeQuery.newLongRange("fileSize", 47L, 200L, false, true);
  96.         System.out.println(query);
  97.         printResult(indexSearcher, query);
  98.         //关闭资源
  99.         indexSearcher.getIndexReader().close();
  100.     }
  101.     //可以组合查询条件
  102.     @Test
  103.     public void testBooleanQuery() throws Exception {
  104.         IndexSearcher indexSearcher = getIndexSearcher();
  106.         BooleanQuery booleanQuery = new BooleanQuery();
  108.         Query query1 = new TermQuery(new Term("fileName","apache"));
  109.         Query query2 = new TermQuery(new Term("fileName","lucene"));
  110.         //  select * from user where id =1 or name = 'safdsa'
  111.         booleanQuery.add(query1, Occur.MUST);
  112.         booleanQuery.add(query2, Occur.SHOULD);
  113.         System.out.println(booleanQuery);
  114.         printResult(indexSearcher, booleanQuery);
  115.         //关闭资源
  116.         indexSearcher.getIndexReader().close();
  117.     }
  118.     //条件解释的对象查询
  119.     @Test
  120.     public void testQueryParser() throws Exception {
  121.         IndexSearcher indexSearcher = getIndexSearcher();
  122.         //参数1： 默认查询的域  
  123.         //参数2：采用的分析器
  124.         QueryParser queryParser = new QueryParser("fileName",new IKAnalyzer());
  125.         // *:*   域：值
  126.         Query query = queryParser.parse("fileName:lucene is apache OR fileContent:lucene is apache");
  128.         printResult(indexSearcher, query);
  129.         //关闭资源
  130.         indexSearcher.getIndexReader().close();
  131.     }
  132.     //条件解析的对象查询   多个默念域
  133.     @Test
  134.     public void testMultiFieldQueryParser() throws Exception {
  135.         IndexSearcher indexSearcher = getIndexSearcher();
  137.         String[] fields = {"fileName","fileContent"};
  138.         //参数1： 默认查询的域  
  139.         //参数2：采用的分析器
  140.         MultiFieldQueryParser queryParser = new MultiFieldQueryParser(fields,new IKAnalyzer());
  141.         // *:*   域：值
  142.         Query query = queryParser.parse("lucene is apache");
  144.         printResult(indexSearcher, query);
  145.         //关闭资源
  146.         indexSearcher.getIndexReader().close();
  147.     }
  150. }

以上就是lucene的基本使用方法。

solr

solr实现全文检索的流程：

  1. 配置solr服务器环境。  
  2. 配置中文分析器：  
  3.     Schema.xml：  
  4.         FieldType：域类型定义  
  5.         Field：域定义  
  6.         uniqueKey：组件  
  7.         copyField：复制域，用于当查询一个条件的时候，查询多个域。（只发起一次请求）  
  8.         dynamicField：动态域，用于添加一个可以动态改天域名的域，这样就可以方便我们添加域名。  
  9.     安装ik分词器  
  10. 设置业务系统field（域）  
  11. 配置批量导入处理器

使用solr其实就是在lucene的基础上多了一些配置方法，让我们使用起来更加方便。所以，solr相应的配置起来会比较繁琐，相应的教程可以在网上搜到。

在配置好了相应的环境之后，我们可以通过自己的使用，看到solr自带的web界面的Query选项中的一些参数。熟悉一下都有什么用。

话不多说，solr的使用直接上代码吧。

  1. public class JdDaoImpl implements JdDao {
  3.     // 索引库
  4.     @Autowired
  5.     private SolrServer solrServer;
  6.     // 单机版的SolrServer
  7.     // String baseURL = "127.0.0.1:8080/solr/使用的core一般默认为core1"
  8.     // SolrServer 是一个抽象类，所以不能直接new它，需要知道子类的实现
  9.     // SolrServer solrServer = new HttpSolrServer（baseURL）
  11.      通过上面四个条件查询对象商品结果集
  12.     public List<ProductModel> selectProductModelListByQuery(String queryString, String catalog_name,
  13.             String price,String sort) throws Exception {
  15.         // 查询 关键词  过滤条件
  16.         // 价格排序 分页 开始行 每页数 高亮 默认域 只查询指定域
  17.         SolrQuery solrQuery = new SolrQuery();
  18.         // 关键词
  19.         solrQuery.setQuery(queryString);
  20.         // 过滤条件 
  21.         if(null != catalog_name && !"".equals(catalog_name)){
  22.             solrQuery.set("fq", "product_catalog_name:" + catalog_name);
  23.         }
  24.         if(null != price && !"".equals(price)){
  25.             //0-9   50-*
  26.             String[] p = price.split("-");
  27.             solrQuery.set("fq", "product_price:[" + p[0] + " TO " + p[1] + "]");
  28.         }
  29.         // 价格排序
  30.         if("1".equals(sort)){
  31.             solrQuery.addSort("product_price", ORDER.desc);
  32.         }else{
  33.             solrQuery.addSort("product_price", ORDER.asc);
  34.         }
  35.         // 分页
  36.         solrQuery.setStart(0);
  37.         solrQuery.setRows(16);
  38.         // 默认域
  39.         solrQuery.set("df", "product_keywords");
  40.         // 只查询指定域
  41.         solrQuery.set("fl", "id,product_name,product_price,product_picture");
  42.         // 高亮
  43.         // 打开开关
  44.         solrQuery.setHighlight(true);
  45.         // 指定高亮域
  46.         solrQuery.addHighlightField("product_name");
  47.         // 前缀
  48.         solrQuery.setHighlightSimplePre("<span style='color:red'>");
  49.         solrQuery.setHighlightSimplePost("</span>");
  51.         // 后缀
  52.         // 执行查询
  53.         QueryResponse response = solrServer.query(solrQuery);
  54.         // 文档结果集
  55.         SolrDocumentList docs = response.getResults();
  57.         Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
  58.         // Map K id V Map
  59.         // Map K 域名 V List
  60.         // List list.get(0)
  61.         // 总条数
  62.         long numFound = docs.getNumFound();
  65.         List<ProductModel> productModels = new ArrayList<ProductModel>();
  67.         for (SolrDocument doc : docs) {
  68.             ProductModel productModel = new ProductModel();
  70.             productModel.setPid((String) doc.get("id"));
  71.             productModel.setPrice((Float) doc.get("product_price"));
  72.             productModel.setPicture((String) doc.get("product_picture"));
  73.             Map<String, List<String>> map = highlighting.get((String) doc.get("id"));
  74.             List<String> list = map.get("product_name");
  76.             productModel.setName(list.get(0));
  77.             productModels.add(productModel);
  78.         }
  79.         return productModels;
  81.     }
  82. }

solr开发常用到的jar包一般都在solr文件夹—》dist文件夹—》solr-solrj.jar和solrj-lib文件夹—》所有jar包。

我们注意一点，不要被索引的一些概念弄懵，创建索引，其实就是索引的增、删、改。查询索引就是索引的查询。

发表评论

表情：
评论列表 （有 0 条评论，317人围观）

还没有评论，来说两句吧...

相关阅读

    相关 bash使用基础

    关于命令及命令类型 对于使用的命令BASH使用hash表，以加速下次的查找，为添加一个经常使用的命令，可以使用hash cmd BASH在执行命令时对路径中找到的同名命令

    素颜马尾好姑娘i素颜马尾好姑娘i/ 0 赞/ 183 阅读