几百行代码完成百度搜索引擎，真的可以吗?-低调大师

几百行代码完成百度搜索引擎，真的可以吗?

2020-10-19 596

本文转载自微信公众号「Java极客技术」，作者鸭血粉丝。转载本文请联系Java极客技术公众号。

Hello 大家好，我是鸭血粉丝，大家都叫我阿粉，搜索引擎想必大家一定不会默认，我们项目中经常使用的 ElasticSearch 就是一种搜索引擎，在我们的日志系统中必不可少，ELK 作为一个整体，基本上是运维标配了，另外目前的搜索引擎底层都是基于 Lucene 来实现的。

阿粉最近遇到一个需求，因为数据量没有达到需要使用 ElasticSearch 的级别，也不想单独部署一套集群，所以准备自己基于 Lucene 实现一个简易的搜索服务。下面我们一起来看一下吧。

背景

**Lucene **是一套用于全文检索和搜索的开放源码程序库，由 Apache 软件基金会支持和提供。Lucene 提供了一个简单却强大的应用程序接口，能够做全文索引和搜索。Lucene 是现在最受欢迎的免费 Java 信息检索程序库。

上面的解释是来自维基百科，我们只需要知道 Lucene 可以进行全文索引和搜索就行了，这里的索引是动词，意思是我们可以将文档或者文章或者文件等数据进行索引记录下来，索引过后，我们查询起来就会很快。

索引这个词有的时候是动词，表示我们要索引数据，有的时候是名词，我们需要根据上下文场景来判断。新华字典前面的字母表或者书籍前面的目录本质上都是索引。

接入

引入依赖

首先我们创建一个 SpringBoot 项目，然后在 pom 文件中加入如下内容，我这里使用的 lucene 版本是 7.2.1，

 
 
  
  <properties> 
  
      <lucene.version>7.2.1</lucene.version> 
  
  </properties> 
  
   
  
  <!-- Lucene核心库 --> 
  
  <dependency> 
  
   <groupId>org.apache.lucene</groupId> 
  
   <artifactId>lucene-core</artifactId> 
  
   <version>${lucene.version}</version> 
  
  </dependency> 
  
  <!-- Lucene解析库 --> 
  
  <dependency> 
  
   <groupId>org.apache.lucene</groupId> 
  
   <artifactId>lucene-queryparser</artifactId> 
  
   <version>${lucene.version}</version> 
  
  </dependency> 
  
  <!-- Lucene附加的分析库 --> 
  
  <dependency> 
  
   <groupId>org.apache.lucene</groupId> 
  
   <artifactId>lucene-analyzers-common</artifactId> 
  
   <version>${lucene.version}</version> 
  
  </dependency>

索引数据

在使用 Lucene 之前我们需要先索引一些文件，然后再通过关键词查询出来，下面我们来模拟整个过程。为了方便我们这里模拟一些数据，正常的数据应该是从数据库或者文件中加载的，我们的思路是这样的：

生成多条实体数据;
将实体数据映射成 Lucene 的文档形式;
索引文档;
根据关键词查询文档;

第一步我们先创建一个实体如下：

 
 
  
  import lombok.Data; 
  
   
  
  @Data 
  
  public class ArticleModel { 
  
      private String title; 
  
      private String author; 
  
      private String content; 
  
  }

我们再写一个工具类，用来索引数据，代码如下：

 
 
  
  import org.apache.commons.collections.CollectionUtils; 
  
  import org.apache.commons.lang.StringUtils; 
  
  import org.apache.lucene.analysis.Analyzer; 
  
  import org.apache.lucene.analysis.standard.StandardAnalyzer; 
  
  import org.apache.lucene.document.*; 
  
  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 org.springframework.beans.factory.annotation.Value; 
  
  import org.springframework.stereotype.Component; 
  
   
  
  import java.io.IOException; 
  
  import java.nio.file.Paths; 
  
  import java.util.ArrayList; 
  
  import java.util.List; 
  
  import java.util.Map; 
  
   
  
  public class LuceneIndexUtil { 
  
   
  
      private static String INDEX_PATH = "/opt/lucene/demo"; 
  
      private static IndexWriter writer; 
  
   
  
      public static LuceneIndexUtil getInstance() { 
  
          return SingletonHolder.luceneUtil; 
  
      } 
  
   
  
      private static class SingletonHolder { 
  
          public final static LuceneIndexUtil luceneUtil = new LuceneIndexUtil(); 
  
      } 
  
   
  
      private LuceneIndexUtil() { 
  
          this.initLuceneUtil(); 
  
      } 
  
   
  
      private void initLuceneUtil() { 
  
          try { 
  
              Directory dir = FSDirectory.open(Paths.get(INDEX_PATH)); 
  
              Analyzer analyzer = new StandardAnalyzer(); 
  
              IndexWriterConfig iwc = new IndexWriterConfig(analyzer); 
  
              writer = new IndexWriter(dir, iwc); 
  
          } catch (IOException e) { 
  
              log.error("create luceneUtil error"); 
  
              if (null != writer) { 
  
                  try { 
  
                      writer.close(); 
  
                  } catch (IOException ioException) { 
  
                      ioException.printStackTrace(); 
  
                  } finally { 
  
                      writer = null; 
  
                  } 
  
              } 
  
          } 
  
      } 
  
   
  
      /** 
  
       * 索引单个文档 
  
       * 
  
       * @param doc 文档信息 
  
       * @throws IOException IO 异常 
  
       */ 
  
      public void addDoc(Document doc) throws IOException { 
  
          if (null != doc) { 
  
              writer.addDocument(doc); 
  
              writer.commit(); 
  
              writer.close(); 
  
          } 
  
      } 
  
   
  
      /** 
  
       * 索引单个实体 
  
       * 
  
       * @param model 单个实体 
  
       * @throws IOException IO 异常 
  
       */ 
  
      public void addModelDoc(Object model) throws IOException { 
  
          Document document = new Document(); 
  
          List<Field> fields = luceneField(model.getClass()); 
  
          fields.forEach(document::add); 
  
          writer.addDocument(document); 
  
          writer.commit(); 
  
          writer.close(); 
  
      } 
  
   
  
      /** 
  
       * 索引实体列表 
  
       * 
  
       * @param objects 实例列表 
  
       * @throws IOException IO 异常 
  
       */ 
  
      public void addModelDocs(List<?> objects) throws IOException { 
  
          if (CollectionUtils.isNotEmpty(objects)) { 
  
              List<Document> docs = new ArrayList<>(); 
  
              objects.forEach(o -> { 
  
                  Document document = new Document(); 
  
                  List<Field> fields = luceneField(o); 
  
                  fields.forEach(document::add); 
  
                  docs.add(document); 
  
              }); 
  
              writer.addDocuments(docs); 
  
          } 
  
      } 
  
   
  
      /** 
  
       * 清除所有文档 
  
       * 
  
       * @throws IOException IO 异常 
  
       */ 
  
      public void delAllDocs() throws IOException { 
  
          writer.deleteAll(); 
  
      } 
  
   
  
      /** 
  
       * 索引文档列表 
  
       * 
  
       * @param docs 文档列表 
  
       * @throws IOException IO 异常 
  
       */ 
  
      public void addDocs(List<Document> docs) throws IOException { 
  
          if (CollectionUtils.isNotEmpty(docs)) { 
  
              long startTime = System.currentTimeMillis(); 
  
              writer.addDocuments(docs); 
  
              writer.commit(); 
  
              log.info("共索引{}个 Document，共耗时{} 毫秒", docs.size(), (System.currentTimeMillis() - startTime)); 
  
          } else { 
  
              log.warn("索引列表为空"); 
  
          } 
  
      } 
  
   
  
      /** 
  
       * 根据实体 class 对象获取字段类型，进行 lucene Field 字段映射 
  
       * 
  
       * @param modelObj 实体 modelObj 对象 
  
       * @return 字段映射列表 
  
       */ 
  
      public List<Field> luceneField(Object modelObj) { 
  
          Map<String, Object> classFields = ReflectionUtils.getClassFields(modelObj.getClass()); 
  
          Map<String, Object> classFieldsValues = ReflectionUtils.getClassFieldsValues(modelObj); 
  
   
  
          List<Field> fields = new ArrayList<>(); 
  
          for (String key : classFields.keySet()) { 
  
              Field field; 
  
              String dataType = StringUtils.substringAfterLast(classFields.get(key).toString(), "."); 
  
              switch (dataType) { 
  
                  case "Integer": 
  
                      field = new IntPoint(key, (Integer) classFieldsValues.get(key)); 
  
                      break; 
  
                  case "Long": 
  
                      field = new LongPoint(key, (Long) classFieldsValues.get(key)); 
  
                      break; 
  
                  case "Float": 
  
                      field = new FloatPoint(key, (Float) classFieldsValues.get(key)); 
  
                      break; 
  
                  case "Double": 
  
                      field = new DoublePoint(key, (Double) classFieldsValues.get(key)); 
  
                      break; 
  
                  case "String": 
  
                      String string = (String) classFieldsValues.get(key); 
  
                      if (StringUtils.isNotBlank(string)) { 
  
                          if (string.length() <= 1024) { 
  
                              field = new StringField(key, (String) classFieldsValues.get(key), Field.Store.YES); 
  
                          } else { 
  
                              field = new TextField(key, (String) classFieldsValues.get(key), Field.Store.NO); 
  
                          } 
  
                      } else { 
  
                          field = new StringField(key, StringUtils.EMPTY, Field.Store.NO); 
  
                      } 
  
                      break; 
  
                  default: 
  
                      field = new TextField(key, JsonUtils.obj2Json(classFieldsValues.get(key)), Field.Store.YES); 
  
                      break; 
  
              } 
  
              fields.add(field); 
  
          } 
  
          return fields; 
  
      } 
  
      public void close() { 
  
          if (null != writer) { 
  
              try { 
  
                  writer.close(); 
  
              } catch (IOException e) { 
  
                  log.error("close writer error"); 
  
              } 
  
              writer = null; 
  
          } 
  
      } 
  
   
  
      public void commit() throws IOException { 
  
          if (null != writer) { 
  
              writer.commit(); 
  
              writer.close(); 
  
          } 
  
      } 
  
  }

有了工具类，我们再写一个 demo 来进行数据的索引

 
 
  
  import java.util.ArrayList; 
  
  import java.util.List; 
  
   
  
  /** 
  
   * <br> 
  
   * <b>Function：</b><br> 
  
   * <b>Author：</b>@author Silence<br> 
  
   * <b>Date：</b>2020-10-17 21:08<br> 
  
   * <b>Desc：</b>无<br> 
  
   */ 
  
  public class Demo { 
  
      public static void main(String[] args) { 
  
          LuceneIndexUtil luceneUtil = LuceneIndexUtil.getInstance(); 
  
          List<ArticleModel> articles = new ArrayList<>(); 
  
          try { 
  
              //索引数据 
  
              ArticleModel article1 = new ArticleModel(); 
  
              article1.setTitle("Java 极客技术"); 
  
              article1.setAuthor("鸭血粉丝"); 
  
              article1.setContent("这是一篇给大家介绍 Lucene 的技术文章，必定点赞评论转发！！！"); 
  
              ArticleModel article2 = new ArticleModel(); 
  
              article2.setTitle("极客技术"); 
  
              article2.setAuthor("鸭血粉丝"); 
  
              article2.setContent("此处省略两千字..."); 
  
              ArticleModel article3 = new ArticleModel(); 
  
              article3.setTitle("Java 极客技术"); 
  
              article3.setAuthor("鸭血粉丝"); 
  
              article3.setContent("最后邀请你加入我们的知识星球，Today is big day!"); 
  
              articles.add(article1); 
  
              articles.add(article2); 
  
              articles.add(article3); 
  
              luceneUtil.addModelDocs(articles); 
  
              luceneUtil.commit(); 
  
               
  
          } catch (Exception e) { 
  
              e.printStackTrace(); 
  
          } 
  
      } 
  
  }

上面的 content 内容可以自行进行替换，阿粉这边避免凑字数的嫌疑就不贴了。

展示

运行结束过后，我们用过 Lucene 的可视化工具 luke 来查看下索引的数据内容，下载过后解压我们可以看到有.bat 和 .sh 两个脚本，根据自己的系统进行运行就好了。阿粉这边是 mac 用的是 sh 脚本运行，运行后打开设置的索引目录即可。

进入过后，我们可以看到下图显示的内容，选择 content 点击 show top items 可以看到右侧的索引数据，这里根据分词器的不同，索引的结果是不一样的，阿粉这里采用的分词器就是标准的分词器，小伙伴们可以根据自己的要求选择适合自己的分词器即可。

搜索数据

数据已经索引成功了，接下来我们就需要根据条件进行数据的搜索了，我们创建一个 LuceneSearchUtil.java 来操作数据。

 
 
  
  import org.apache.commons.collections.MapUtils; 
  
  import org.apache.lucene.analysis.Analyzer; 
  
  import org.apache.lucene.analysis.standard.StandardAnalyzer; 
  
  import org.apache.lucene.index.DirectoryReader; 
  
  import org.apache.lucene.queryparser.classic.QueryParser; 
  
  import org.apache.lucene.search.*; 
  
  import org.apache.lucene.store.Directory; 
  
  import org.apache.lucene.store.FSDirectory; 
  
  import org.springframework.beans.factory.annotation.Value; 
  
   
  
  import java.io.IOException; 
  
  import java.nio.file.Paths; 
  
  import java.util.Map; 
  
   
  
   
  
  public class LuceneSearchUtil { 
  
   
  
      private static String INDEX_PATH = "/opt/lucene/demo"; 
  
      private static IndexSearcher searcher; 
  
   
  
      public static LuceneSearchUtil getInstance() { 
  
          return LuceneSearchUtil.SingletonHolder.searchUtil; 
  
      } 
  
   
  
      private static class SingletonHolder { 
  
          public final static LuceneSearchUtil searchUtil = new LuceneSearchUtil(); 
  
      } 
  
   
  
      private LuceneSearchUtil() { 
  
          this.initSearcher(); 
  
      } 
  
   
  
      private void initSearcher() { 
  
          Directory directory; 
  
          try { 
  
              directory = FSDirectory.open(Paths.get(INDEX_PATH)); 
  
              DirectoryReader reader = DirectoryReader.open(directory); 
  
              searcher = new IndexSearcher(reader); 
  
          } catch (IOException e) { 
  
              e.printStackTrace(); 
  
          } 
  
      } 
  
   
  
      public TopDocs searchByMap(Map<String, Object> queryMap) throws Exception { 
  
          if (null == searcher) { 
  
              this.initSearcher(); 
  
          } 
  
          if (MapUtils.isNotEmpty(queryMap)) { 
  
              BooleanQuery.Builder builder = new BooleanQuery.Builder(); 
  
              queryMap.forEach((key, value) -> { 
  
                  if (value instanceof String) { 
  
                      Query queryString = new PhraseQuery(key, (String) value); 
  
  //                    Query queryString = new TermQuery(new Term(key, (String) value)); 
  
                      builder.add(queryString, BooleanClause.Occur.MUST); 
  
                  } 
  
              }); 
  
              return searcher.search(builder.build(), 10); 
  
          } 
  
          return null; 
  
      } 
  
   
  
  }

在 demo.java 中增加搜索代码如下：

 
 
  
  //查询数据 
  
     Map<String, Object> map = new HashMap<>(); 
  
     map.put("title", "Java 极客技术"); 
  
  //   map.put("title", "极客技术"); 
  
  //   map.put("content", "最"); 
  
     LuceneSearchUtil searchUtil = LuceneSearchUtil.getInstance(); 
  
     TopDocs topDocs = searchUtil.searchByMap(map); 
  
     System.out.println(topDocs.totalHits);

运行结果如下，表示搜索到了两条。

通过可视化工具我们可以看到 title 为"Java 极客技术"确实是有两条记录，而且我们也确认只插入了两条数据。注意这里如果根据其他字符去查询可能查询不出来，因为阿粉这里的分词器采用的是默认的分词器，小伙伴可以根据自身的情况采用相应的分词器。

至此我们可以索引和搜索数据了，不过这还是简单的入门操作，对于不同类型的字段，我们需要使用不同的查询方式，而且根据系统的特性我们需要使用特定的分词器，默认的标准分词器不一定符合我们的使用场景。而且我们索引数据的时候也需要根据字段类型进行不同 Field 的设定。上面的案例只是 demo 并不能在生产上使用，搜索引擎在互联网行业是领头羊，很多先进的互联网技术都是从搜索引擎开始发展的。

微信关注我们

原文链接：http://os.51cto.com/art/202010/629063.htm

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

如何保护智慧城市中的运营技术？

运营技术安全性更加关注智能城市环境中的数据完整性和整体系统的可用性。智慧城市依靠硬件和软件来提供服务和控制系统，以提高城市本身的效率和效力。保护智慧城市运营技术免受网络安全风险是建设智慧城市的关键部分。多年来，城市一直将IT嵌入城市系统中。近30年前，诸如交通信号灯之类的基本城市服务就处于通信网络的最前沿。但是，随着城市向智慧城市的数字化转型加速，将所有这些新的硬件和软件连接在一起的工业控制系统出现了一个新名词：运营技术或OT(Operational Technology)。如果传统的IT专注于最终用户计算、服务器和应用程序，那么OT是将其他所有内容链接在一起的软件和系统。智慧城市中的运营技术是什么? 运营技术使智慧城市成为“智能”。如果路灯对环境光做出反应以调节其亮度，而不是仅仅在日落前15分钟就亮起来，那么实现这一目标的软件和传感器就是可操作的技术。如果限速标志根据天气和能见度调整最大速度，以创造更安全的路段，那么这就是工作的全部时间。显然，运营技术的某些方面与传统的IT应用和系统没有什么不同。他们都接受输入，做出决定并产生结果。主要区别在于OT立即影响物理世界。 SCAD...

2020-10-20

628

【争做优秀博主】大话MySQL之爱恨情仇

在数据库的发展过程中，安全-->稳定-->高效-->低成本四个有序的要点一直如影随形，后者离开前者就是空谈。10月19日晚上MySQL发布了8.0.22版本，其中一个新功能（Automatic connection failover for Async Replication Channels）引起我的注意，也很感兴趣，作为一个DBA老兵，百感交集，在过去的20多年，故障切换功能一直是三方后娘工具在主导，是几代DBA的痛，互联网最流行的数据库，在这块一直为人诟病。此功能还没有测试，不管如何，至少在这块官方终于开始出手解决了。夜深人静，整理了一下思路，对于MySQL产品截至目前的发展情况，做了一下总结，基本走以下几个方向发展：1、主从同步方向：异步同步到半同步，在到增强半同步，再到组复制；走同步的安全策略，到提升同步的效率，走单线程复制到并行复制，致力于降低主从延迟问题，但相对的同步绝对的延迟伴随其发展全过程至今。2、性能优化方向：多线程，线程池（原版MySQL的企业版支持，社区版不支持）；各种日志各种独立，截止8.0.22版本，保证安全与问题记录的日志基本全部独立了，...

2020-10-20

666

发表评论

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。