Apache Solr - 快速指南
Apache Solr - 概述
Solr 是一个开源搜索平台，用于构建搜索应用程序。它建立在 Lucene(全文搜索引擎)之上。Solr 适用于企业，速度快且高度可扩展。使用 Solr 构建的应用程序非常复杂，性能卓越。
2004 年，Yonik Seely 创建了 Solr，旨在为 CNET Networks 公司网站添加搜索功能。2006 年 1 月，它成为 Apache 软件基金会下的一个开源项目。其最新版本 Solr 6.0 于 2016 年发布，支持执行并行 SQL 查询。
Solr 可以与 Hadoop 一起使用。由于 Hadoop 处理大量数据，Solr 可帮助我们从如此庞大的来源中找到所需信息。Solr 不仅可用于搜索，还可用于存储。与其他 NoSQL 数据库一样，它是一种非关系数据存储和处理技术。
简而言之，Solr 是一种可扩展、随时可部署的搜索/存储引擎，经过优化，可搜索大量以文本为中心的数据。
Apache Solr 的功能
Solr 是 Lucene Java API 的包装。因此，使用 Solr，您可以利用 Lucene 的所有功能。让我们来看看 Solr 的一些最突出的功能 −
Restful API − 要与 Solr 通信，不一定要具备 Java 编程技能。相反，您可以使用 restful 服务与其通信。我们在 Solr 中输入 XML、JSON 和 .CSV 等文件格式的文档，并以相同的文件格式获得结果。
全文搜索 − Solr 提供全文搜索所需的所有功能，例如标记、短语、拼写检查、通配符和自动完成。
企业就绪 − 根据组织的需要，Solr 可以部署在任何类型的系统(大型或小型)中，例如独立、分布式、云等。
灵活且可扩展 − 通过扩展 Java 类并进行相应配置，我们可以轻松定制 Solr 的组件。
NoSQL 数据库 − Solr 还可以用作大数据规模 NOSQL 数据库，我们可以在其中沿集群分发搜索任务。
管理界面 − Solr 提供了一个易于使用、用户友好、功能强大的用户界面，我们可以使用该界面执行所有可能的任务，例如管理日志、添加、删除、更新和搜索文档。
高度可扩展 − 在将 Solr 与 Hadoop 一起使用时，我们可以通过添加副本来扩展其容量。
以文本为中心并按相关性排序 − Solr 主要用于搜索文本文档，并根据与用户查询的相关性按顺序提供结果。
与 Lucene 不同，使用 Apache Solr 时不需要具备 Java 编程技能。它提供了一项出色的即用型服务，用于构建具有自动完成功能的搜索框，而 Lucene 不提供此功能。使用 Solr，我们可以扩展、分发和管理索引，适用于大规模(大数据)应用程序。
搜索应用程序中的 Lucene
Lucene 是一个简单但功能强大的基于 Java 的搜索库。它可以用于任何应用程序以添加搜索功能。Lucene 是一个可扩展且高性能的库，用于索引和搜索几乎任何类型的文本。Lucene 库提供了任何搜索应用程序所需的核心操作，例如索引和搜索。
如果我们有一个包含大量数据的 Web 门户，那么我们很可能需要门户中的搜索引擎来从庞大的数据池中提取相关信息。Lucene 是任何搜索应用程序的核心，并提供与索引和搜索相关的重要操作。
Apache Solr - 搜索引擎基础知识
搜索引擎是指包含网页、新闻组、程序、图像等互联网资源的庞大数据库。它有助于在万维网上查找信息。
用户可以通过将查询以关键字或短语的形式传递到搜索引擎来搜索信息。然后，搜索引擎在其数据库中进行搜索并向用户返回相关链接。
搜索引擎组件
通常，搜索引擎有三个基本组件，如下所示 −
网络爬虫 − 网络爬虫也称为蜘蛛或机器人。它是一个遍历网络以收集信息的软件组件。
数据库 − 网络上的所有信息都存储在数据库中。它们包含大量的网络资源。
搜索界面 − 此组件是用户和数据库之间的界面。它可以帮助用户搜索数据库。
搜索引擎如何工作?
任何搜索应用程序都需要执行以下部分或全部操作。
| 步骤 | 标题 | 描述 |
|---|---|---|
1 |
获取原始内容 |
任何搜索应用程序的第一步都是收集要搜索的目标内容进行。 |
2 |
构建文档 |
下一步是从搜索应用程序可以轻松理解和解释的原始内容构建文档。 |
3 |
分析文档 |
在开始索引之前，需要分析文档。 |
4 |
索引文档 |
构建和分析文档后，下一步就是对它们进行索引，以便可以根据某些键而不是文档的全部内容检索该文档。 索引类似于我们在书末的索引，其中常用词与其页码一起显示，以便可以快速跟踪这些词，而不必搜索整本书。 |
5 |
搜索用户界面 |
索引数据库准备就绪后，应用程序就可以执行搜索操作。为了帮助用户进行搜索，应用程序必须提供一个用户界面，用户可以在其中输入文本并启动搜索过程 |
6 |
构建查询 |
一旦用户发出搜索文本的请求，应用程序应该使用该文本准备一个查询对象，然后可以使用该对象查询索引数据库以获取相关详细信息。 |
7 |
搜索查询 |
使用查询对象，检查索引数据库以获取相关详细信息和内容文档。 |
8 |
呈现结果 |
收到所需结果后，应用程序应决定如何使用其用户界面向用户显示结果。 |
查看下图。它显示了搜索引擎如何运作的总体视图。
除了这些基本操作外，搜索应用程序还可以提供管理用户界面，帮助管理员根据用户配置文件控制搜索级别。搜索结果分析是任何搜索应用程序的另一个重要且高级的方面。
Apache Solr - 在 Windows 环境中
在本章中，我们将讨论如何在 Windows 环境中设置 Solr。要在 Windows 系统上安装 Solr，您需要按照下面给出的步骤 −
访问 Apache Solr 主页并单击下载按钮。
选择其中一个镜像以获取 Apache Solr 的索引。从那里下载名为 Solr-6.2.0.zip 的文件。
将文件从 下载文件夹 移动到所需目录并解压缩。
假设您下载了 Solr 文件并将其解压缩到 C 盘。在这种情况下，您可以按照以下屏幕截图所示启动 Solr。
要验证安装，请在浏览器中使用以下 URL。
http://localhost:8983/
如果安装过程成功，您将看到 Apache Solr 用户界面的仪表板，如下所示。
设置 Java 环境
我们还可以使用 Java 库与 Apache Solr 通信;但在使用 Java API 访问 Solr 之前，您需要设置这些库的类路径。
设置类路径
在 .bashrc 文件中将 类路径 设置为 Solr 库。在任何编辑器中打开 .bashrc，如下所示。
$ gedit ~/.bashrc
设置 Solr 库的类路径(HBase 中的 lib 文件夹)，如下所示。
export CLASSPATH = $CLASSPATH://home/hadoop/Solr/lib/*
这是为了防止使用 Java API 访问 HBase 时出现"找不到类"异常。
Apache Solr - 在 Hadoop 上
Solr 可以与 Hadoop 一起使用。由于 Hadoop 处理大量数据，Solr 可帮助我们从如此庞大的来源中找到所需的信息。在本节中，让我们了解如何在系统上安装 Hadoop。
下载 Hadoop
下面给出了将 Hadoop 下载到系统上需要遵循的步骤。
步骤 1 − 转到 Hadoop 主页。您可以使用链接 − www.hadoop.apache.org/。单击链接 Releases，如以下屏幕截图中突出显示。
它将重定向您到 Apache Hadoop Releases 页面，其中包含各种版本的 Hadoop 源和二进制文件的镜像链接，如下所示 −
步骤 2 − 选择最新版本的 Hadoop(在我们的教程中为 2.6.4)并单击其 二进制链接。它将带您进入一个页面，其中提供了 Hadoop 二进制镜像。单击其中一个镜像即可下载 Hadoop。
从命令提示符下载 Hadoop
打开 Linux 终端并以超级用户身份登录。
$ su password:
转到需要安装 Hadoop 的目录，并使用之前复制的链接将文件保存在那里，如以下代码块所示。
# cd /usr/local # wget http://redrockdigimark.com/apachemirror/hadoop/common/hadoop- 2.6.4/hadoop-2.6.4.tar.gz
下载 Hadoop 后，使用以下命令将其解压。
# tar zxvf hadoop-2.6.4.tar.gz # mkdir hadoop # mv hadoop-2.6.4/* to hadoop/ # exit
安装 Hadoop
按照以下步骤以伪分布式模式安装 Hadoop。
步骤 1:设置 Hadoop
您可以通过将以下命令附加到 ~/.bashrc 文件来设置 Hadoop 环境变量。
export HADOOP_HOME = /usr/local/hadoop export HADOOP_MAPRED_HOME = $HADOOP_HOME export HADOOP_COMMON_HOME = $HADOOP_HOME export HADOOP_HDFS_HOME = $HADOOP_HOME export YARN_HOME = $HADOOP_HOME export HADOOP_COMMON_LIB_NATIVE_DIR = $HADOOP_HOME/lib/native export PATH = $PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin export HADOOP_INSTALL = $HADOOP_HOME
接下来，将所有更改应用到当前运行的系统中。
$ source ~/.bashrc
第 2 步:Hadoop 配置
您可以在"$HADOOP_HOME/etc/hadoop"位置找到所有 Hadoop 配置文件。需要根据您的 Hadoop 基础架构对这些配置文件进行更改。
$ cd $HADOOP_HOME/etc/hadoop
为了使用 Java 开发 Hadoop 程序，您必须重置 hadoop-env.sh 文件中的 Java 环境变量，方法是将 JAVA_HOME 值替换为系统中 Java 的位置。
export JAVA_HOME = /usr/local/jdk1.7.0_71
以下是您必须编辑以配置 Hadoop 的文件列表 −
- core-site.xml
- hdfs-site.xml
- yarn-site.xml
- mapred-site.xml
core-site.xml
core-site.xml 文件包含用于 Hadoop 实例的端口号、分配给文件系统的内存、用于存储数据的内存限制以及读/写缓冲区的大小等信息。
打开 core-site.xml 并在 <configuration>、</configuration> 标签内添加以下属性。
<configuration>
<property>
<name>fs.default.name</name>
<value>hdfs://localhost:9000</value>
</property>
</configuration>
hdfs-site.xml
hdfs-site.xml 文件包含复制数据的值、namenode 路径以及本地文件系统的 datanode 路径等信息。它表示您要存储 Hadoop 基础架构的位置。
让我们假设以下数据。
dfs.replication (data replication value) = 1 (In the below given path /hadoop/ is the user name. hadoopinfra/hdfs/namenode is the directory created by hdfs file system.) namenode path = //home/hadoop/hadoopinfra/hdfs/namenode (hadoopinfra/hdfs/datanode is the directory created by hdfs file system.) datanode path = //home/hadoop/hadoopinfra/hdfs/datanode
打开此文件并在 <configuration>、</configuration> 标签内添加以下属性。
<configuration>
<property>
<name>dfs.replication</name>
<value>1</value>
</property>
<property>
<name>dfs.name.dir</name>
<value>file:///home/hadoop/hadoopinfra/hdfs/namenode</value>
</property>
<property>
<name>dfs.data.dir</name>
<value>file:///home/hadoop/hadoopinfra/hdfs/datanode</value>
</property>
</configuration>
注意 − 在上述文件中，所有属性值都是用户定义的，您可以根据您的 Hadoop 基础架构进行更改。
yarn-site.xml
此文件用于将 yarn 配置到 Hadoop。打开 yarn-site.xml 文件，并在此文件中的 <configuration>、</configuration> 标签之间添加以下属性。
<configuration>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>
mapred-site.xml
此文件用于指定我们使用哪个 MapReduce 框架。默认情况下，Hadoop 包含一个 yarn-site.xml 模板。首先，需要使用以下命令将文件从 mapred-site,xml.template 复制到 mapred-site.xml 文件。
$ cp mapred-site.xml.template mapred-site.xml
打开 mapred-site.xml 文件并在 <configuration>、</configuration> 标签内添加以下属性。
<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
</configuration>
验证 Hadoop 安装
以下步骤用于验证 Hadoop 安装。
步骤 1:名称节点设置
使用命令"hdfs namenode –format"设置名称节点，如下所示。
$ cd ~ $ hdfs namenode -format
预期结果如下。
10/24/14 21:30:55 INFO namenode.NameNode: STARTUP_MSG: /************************************************************ STARTUP_MSG: Starting NameNode STARTUP_MSG: host = localhost/192.168.1.11 STARTUP_MSG: args = [-format] STARTUP_MSG: version = 2.6.4 ... ... 10/24/14 21:30:56 INFO common.Storage: Storage directory /home/hadoop/hadoopinfra/hdfs/namenode has been successfully formatted. 10/24/14 21:30:56 INFO namenode.NNStorageRetentionManager: Going to retain 1 images with txid >= 0 10/24/14 21:30:56 INFO util.ExitUtil: Exiting with status 0 10/24/14 21:30:56 INFO namenode.NameNode: SHUTDOWN_MSG: /************************************************************ SHUTDOWN_MSG: Shutting down NameNode at localhost/192.168.1.11 ************************************************************/
步骤 2:验证 Hadoop dfs
以下命令用于启动 Hadoop dfs。执行此命令将启动您的 Hadoop 文件系统。
$ start-dfs.sh
预期输出如下 −
10/24/14 21:37:56 Starting namenodes on [localhost] localhost: starting namenode, logging to /home/hadoop/hadoop-2.6.4/logs/hadoop- hadoop-namenode-localhost.out localhost: starting datanode, logging to /home/hadoop/hadoop-2.6.4/logs/hadoop- hadoop-datanode-localhost.out Starting secondary namenodes [0.0.0.0]
步骤 3:验证 Yarn 脚本
以下命令用于启动 Yarn 脚本。执行此命令将启动您的 Yarn 守护程序。
$ start-yarn.sh
预期输出如下 −
starting yarn daemons starting resourcemanager, logging to /home/hadoop/hadoop-2.6.4/logs/yarn- hadoop-resourcemanager-localhost.out localhost: starting nodemanager, logging to /home/hadoop/hadoop- 2.6.4/logs/yarn-hadoop-nodemanager-localhost.out
步骤 4:在浏览器上访问 Hadoop
访问 Hadoop 的默认端口号为 50070。使用以下 URL 在浏览器上获取 Hadoop 服务。
http://localhost:50070/
在 Hadoop 上安装 Solr
按照以下步骤下载并安装 Solr。
步骤 1
单击以下链接 − 打开 Apache Solr 主页https://lucene.apache.org/solr/
第 2 步
单击下载按钮(在上面的屏幕截图中突出显示)。单击后，您将被重定向到拥有 Apache Solr 各种镜像的页面。选择一个镜像并单击它，它将重定向到可以下载 Apache Solr 的源文件和二进制文件的页面，如以下屏幕截图所示。
步骤 3
单击后，将在系统的下载文件夹中下载一个名为 Solr-6.2.0.tqz 的文件夹。提取下载文件夹的内容。
步骤 4
在 Hadoop 主目录中创建一个名为 Solr 的文件夹，并将提取的文件夹的内容移动到其中，如下所示。
$ mkdir Solr $ cd Downloads $ mv Solr-6.2.0 /home/Hadoop/
验证
浏览 Solr 主目录的 bin 文件夹，并使用 version 选项验证安装，如以下代码块所示。
$ cd bin/ $ ./Solr version 6.2.0
设置主目录和路径
使用以下命令打开 .bashrc 文件 −
[Hadoop@localhost ~]$ source ~/.bashrc
现在按如下方式设置 Apache Solr 的主目录和路径目录 −
export SOLR_HOME = /home/Hadoop/Solr export PATH = $PATH:/$SOLR_HOME/bin/
打开终端并执行以下命令 −
[Hadoop@localhost Solr]$ source ~/.bashrc
现在，您可以从任何目录执行 Solr 的命令。
Apache Solr - 架构
在本章中，我们将讨论 Apache Solr 的架构。下图显示了 Apache Solr 架构的框图。
Solr 架构 ─ 构建块
以下是 Apache Solr 的主要构建块(组件)−
请求处理程序 − 我们发送给 Apache Solr 的请求由这些请求处理程序处理。这些请求可能是查询请求或索引更新请求。根据我们的需求，我们需要选择请求处理程序。要将请求传递给 Solr，我们通常会将处理程序映射到某个 URI 端点，然后由该处理程序处理指定的请求。
搜索组件 − 搜索组件是 Apache Solr 中提供的一种搜索类型(功能)。它可能是拼写检查、查询、分面、命中突出显示等。这些搜索组件注册为搜索处理程序。多个组件可以注册到搜索处理程序。
查询解析器 − Apache Solr 查询解析器解析我们传递给 Solr 的查询并验证查询是否存在语法错误。解析查询后，它会将其转换为 Lucene 可以理解的格式。
响应编写器 − Apache Solr 中的响应编写器是生成用户查询的格式化输出的组件。 Solr 支持 XML、JSON、CSV 等响应格式。我们为每种类型的响应提供不同的响应编写器。
分析器/标记器 − Lucene 以标记形式识别数据。Apache Solr 分析内容，将其划分为标记，并将这些标记传递给 Lucene。Apache Solr 中的分析器检查字段的文本并生成标记流。标记器将分析器准备的标记流分解为标记。
更新请求处理器 − 每当我们向 Apache Solr 发送更新请求时，请求都会通过一组插件(签名、日志记录、索引)运行，统称为更新请求处理器。此处理器负责删除字段、添加字段等修改。
Apache Solr - 术语
在本章中，我们将尝试理解在使用 Solr 时经常使用的一些术语的真正含义。
通用术语
以下是所有类型的 Solr 设置中使用的通用术语列表 −
实例 − 就像 tomcat 实例 或 jetty 实例 一样，此术语指的是在 JVM 内部运行的应用程序服务器。Solr 的主目录提供了对每个 Solr 实例的引用，其中可以配置一个或多个核心以在每个实例中运行。
核心 −在应用程序中运行多个索引时，每个实例可以有多个核心，而不是每个实例只有一个核心。
Home − 术语 $SOLR_HOME 指的是主目录，其中包含有关核心及其索引、配置和依赖项的所有信息。
Shard − 在分布式环境中，数据在多个 Solr 实例之间进行分区，其中每个数据块可以称为 Shard。它包含整个索引的子集。
SolrCloud 术语
在前面的章节中，我们讨论了如何在独立模式下安装 Apache Solr。请注意，我们还可以在分布式模式(云环境)下安装 Solr，其中 Solr 以主从模式安装。在分布式模式下，索引在主服务器上创建，并复制到一个或多个从属服务器。
与 Solr Cloud 相关的关键术语如下 −
节点 − 在 Solr Cloud 中，每个 Solr 实例都被视为一个 节点。
集群 − 环境中的所有节点组合在一起构成一个 集群。
集合 − 集群具有称为 集合 的逻辑索引。
分片 − 分片是集合的一部分，其中包含索引的一个或多个副本。
副本 −在 Solr Core 中，在节点中运行的分片副本称为 replica。
Leader − 它也是分片的副本，它将 Solr Cloud 的请求分发给其余副本。
Zookeeper − 它是 Solr Cloud 用于集中配置和协调、管理集群和选举 Leader 的一个 Apache 项目。
配置文件
Apache Solr 中的主要配置文件如下 −
Solr.xml − 它是 $SOLR_HOME 目录中包含 Solr Cloud 相关信息的文件。为了加载核心，Solr 会引用此文件，这有助于识别它们。
Solrconfig.xml − 此文件包含与请求处理和响应格式相关的定义和特定于核心的配置，以及索引、配置、管理内存和提交。
Schema.xml − 此文件包含整个架构以及字段和字段类型。
Core.properties − 此文件包含特定于核心的配置。它用于核心发现，因为它包含核心的名称和数据目录的路径。它可以在任何目录中使用，然后该目录将被视为核心目录。
Apache Solr - 基本命令
启动 Solr
安装 Solr 后，浏览至 Solr 主目录中的 bin 文件夹，然后使用以下命令启动 Solr。
[Hadoop@localhost ~]$ cd [Hadoop@localhost ~]$ cd Solr/ [Hadoop@localhost Solr]$ cd bin/ [Hadoop@localhost bin]$ ./Solr start
此命令在后台启动 Solr，并通过显示以下消息来监听端口 8983。
等待最多 30 秒，即可看到 Solr 在端口 8983 上运行 [\] 已在端口 8983 (pid = 6035) 上启动 Solr 服务器。祝您搜索愉快!
在前台启动 Solr
如果您使用 start 命令启动 Solr，那么 Solr 将在后台启动。相反，您可以使用 –f 选项在前台启动 Solr。
[Hadoop@localhost bin]$ ./Solr start –f 5823 INFO (coreLoadExecutor-6-thread-2) [ ] o.a.s.c.SolrResourceLoader Adding 'file:/home/Hadoop/Solr/contrib/extraction/lib/xmlbeans-2.6.0.jar' to classloader 5823 INFO (coreLoadExecutor-6-thread-2) [ ] o.a.s.c.SolrResourceLoader Adding 'file:/home/Hadoop/Solr/dist/Solr-cell-6.2.0.jar' to classloader 5823 INFO (coreLoadExecutor-6-thread-2) [ ] o.a.s.c.SolrResourceLoader Adding 'file:/home/Hadoop/Solr/contrib/clustering/lib/carrot2-guava-18.0.jar' to classloader 5823 INFO (coreLoadExecutor-6-thread-2) [ ] o.a.s.c.SolrResourceLoader Adding 'file:/home/Hadoop/Solr/contrib/clustering/lib/attributes-binder1.3.1.jar' to classloader 5823 INFO (coreLoadExecutor-6-thread-2) [ ] o.a.s.c.SolrResourceLoader Adding 'file:/home/Hadoop/Solr/contrib/clustering/lib/simple-xml-2.7.1.jar' to classloader …………………………………………………………………………………………………………………………………………………………………………………………………………… …………………………………………………………………………………………………………………………………………………………………………………………………. 12901 INFO (coreLoadExecutor-6-thread-1) [ x:Solr_sample] o.a.s.u.UpdateLog Took 24.0ms to seed version buckets with highest version 1546058939881226240 12902 INFO (coreLoadExecutor-6-thread-1) [ x:Solr_sample] o.a.s.c.CoreContainer registering core: Solr_sample 12904 INFO (coreLoadExecutor-6-thread-2) [ x:my_core] o.a.s.u.UpdateLog Took 16.0ms to seed version buckets with highest version 1546058939894857728 12904 INFO (coreLoadExecutor-6-thread-2) [ x:my_core] o.a.s.c.CoreContainer registering core: my_core
在另一个端口启动 Solr
使用 start 命令的 –p 选项，我们可以在另一个端口启动 Solr，如下面的代码块所示。
[Hadoop@localhost bin]$ ./Solr start -p 8984 Waiting up to 30 seconds to see Solr running on port 8984 [-] Started Solr server on port 8984 (pid = 10137). Happy searching!
停止 Solr
您可以使用 stop 命令停止 Solr。
$ ./Solr stop
此命令停止 Solr，并显示如下所示的消息。
Sending stop command to Solr running on port 8983 ... waiting 5 seconds to allow Jetty process 6035 to stop gracefully.
重新启动 Solr
Solr 的 restart 命令会停止 Solr 5 秒钟，然后重新启动。您可以使用以下命令重新启动 Solr −
./Solr restart
此命令重新启动 Solr，并显示以下消息−
Sending stop command to Solr running on port 8983 ... waiting 5 seconds to allow Jetty process 6671 to stop gracefully. Waiting up to 30 seconds to see Solr running on port 8983 [|] [/] Started Solr server on port 8983 (pid = 6906). Happy searching!
Solr ─ help 命令
Solr 的 help 命令可用于检查 Solr 提示符及其选项的使用情况。
[Hadoop@localhost bin]$ ./Solr -help Usage: Solr COMMAND OPTIONS where COMMAND is one of: start, stop, restart, status, healthcheck, create, create_core, create_collection, delete, version, zk Standalone server example (start Solr running in the background on port 8984): ./Solr start -p 8984 SolrCloud example (start Solr running in SolrCloud mode using localhost:2181 to connect to Zookeeper, with 1g max heap size and remote Java debug options enabled): ./Solr start -c -m 1g -z localhost:2181 -a "-Xdebug - Xrunjdwp:transport = dt_socket,server = y,suspend = n,address = 1044" Pass -help after any COMMAND to see command-specific usage information, such as: ./Solr start -help or ./Solr stop -help
Solr ─ status 命令
Solr 的此 status 命令可用于搜索和查找计算机上正在运行的 Solr 实例。它可以为您提供有关 Solr 实例的信息，例如其版本、内存使用情况等。
您可以使用 status 命令检查 Solr 实例的状态，如下所示 −
[Hadoop@localhost bin]$ ./Solr status
执行时，上述命令将显示 Solr 的状态，如下所示 −
Found 1 Solr nodes:
Solr process 6906 running on port 8983 {
"Solr_home":"/home/Hadoop/Solr/server/Solr",
"version":"6.2.0 764d0f19151dbff6f5fcd9fc4b2682cf934590c5 -
mike - 2016-08-20 05:41:37",
"startTime":"2016-09-20T06:00:02.877Z",
"uptime":"0 days, 0 hours, 5 minutes, 14 seconds",
"memory":"30.6 MB (%6.2) of 490.7 MB"
}
Solr Admin
启动 Apache Solr 后，您可以使用以下 URL 访问 Solr Web 界面 的主页。
Localhost:8983/Solr/
Solr Admin 的界面显示如下 −
Apache Solr - Core
Solr Core 是 Lucene 索引的运行实例，包含使用它所需的所有 Solr 配置文件。我们需要创建一个 Solr Core 来执行索引和分析等操作。
Solr 应用程序可能包含一个或多个核心。如有必要，Solr 应用程序中的两个核心可以相互通信。
创建核心
安装并启动 Solr 后，您可以连接到 Solr 的客户端(Web 界面)。
如以下屏幕截图所示，Apache Solr 中最初没有核心。现在，我们将了解如何在 Solr 中创建核心。
使用 create 命令
创建核心的一种方法是使用 create 命令创建 无模式核心，如下所示 −
[Hadoop@localhost bin]$ ./Solr create -c Solr_sample
在这里，我们尝试在 Apache Solr 中创建一个名为 Solr_sample 的核心。此命令创建一个显示以下消息的核心。
Copying configuration to new core instance directory:
/home/Hadoop/Solr/server/Solr/Solr_sample
Creating new core 'Solr_sample' using command:
http://localhost:8983/Solr/admin/cores?action=CREATE&name=Solr_sample&instanceD
ir = Solr_sample {
"responseHeader":{
"status":0,
"QTime":11550
},
"core":"Solr_sample"
}
您可以在 Solr 中创建多个核心。在 Solr Admin 的左侧，您可以看到一个 核心选择器，您可以在其中选择新创建的核心，如以下屏幕截图所示。
使用 create_core 命令
或者，您可以使用 create_core 命令创建核心。此命令具有以下选项 −
| –c core_name | 要创建的核心的名称 |
| -p port_name | 要在其中创建核心的端口 |
| -d conf_dir | 端口的配置目录 |
让我们看看如何使用 create_core 命令。在这里，我们将尝试创建一个名为 my_core 的核心。
[Hadoop@localhost bin]$ ./Solr create_core -c my_core
执行时，上述命令会创建一个核心，并显示以下消息 −
Copying configuration to new core instance directory:
/home/Hadoop/Solr/server/Solr/my_core
Creating new core 'my_core' using command:
http://localhost:8983/Solr/admin/cores?action=CREATE&name=my_core&instanceD
ir = my_core {
"responseHeader":{
"status":0,
"QTime":1346
},
"core":"my_core"
}
删除核心
您可以使用 Apache Solr 的 delete 命令删除核心。假设我们在 Solr 中有一个名为 my_core 的核心，如以下屏幕截图所示。
您可以使用 delete 命令删除此核心，方法是将核心的名称传递给此命令，如下所示 −
[Hadoop@localhost bin]$ ./Solr delete -c my_core
执行上述命令后，将删除指定的核心，并显示以下消息。
Deleting core 'my_core' using command:
http://localhost:8983/Solr/admin/cores?action=UNLOAD&core = my_core&deleteIndex
= true&deleteDataDir = true&deleteInstanceDir = true {
"responseHeader" :{
"status":0,
"QTime":170
}
}
您可以打开 Solr 的 Web 界面来验证核心是否已被删除。
Apache Solr - 索引数据
一般来说，索引是对文档或(其他实体)进行系统排列。索引使用户能够在文档中定位信息。
索引收集、解析和存储文档。
索引是为了在查找所需文档时提高搜索查询的速度和性能。
Apache Solr 中的索引
在 Apache Solr 中，我们可以索引(添加、删除、修改)各种文档格式，如 xml、csv、pdf 等。我们可以通过多种方式将数据添加到 Solr 索引中。
在本章中，我们将讨论索引 −
- 使用 Solr Web 界面。
- 使用任何客户端 API，如 Java、Python 等。
- 使用 post 工具。
在本章中章节中，我们将讨论如何使用各种接口(命令行、Web 界面和 Java 客户端 API)将数据添加到 Apache Solr 的索引中。
使用 Post 命令添加文档
Solr 在其 bin/ 目录中有一个 post 命令。使用此命令，您可以在 Apache Solr 中索引各种格式的文件，例如 JSON、XML、CSV。
浏览 Apache Solr 的 bin 目录并执行 post 命令的 –h 选项，如以下代码块所示。
[Hadoop@localhost bin]$ cd $SOLR_HOME [Hadoop@localhost bin]$ ./post -h
执行上述命令后，您将获得 post 命令 的选项列表，如下所示。
Usage: post -c <collection> [OPTIONS] <files|directories|urls|-d [".."]>
or post –help
collection name defaults to DEFAULT_SOLR_COLLECTION if not specified
OPTIONS
=======
Solr options:
-url <base Solr update URL> (overrides collection, host, and port)
-host <host> (default: localhost)
-p or -port <port> (default: 8983)
-commit yes|no (default: yes)
Web crawl options:
-recursive <depth> (default: 1)
-delay <seconds> (default: 10)
Directory crawl options:
-delay <seconds> (default: 0)
stdin/args options:
-type <content/type> (default: application/xml)
Other options:
-filetypes <type>[,<type>,...] (default:
xml,json,jsonl,csv,pdf,doc,docx,ppt,pptx,xls,xlsx,odt,odp,ods,ott,otp,ots,
rtf,htm,html,txt,log)
-params "<key> = <value>[&<key> = <value>...]" (values must be
URL-encoded; these pass through to Solr update request)
-out yes|no (default: no; yes outputs Solr response to console)
-format Solr (sends application/json content as Solr commands
to /update instead of /update/json/docs)
Examples:
* JSON file:./post -c wizbang events.json
* XML files: ./post -c records article*.xml
* CSV file: ./post -c signals LATEST-signals.csv
* Directory of files: ./post -c myfiles ~/Documents
* Web crawl: ./post -c gettingstarted http://lucene.apache.org/Solr -recursive 1 -delay 1
* Standard input (stdin): echo '{commit: {}}' | ./post -c my_collection -
type application/json -out yes –d
* Data as string: ./post -c signals -type text/csv -out yes -d $'id,value
1,0.47'
示例
假设我们有一个名为 sample.csv 的文件，其内容如下(在 bin 目录中)。
| Student ID | First Name | Lasst Name | Phone | City |
|---|---|---|---|---|
| 001 | Rajiv | Reddy | 9848022337 | Hyderabad |
| 002 | Siddharth | Bhattacharya | 9848022338 | Kolkata |
| 003 | Rajesh | Khanna | 9848022339 | Delhi |
| 004 | Preethi | Agarwal | 9848022330 | Pune |
| 005 | Trupthi | Mohanty | 9848022336 | Bhubaneshwar |
| 006 | Archana | Mishra | 9848022335 | Chennai |
上述数据集包含学生 ID、名字、姓氏、电话和城市等个人信息。数据集的 CSV 文件如下所示。在这里，您必须注意，您需要提及架构，记录其第一行。
id, first_name, last_name, phone_no, location 001, Pruthvi, Reddy, 9848022337, Hyderabad 002, kasyap, Sastry, 9848022338, Vishakapatnam 003, Rajesh, Khanna, 9848022339, Delhi 004, Preethi, Agarwal, 9848022330, Pune 005, Trupthi, Mohanty, 9848022336, Bhubaneshwar 006, Archana, Mishra, 9848022335, Chennai
您可以使用 post 命令将此数据索引到名为 sample_Solr 的核心下，如下所示 −
[Hadoop@localhost bin]$ ./post -c Solr_sample sample.csv
执行上述命令后，给定的文档将在指定的核心下建立索引，并生成以下输出。
/home/Hadoop/java/bin/java -classpath /home/Hadoop/Solr/dist/Solr-core 6.2.0.jar -Dauto = yes -Dc = Solr_sample -Ddata = files org.apache.Solr.util.SimplePostTool sample.csv SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/Solr/Solr_sample/update... Entering auto mode. File endings considered are xml,json,jsonl,csv,pdf,doc,docx,ppt,pptx,xls,xlsx,odt,odp,ods,ott,otp,ots,rtf, htm,html,txt,log POSTing file sample.csv (text/csv) to [base] 1 files indexed. COMMITting Solr index changes to http://localhost:8983/Solr/Solr_sample/update... Time spent: 0:00:00.228
使用以下 URL 访问 Solr Web UI 主页 −
http://localhost:8983/
选择核心 Solr_sample。默认情况下，请求处理程序为 /select，查询为":"。不做任何修改，单击页面底部的 ExecuteQuery 按钮。
执行查询时，您可以观察 JSON 格式(默认)的索引 CSV 文档的内容，如以下屏幕截图所示。
注意 −用同样的方式，您可以索引其他文件格式，例如 JSON、XML、CSV 等。
使用 Solr Web 界面添加文档
您还可以使用 Solr 提供的 Web 界面索引文档。让我们看看如何索引以下 JSON 文档。
[
{
"id" : "001",
"name" : "Ram",
"age" : 53,
"Designation" : "Manager",
"Location" : "Hyderabad",
},
{
"id" : "002",
"name" : "Robert",
"age" : 43,
"Designation" : "SR.Programmer",
"Location" : "Chennai",
},
{
"id" : "003",
"name" : "Rahim",
"age" : 25,
"Designation" : "JR.Programmer",
"Location" : "Delhi",
}
]
步骤 1
使用以下 URL − 打开 Solr Web 界面
http://localhost:8983/
步骤 2
选择核心 Solr_sample。默认情况下，字段 Request Handler、Common Within、Overwrite 和 Boost 的值分别为 /update、1000、true 和 1.0，如以下屏幕截图所示。
现在，从 JSON、CSV、XML 等中选择所需的文档格式。在文本区域中键入要索引的文档，然后单击 Submit Document 按钮，如以下屏幕截图所示。
使用 Java 客户端 API 添加文档
以下是将文档添加到 Apache Solr 索引的 Java 程序。将此代码保存在名为 AddingDocument.java 的文件中。
import java.io.IOException;
import org.apache.Solr.client.Solrj.SolrClient;
import org.apache.Solr.client.Solrj.SolrServerException;
import org.apache.Solr.client.Solrj.impl.HttpSolrClient;
import org.apache.Solr.common.SolrInputDocument;
public class AddingDocument {
public static void main(String args[]) throws Exception {
//准备 Solr 客户端
String urlString = "http://localhost:8983/Solr/my_core";
SolrClient Solr = new HttpSolrClient.Builder(urlString).build();
//准备 Solr 文档
SolrInputDocument doc = new SolrInputDocument();
//向文档添加字段
doc.addField("id", "003");
doc.addField("name", "Rajaman");
doc.addField("age","34");
doc.addField("addr","vishakapatnam");
//将文档添加到 Solr
Solr.add(doc);
//保存更改
Solr.commit();
System.out.println("Documents added");
}
}
通过在终端中执行以下命令来编译上述代码 −
[Hadoop@localhost bin]$ javac AddingDocument [Hadoop@localhost bin]$ java AddingDocument
执行上述命令后，您将获得以下输出。
Documents added
Apache Solr - 添加文档 (XML)
在上一章中，我们解释了如何将 JSON 和 .CSV 文件格式的数据添加到 Solr。在本章中，我们将演示如何使用 XML 文档格式将数据添加到 Apache Solr 索引中。
示例数据
假设我们需要使用 XML 文件格式将以下数据添加到 Solr 索引中。
| Student ID | First Name | Last Name | Phone | City |
|---|---|---|---|---|
| 001 | Rajiv | Reddy | 9848022337 | Hyderabad |
| 002 | Siddharth | Bhattacharya | 9848022338 | Kolkata |
| 003 | Rajesh | Khanna | 9848022339 | Delhi |
| 004 | Preethi | Agarwal | 9848022330 | Pune |
| 005 | Trupthi | Mohanty | 9848022336 | Bhubaneshwar |
| 006 | Archana | Mishra | 9848022335 | Chennai |
使用 XML 添加文档
要将上述数据添加到 Solr 索引中，我们需要准备一个 XML 文档，如下所示。将此文档保存在名为 sample.xml 的文件中。
<add>
<doc>
<field name = "id">001</field>
<field name = "first name">Rajiv</field>
<field name = "last name">Reddy</field>
<field name = "phone">9848022337</field>
<field name = "city">Hyderabad</field>
</doc>
<doc>
<field name = "id">002</field>
<field name = "first name">Siddarth</field>
<field name = "last name">Battacharya</field>
<field name = "phone">9848022338</field>
<field name = "city">Kolkata</field>
</doc>
<doc>
<field name = "id">003</field>
<field name = "first name">Rajesh</field>
<field name = "last name">Khanna</field>
<field name = "phone">9848022339</field>
<field name = "city">Delhi</field>
</doc>
<doc>
<field name = "id">004</field>
<field name = "first name">Preethi</field>
<field name = "last name">Agarwal</field>
<field name = "phone">9848022330</field>
<field name = "city">Pune</field>
</doc>
<doc>
<field name = "id">005</field>
<field name = "first name">Trupthi</field>
<field name = "last name">Mohanthy</field>
<field name = "phone">9848022336</field>
<field name = "city">Bhuwaeshwar</field>
</doc>
<doc>
<field name = "id">006</field>
<field name = "first name">Archana</field>
<field name = "last name">Mishra</field>
<field name = "phone">9848022335</field>
<field name = "city">Chennai</field>
</doc>
</add>
您可以看到，为将数据添加到索引而编写的 XML 文件包含三个重要标签，即 <add> </add>、<doc></doc> 和 < field >< /field >。
add − 这是将文档添加到索引的根标签。它包含一个或多个要添加的文档。
doc − 我们添加的文档应包装在 <doc></doc> 标签内。该文档包含字段形式的数据。
field − field 标签保存了文档字段的名称和值。
准备好文档后，您可以使用上一章中讨论的任何方法将此文档添加到索引中。
假设 XML 文件存在于 Solr 的 bin 目录中，并且要在名为 my_core 的核心中建立索引，那么您可以使用 post 工具将其添加到 Solr 索引中，如下所示 −
[Hadoop@localhost bin]$ ./post -c my_core sample.xml
执行上述命令后，您将获得以下输出。
/home/Hadoop/java/bin/java -classpath /home/Hadoop/Solr/dist/Solr- core6.2.0.jar -Dauto = yes -Dc = my_core -Ddata = files org.apache.Solr.util.SimplePostTool sample.xml SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/Solr/my_core/update... Entering auto mode. File endings considered are xml,json,jsonl,csv,pdf,doc,docx,ppt,pptx, xls,xlsx,odt,odp,ods,ott,otp,ots,rtf,htm,html,txt,log POSTing file sample.xml (application/xml) to [base] 1 files indexed. COMMITting Solr index changes to http://localhost:8983/Solr/my_core/update... Time spent: 0:00:00.201
验证
访问 Apache Solr Web 界面主页并选择核心 my_core。尝试通过在文本区域 q 中传递查询":"来检索所有文档并执行查询。执行时，您可以观察到所需的数据已添加到 Solr 索引中。
Apache Solr - 更新数据
使用 XML 更新文档
以下是用于更新现有文档中字段的 XML 文件。将其保存在名为 update.xml 的文件中。
<add>
<doc>
<field name = "id">001</field>
<field name = "first name" update = "set">Raj</field>
<field name = "last name" update = "add">Malhotra</field>
<field name = "phone" update = "add">9000000000</field>
<field name = "city" update = "add">Delhi</field>
</doc>
</add>
如您所见，更新数据所用的 XML 文件与我们添加文档时使用的 XML 文件一样。但唯一的区别是我们使用了字段的 update 属性。
在我们的示例中，我们将使用上述文档并尝试更新 ID 为 001 的文档的字段。
假设 XML 文档存在于 Solr 的 bin 目录中。由于我们正在更新名为 my_core 的核心中存在的索引，因此您可以使用 post 工具进行更新，如下所示 −
[Hadoop@localhost bin]$ ./post -c my_core update.xml
执行上述命令后，您将获得以下输出。
/home/Hadoop/java/bin/java -classpath /home/Hadoop/Solr/dist/Solr-core 6.2.0.jar -Dauto = yes -Dc = my_core -Ddata = files org.apache.Solr.util.SimplePostTool update.xml SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/Solr/my_core/update... Entering auto mode. File endings considered are xml,json,jsonl,csv,pdf,doc,docx,ppt,pptx,xls,xlsx,odt,odp,ods,ott,otp,ots,rtf, htm,html,txt,log POSTing file update.xml (application/xml) to [base] 1 files indexed. COMMITting Solr index changes to http://localhost:8983/Solr/my_core/update... Time spent: 0:00:00.159
验证
访问 Apache Solr Web 界面的主页，并选择核心为 my_core。尝试通过在文本区域 q 中传递查询":"来检索所有文档，然后执行查询。执行时，您可以观察到文档已更新。
使用 Java(客户端 API)更新文档
以下是将文档添加到 Apache Solr 索引的 Java 程序。将此代码保存在名为 UpdatingDocument.java 的文件中。
import java.io.IOException;
import org.apache.Solr.client.Solrj.SolrClient;
import org.apache.Solr.client.Solrj.SolrServerException;
import org.apache.Solr.client.Solrj.impl.HttpSolrClient;
import org.apache.Solr.client.Solrj.request.UpdateRequest;
import org.apache.Solr.client.Solrj.response.UpdateResponse;
import org.apache.Solr.common.SolrInputDocument;
public class UpdatingDocument {
public static void main(String args[]) throws SolrServerException, IOException {
//准备 Solr 客户端
String urlString = "http://localhost:8983/Solr/my_core";
SolrClient Solr = new HttpSolrClient.Builder(urlString).build();
//准备 Solr 文档
SolrInputDocument doc = new SolrInputDocument();
UpdateRequest updateRequest = new UpdateRequest();
updateRequest.setAction( UpdateRequest.ACTION.COMMIT, false, false);
SolrInputDocument myDocumentInstantlycommited = new SolrInputDocument();
myDocumentInstantlycommited.addField("id", "002");
myDocumentInstantlycommited.addField("name", "Rahman");
myDocumentInstantlycommited.addField("age","27");
myDocumentInstantlycommited.addField("addr","hyderabad");
updateRequest.add( myDocumentInstantlycommited);
UpdateResponse rsp = updateRequest.process(Solr);
System.out.println("Documents Updated");
}
}
通过在终端中执行以下命令来编译上述代码 −
[Hadoop@localhost bin]$ javac UpdatingDocument [Hadoop@localhost bin]$ java UpdatingDocument
执行上述命令后，您将获得以下输出。
Documents updated
Apache Solr - 删除文档
删除文档
要从 Apache Solr 的索引中删除文档，我们需要在 <delete></delete> 标签之间指定要删除的文档的 ID。
<delete> <id>003</id> <id>005</id> <id>004</id> <id>002</id> </delete>
此处，此 XML 代码用于删除 ID 为 003 和 005 的文档。将此代码保存在名为 delete.xml 的文件中。
如果要从属于名为 my_core 的核心的索引中删除文档，则可以使用 post 工具发布 delete.xml 文件，如下所示。
[Hadoop@localhost bin]$ ./post -c my_core delete.xml
执行上述命令后，您将获得以下输出。
/home/Hadoop/java/bin/java -classpath /home/Hadoop/Solr/dist/Solr-core 6.2.0.jar -Dauto = yes -Dc = my_core -Ddata = files org.apache.Solr.util.SimplePostTool delete.xml SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/Solr/my_core/update... Entering auto mode. File endings considered are xml,json,jsonl,csv,pdf,doc,docx,ppt,pptx,xls,xlsx,odt,odp,ods,ott,otp,ots, rtf,htm,html,txt,log POSTing file delete.xml (application/xml) to [base] 1 files indexed. COMMITting Solr index changes to http://localhost:8983/Solr/my_core/update... Time spent: 0:00:00.179
验证
访问 Apache Solr Web 界面的主页，并选择核心为 my_core。尝试通过在文本区域 q 中传递查询":"来检索所有文档，然后执行查询。执行时，您可以观察到指定的文档已被删除。
删除字段
有时我们需要根据 ID 以外的字段删除文档。例如，我们可能必须删除城市为 Chennai 的文档。
在这种情况下，您需要在 <query></query> 标签对中指定字段的名称和值。
<delete> <query>city:Chennai</query> </delete>
将其保存为delete_field.xml，并使用Solr的post工具对名为my_core的核心执行删除操作。
[Hadoop@localhost bin]$ ./post -c my_core delete_field.xml
执行上述命令后，会产生以下输出。
/home/Hadoop/java/bin/java -classpath /home/Hadoop/Solr/dist/Solr-core 6.2.0.jar -Dauto = yes -Dc = my_core -Ddata = files org.apache.Solr.util.SimplePostTool delete_field.xml SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/Solr/my_core/update... Entering auto mode. File endings considered are xml,json,jsonl,csv,pdf,doc,docx,ppt,pptx,xls,xlsx,odt,odp,ods,ott,otp,ots, rtf,htm,html,txt,log POSTing file delete_field.xml (application/xml) to [base] 1 files indexed. COMMITting Solr index changes to http://localhost:8983/Solr/my_core/update... Time spent: 0:00:00.084
验证
访问 Apache Solr 网页界面主页，选择核心为 my_core。尝试通过在文本区域 q 中传递查询":"来检索所有文档并执行查询。执行时，您可以观察到包含指定字段值对的文档已被删除。
删除所有文档
就像删除特定字段一样，如果您想从索引中删除所有文档，只需在标签 <query></ query> 之间传递符号":"，如下所示。
<delete> <query>*:*</query> </delete>
将其保存为delete_all.xml，并使用Solr的post工具对名为my_core的核心执行删除操作。
[Hadoop@localhost bin]$ ./post -c my_core delete_all.xml
执行上述命令时，会产生以下输出。
/home/Hadoop/java/bin/java -classpath /home/Hadoop/Solr/dist/Solr-core 6.2.0.jar -Dauto = yes -Dc = my_core -Ddata = files org.apache.Solr.util.SimplePostTool deleteAll.xml SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/Solr/my_core/update... Entering auto mode. File endings considered are xml,json,jsonl,csv,pdf,doc,docx,ppt,pptx,xls,xlsx,odt,odp,ods,ott,otp,ots,rtf, htm,html,txt,log POSTing file deleteAll.xml (application/xml) to [base] 1 files indexed. COMMITting Solr index changes to http://localhost:8983/Solr/my_core/update... Time spent: 0:00:00.138
验证
访问 Apache Solr Web 界面主页并选择核心为 my_core。尝试通过在文本区域 q 中传递查询":"来检索所有文档并执行查询。执行时，您可以观察到包含指定字段值对的文档已被删除。
使用 Java(客户端 API)删除所有文档
以下是将文档添加到 Apache Solr 索引的 Java 程序。将此代码保存在名为 UpdatingDocument.java 的文件中。
import java.io.IOException;
import org.apache.Solr.client.Solrj.SolrClient;
import org.apache.Solr.client.Solrj.SolrServerException;
import org.apache.Solr.client.Solrj.impl.HttpSolrClient;
import org.apache.Solr.common.SolrInputDocument;
public class DeletingAllDocuments {
public static void main(String args[]) throws SolrServerException, IOException {
//准备 Solr 客户端
String urlString = "http://localhost:8983/Solr/my_core";
SolrClient Solr = new HttpSolrClient.Builder(urlString).build();
//准备 Solr 文档
SolrInputDocument doc = new SolrInputDocument();
//从 Solr 中删除文档
Solr.deleteByQuery("*");
//保存文档
Solr.commit();
System.out.println("Documents deleted");
}
}
通过在终端中执行以下命令来编译上述代码 −
[Hadoop@localhost bin]$ javac DeletingAllDocuments [Hadoop@localhost bin]$ java DeletingAllDocuments
执行上述命令后，您将获得以下输出。
Documents deleted
Apache Solr - 检索数据
在本章中，我们将讨论如何使用 Java 客户端 API 检索数据。假设我们有一个名为 sample.csv 的 .csv 文档，内容如下。
001,9848022337,Hyderabad,Rajiv,Reddy 002,9848022338,Kolkata,Siddarth,Battacharya 003,9848022339,Delhi,Rajesh,Khanna
您可以使用 post 命令在名为 sample_Solr 的核心下索引此数据。
[Hadoop@localhost bin]$ ./post -c Solr_sample sample.csv
以下是将文档添加到 Apache Solr 索引的 Java 程序。将此代码保存在名为 RetrievingData.java 的文件中。
import java.io.IOException;
import org.apache.Solr.client.Solrj.SolrClient;
import org.apache.Solr.client.Solrj.SolrQuery;
import org.apache.Solr.client.Solrj.SolrServerException;
import org.apache.Solr.client.Solrj.impl.HttpSolrClient;
import org.apache.Solr.client.Solrj.response.QueryResponse;
import org.apache.Solr.common.SolrDocumentList;
public class RetrievingData {
public static void main(String args[]) throws SolrServerException, IOException {
//准备 Solr 客户端
String urlString = "http://localhost:8983/Solr/my_core";
SolrClient Solr = new HttpSolrClient.Builder(urlString).build();
//准备 Solr 查询
SolrQuery query = new SolrQuery();
query.setQuery("*:*");
//添加要检索的字段
query.addField("*");
//执行查询
QueryResponse queryResponse = Solr.query(query);
//存储查询结果
SolrDocumentList docs = queryResponse.getResults();
System.out.println(docs);
System.out.println(docs.get(0));
System.out.println(docs.get(1));
System.out.println(docs.get(2));
//保存操作
Solr.commit();
}
}
通过在终端中执行以下命令来编译上述代码 −
[Hadoop@localhost bin]$ javac RetrievingData [Hadoop@localhost bin]$ java RetrievingData
执行上述命令后，您将获得以下输出。
{numFound = 3,start = 0,docs = [SolrDocument{id=001, phone = [9848022337],
city = [Hyderabad], first_name = [Rajiv], last_name = [Reddy],
_version_ = 1547262806014820352}, SolrDocument{id = 002, phone = [9848022338],
city = [Kolkata], first_name = [Siddarth], last_name = [Battacharya],
_version_ = 1547262806026354688}, SolrDocument{id = 003, phone = [9848022339],
city = [Delhi], first_name = [Rajesh], last_name = [Khanna],
_version_ = 1547262806029500416}]}
SolrDocument{id = 001, phone = [9848022337], city = [Hyderabad], first_name = [Rajiv],
last_name = [Reddy], _version_ = 1547262806014820352}
SolrDocument{id = 002, phone = [9848022338], city = [Kolkata], first_name = [Siddarth],
last_name = [Battacharya], _version_ = 1547262806026354688}
SolrDocument{id = 003, phone = [9848022339], city = [Delhi], first_name = [Rajesh],
last_name = [Khanna], _version_ = 1547262806029500416}
Apache Solr - 查询数据
除了存储数据之外，Apache Solr 还提供在需要时查询数据的功能。 Solr 提供了某些参数，我们可以使用这些参数查询存储在其中的数据。
在下表中，我们列出了 Apache Solr 中可用的各种查询参数。
| 参数 | 描述 |
|---|---|
| q | 这是 Apache Solr 的主要查询参数，文档根据其与此参数中的术语的相似性进行评分。 |
| fq | 此参数表示 Apache Solr 的过滤查询，将结果集限制为与此过滤器匹配的文档。 |
| start | start 参数表示页面结果的起始偏移量，此参数的默认值为 0。 |
| rows | 此参数表示每页要检索的文档数。此参数的默认值为 10。 |
| sort | 此参数指定查询结果排序所依据的字段列表(以逗号分隔)。 |
| fl | 此参数指定结果集中每个文档要返回的字段列表。 |
| wt | 此参数表示我们想要查看结果的响应编写器的类型。 |
您可以将所有这些参数视为查询 Apache Solr 的选项。访问 Apache Solr 主页。在页面左侧，单击选项查询。在这里，您可以看到查询参数的字段。
检索记录
假设我们在名为 my_core 的核心中有 3 条记录。要从选定的核心检索特定记录，您需要传递特定文档的字段的名称和值对。例如，如果您想检索字段值为 id 的记录，您需要将该字段的名称-值对作为 − 传递Id:001 作为参数 q 的值并执行查询。
以同样的方式，您可以通过将 *:* 作为值传递给参数 q 来从索引中检索所有记录，如以下屏幕截图所示。
从第二条记录检索
我们可以通过将 2 作为值传递给参数 start 来从第二条记录检索记录，如以下屏幕截图所示。
限制记录数
您可以通过在 rows 参数中指定一个值来限制记录数。例如，我们可以通过将值 2 传递给参数 rows 来将查询结果中的记录总数限制为 2，如以下屏幕截图所示。
响应编写器类型
您可以通过从参数 wt 提供的值中选择一个来获取所需文档类型的响应。
在上述实例中，我们选择了 .csv 格式来获取响应。
字段列表
如果我们想在结果文档中包含特定字段，我们需要将所需字段的列表(以逗号分隔)作为值传递给属性 fl。
在下面的例子中，我们尝试检索字段 − id、phone 和 first_name。
Apache Solr - 分面
Apache Solr 中的分面是指将搜索结果分为不同的类别。在本章中，我们将讨论 Apache Solr 中可用的分面类型 −
查询分面 − 它返回当前搜索结果中与给定查询匹配的文档数量。
日期分面 −它返回属于特定日期范围内的文档数量。
Faceting 命令可添加到任何常规 Solr 查询请求中，并且 Faceting 计数会在同一查询响应中返回。
Faceting 查询示例
使用字段 faceting，我们可以检索所有术语的计数，或者仅检索任何给定字段中的顶级术语。
作为示例，让我们考虑以下包含有关各种书籍的数据的 books.csv 文件。
id,cat,name,price,inStock,author,series_t,sequence_i,genre_s 0553573403,book,A Game of Thrones,5.99,true,George R.R. Martin,"A Song of Ice and Fire",1,fantasy 0553579908,book,A Clash of Kings,10.99,true,George R.R. Martin,"A Song of Ice and Fire",2,fantasy 055357342X,book,A Storm of Swords,7.99,true,George R.R. Martin,"A Song of Ice and Fire",3,fantasy 0553293354,book,Foundation,7.99,true,Isaac Asimov,Foundation Novels,1,scifi 0812521390,book,The Black Company,4.99,false,Glen Cook,The Chronicles of The Black Company,1,fantasy 0812550706,book,Ender's Game,6.99,true,Orson Scott Card,Ender,1,scifi 0441385532,book,Jhereg,7.95,false,Steven Brust,Vlad Taltos,1,fantasy 0380014300,book,Nine Princes In Amber,6.99,true,Roger Zelazny,the Chronicles of Amber,1,fantasy 0805080481,book,The Book of Three,5.99,true,Lloyd Alexander,The Chronicles of Prydain,1,fantasy 080508049X,book,The Black Cauldron,5.99,true,Lloyd Alexander,The Chronicles of Prydain,2,fantasy
让我们使用 post 工具将此文件发布到 Apache Solr。
[Hadoop@localhost bin]$ ./post -c Solr_sample sample.csv
执行上述命令后，给定 .csv 文件中提到的所有文档都将上传到 Apache Solr。
现在让我们对集合/核心 my_core 上具有 0 行的字段 author 执行分面查询。
打开 Apache Solr 的 Web UI，在页面左侧选中复选框 facet，如以下屏幕截图所示。
选中复选框后，您将在以便传递 facet 搜索的参数。现在，作为查询的参数，传递以下值。
q = *:*, rows = 0, facet.field = author
最后，通过单击 Execute Query 按钮执行查询。
执行时，将产生以下结果。
它根据作者对索引中的文档进行分类，并指定每个作者贡献的书籍数量。
使用 Java 客户端 API 进行分面
以下是将文档添加到 Apache Solr 索引的 Java 程序。将此代码保存在名为 HitHighlighting.java 的文件中。
import java.io.IOException;
import java.util.List;
import org.apache.Solr.client.Solrj.SolrClient;
import org.apache.Solr.client.Solrj.SolrQuery;
import org.apache.Solr.client.Solrj.SolrServerException;
import org.apache.Solr.client.Solrj.impl.HttpSolrClient;
import org.apache.Solr.client.Solrj.request.QueryRequest;
import org.apache.Solr.client.Solrj.response.FacetField;
import org.apache.Solr.client.Solrj.response.FacetField.Count;
import org.apache.Solr.client.Solrj.response.QueryResponse;
import org.apache.Solr.common.SolrInputDocument;
public class HitHighlighting {
public static void main(String args[]) throws SolrServerException, IOException {
//准备 Solr 客户端
String urlString = "http://localhost:8983/Solr/my_core";
SolrClient Solr = new HttpSolrClient.Builder(urlString).build();
//准备 Solr 文档
SolrInputDocument doc = new SolrInputDocument();
//String query = request.query;
SolrQuery query = new SolrQuery();
//设置查询字符串
query.setQuery("*:*");
//设置行数
query.setRows(0);
//添加 facet 字段
query.addFacetField("author");
//创建查询请求
QueryRequest qryReq = new QueryRequest(query);
//创建查询响应
QueryResponse resp = qryReq.process(Solr);
//检索响应字段
System.out.println(resp.getFacetFields());
List<FacetField> facetFields = resp.getFacetFields();
for (int i = 0; i > facetFields.size(); i++) {
FacetField facetField = facetFields.get(i);
List<Count> facetInfo = facetField.getValues();
for (FacetField.Count facetInstance : facetInfo) {
System.out.println(facetInstance.getName() + " : " +
facetInstance.getCount() + " [drilldown qry:" +
facetInstance.getAsFilterQuery());
}
System.out.println("Hello");
}
}
}
通过在终端中执行以下命令来编译上述代码 −
[Hadoop@localhost bin]$ javac HitHighlighting [Hadoop@localhost bin]$ java HitHighlighting
执行上述命令后，您将获得以下输出。
[author:[George R.R. Martin (3), Lloyd Alexander (2), Glen Cook (1), Isaac Asimov (1), Orson Scott Card (1), Roger Zelazny (1), Steven Brust (1)]]
