Hadoop 数据分析高级教程（一）
原文：Pro Hadoop Data Analytics协议：CC BY-NC-SA 4.0
一、概述：利用 Hadoop 构建数据分析系统
这本书是关于计划和实现摄取、分析和可视化大数据集的软件系统。在整本书中，我们将利用缩写词 BDA 或 BDAs(大数据分析系统)来描述这种软件。大数据自己值得表明一下。作为计算机步伐员和架构师，我们知道我们现在所说的“大数据”已经存在了很长时间，究竟上已经有几十年了，因为“大数据”一直是一个相对的多维术语，一个不但仅由数据大小定义的空间。复杂性、速率、正确性，固然另有数据的大小和数目，都是任何现代“大数据集”的维度。
在本章中，我们将讨论什么是利用 Hadoop 的大数据分析系统(BDA ),为什么它们很重要，可以利用哪些数据源、接收器和存储库，以及适合和不适合利用 Hadoop 的分布式系统方法的候选应用步伐。我们还扼要讨论了构建这种范例系统的 Hadoop/Spark 范例的一些替换方案。
软件开发一直都有一种紧迫感，大数据分析的开发也不例外。即使在即将成为新兴行业的早期，大数据分析也要求能够以更快的速率和更深层次的理解来处理和分析越来越多的数据。当我们查抄软件系统架构和开发的实际细节时，以更全面的方式处理越来越多的数据的基本需求一直是抽象计算机科学和应用计算机技术等的关键目的。同样，大数据应用和系统也不例外。如图 1-1 所示，当我们考虑到可用的环球数据资源在过去几年中是如何爆炸式增长的，这就不足为奇了。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig1_HTML.jpg&pos_id=img-p9nQe8Uh-1723617460896
图 1-1。
Annual data volume statistics
由于软件组件的快速发展和廉价的现成处理能力，再加上软件开发自己的快速发展，希望为自己的应用步伐构建 BDA 的架构师和步伐员经常会对他们在 BDA 舞台上面临的技术和战略选择感到不知所措。在这一先容性章节中，我们将对 BDA 的景观做一个高层次的概述，并试图确定在建设 BDAs 时我们必要问自己的一些技术问题。
1.1 对分布式分析系统的需求
我们必要分布式大数据分析，因为传统的业务分析不足以满足现代分析应用步伐对数据量、复杂性、多样性和高数据处理速率的需求。除了软件之外，大数据分析形势在另一方面发生了巨大变化。硬件成本——包括计算和存储——已经大幅下降。Hadoop 等工具依靠于成本相对较低的机器和磁盘集群，使分布式处理成为一样寻常实际，对于大规模数据项目来说，分布式处理也是必要的。也有很多支持软件(框架、库和工具包)用于进行分布式计算。究竟上，选择技术堆栈的问题已经成为一个严重的问题，仔细关注应用步伐需求和可用资源是至关重要的。
历史上，硬件技术定义了软件组件的能力限定，尤其是在数据分析方面。传统的数据分析意味着对简朴的基于文件的数据集或与关系数据存储的直接连接进行统计可视化(直方图、饼图和表格报告)。计算引擎通常利用单个服务器上的批处理来实现。在分布式计算这个勇敢的新天下中，利用计算机集群分而治之办理大数据问题已经成为一种标准的计算方式:这种可扩展性允许我们超越单台计算机的能力边界，并根据我们的必要(或我们的蒙受能力)添加尽可能多的现成硬件。Ambari、Zookeeper 或策展人等软件工具帮助我们管理集群，并提供集群资源的可伸缩性和高可用性。
1.2 Hadoop 焦点和少量历史
一些软件想法已经存在了很长时间，以至于它乃至不再是计算机历史——而是计算机考古学。“map-reduce”问题办理方法的思想可以追溯到第二古老的编程语言 LISP(列表处理),可以追溯到 20 世纪 50 年代。“地图” “缩小”“send”和“lambda”是 LISP 语言自己的标准函数！几十年后，我们现在所知的 Apache Hadoop，即基于 Java 的开源分布式处理框架，并不是“从零开始”的。它是从 Apache Nutch 演化而来的，Apache Nutch 是一个开源的网络搜刮引擎，而后者又是基于 Apache Lucene 的。有趣的是，R 统计库(我们也将在后面的章节中深入讨论)也受到 LISP 的影响，并且最初是用 LISP 语言编写的。
在我们谈论 Hadoop 生态系统之前，Hadoop 焦点组件值得一提。顾名思义，Hadoop 焦点是 Hadoop 框架的本质[图 1.1]。支持组件、架构，固然另有辅助库、问题办理组件和称为 Hadoop 生态系统的子框架都构建在 Hadoop 焦点底子之上，如图 1-2 所示。请注意，在本书的范围内，我们将不会讨论 Hadoop 1，因为它已经被利用 YARN(又一个资源协商器)的新的重新实现所代替。请注意，在 Hadoop 2 系统中，MapReduce 并没有消失，它只是被模块化并抽象成一个组件，可以与其他数据处理模块很好地配合。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig2_HTML.jpg&pos_id=img-OfDj4Lfg-1723617460896
图 1-2。
Hadoop 2 Core diagram
1.3 Hadoop 生态系统概述
Hadoop 及其生态系统，加上围绕它们发展起来的新框架和库，仍然是大数据分析领域不可忽视的力量。本书的别的部分将帮助您针对大数据分析挑衅订定有针对性的应对措施，同时提供最基本的配景知识，帮助您学习办理大数据分析问题的新方法。Hadoop 及其生态系统通常分为四个主要类别或功能块，如图 1-3 所示。您会注意到，我们包括了几个额外的模块，以表现对软件“粘合”组件以及某种安全功能的需求。您还可以根据自己的需求向 BDA 系统添加支持库和框架。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig3_HTML.jpg&pos_id=img-oxWihlxo-1723617460896
图 1-3。
Hadoop 2 Technology Stack diagram Note
在本书中，我们将继续强调免费的第三方组件，比如前面提到的 Apache 组件和库。这并不意味着您不能将您喜好的图数据库(大概关系数据库)作为数据源集成到您的 BDAs 中。我们还将强调开源组件的灵活性和模块化，这允许您用最少的附加软件“粘合剂”将数据管道组件连接在一起在我们的讨论中，我们将利用 Spring 框架的 Spring 数据组件，以及 Apache Camel，来提供集成的“粘合”支持来链接我们的组件。
1.4 人工智能技术、认知计算、深度学习和大数据分析
大数据分析不再仅仅是简朴的统计分析。随着 BDA 及其支持框架的发展，来自机器学习(ML)人工智能(AI)、图像和信号处理以及其他复杂技术(包括所谓的“认知计算”技术)的技术已经成熟，并成为数据分析师工具包的标准组件。
1.5 自然语言处理和 BDAs
究竟证实，自然语言处理(NLP)组件在大量不同的领域都很有效，从扫描息争释收据和发票到复杂的药房处方数据和医院病历处理，以及大量存在非结构化和半结构化数据的很多其他领域。在处理这种“混合搭配”的数据源时，Hadoop 是一个自然的选择，在这种数据源中，条形码、署名、图像和信号、地理空间数据(GPS 位置)和其他数据范例可能会混合在一起。Hadoop 也是进行各种大规模文档分析的一种非常强盛的手段。
我们将在单独的一章中讨论所谓的“语义网”技术，如分类法和本体论、基于规则的控制和 NLP 组件。现在，可以说 NLP 已经走出了研究领域，进入了实际应用步伐开发的领域，有各种各样的工具包和库可供选择。我们将在本书中讨论的一些 NLP 工具包是基于 Python 的自然语言工具包(NLTK)、斯坦福 NLP 和 Digital Pebble 的庞然大物，这是一个基于 Apache Hadoop 的用于大规模文档分析的开源平台。 1
1.6 SQL 和 NoSQL 查询
除非被查询，否则数据是没有效的。查询数据集的过程——无论是键值对集合、Oracle 或 MySQL 的关系数据库结果集，照旧 Neo4j 或 Apache Giraph 等图数据库中的顶点和边的表示——都必要我们对数据进行过滤、排序、分组、构造、比较、分区和评估。这导致了 SQL 等查询语言的发展，以及与 HBase、Cassandra、MongoDB、CouchBase 等“NoSQL”组件和数据库相干的查询语言的所有变种和变体。在本书中，我们将集中利用 read-eval-print 循环(REPLs)、交互式 shells(如 IPython)和其他交互式工具来表达我们的查询，并且我们将尽可能地将我们的查询与众所周知的 SQL 概念相干联，而不管它们与什么软件组件相干联。例如，一些图数据库如 Neo4j(我们将在后面的章节中具体讨论)有它们自己的类似 SQL 的查询语言。在整本书中，我们将尽可能地对峙类似 SQL 的查询传统，但是我们会指出一些有趣的 SQL 范例的替换方案。
1.7 必要的数学
在本书中，我们将保持数学最小化。然而，偶然候，一个数学等式不但仅是一个必要的邪恶。偶然候，理解你的问题并实现你的办理方案的最佳方式是数学途径——同样，在某些情况下,“必要的数学”成为办理难题的关键因素。数据模型、神经网络、单个或多个分类器以及贝叶斯图技术要求至少对这些系统的潜伏动态有所相识。而且，对于步伐员和架构师来说，必要的数学险些总是可以被转换成有效的算法，并从那里转换成有效的实现。
1.8 计划和构建 BDA 系统的循环流程
如今，在构建 BDAs 方面有很多好消息。Apache Spark 及其内存计算模型的出现是一个重要的积极因素，但是另有其他几个原因可以表明为什么构建 BDAs 从来没有这么简朴。这些原因包括:
[*]丰富的框架和 ide 来帮助开发；
[*]成熟且颠末充分测试的组件，用于帮助构建 BDAs，如果您必要，还可以利用公司支持的 BDA 产品。框架成熟度(比如 Spring 框架、Spring Data subframework、Apache Camel 等等)通过提供可靠的焦点底子设施来帮助分布式系统开发。
[*]一个重要的在线和面临面的 BDA 开发社区，有无数的开发者论坛和聚会。如果您遇到了与 BDA 计划和开发相干的架构或技术问题，用户社区中的某个人可能会为您提供有效的发起。
在本书中，我们将利用以下九个步调来指定和创建我们的 BDA 示例系统。这个过程只是提示性的。您可以按原样利用下面列出的过程，对其进行自己的修改，添加或减少结构或步调，大概提出自己的开发过程。这取决于你。我们发现以下步调对于规划和构造 BDA 项目以及我们开发和构建项目时出现的一些问题特殊有效。
您可能会注意到问题和需求定义、实现、测试和文档被归并到一个团体过程中。这里描述的过程非常适合于快速迭代开发过程，此中所利用的需求和技术在开发周期中相对稳定。
定义和构建 BDA 系统的基本步调如下。团体循环如图 1-4 所示。
[*]确定 BDA 系统的要求。开发的初始阶段必要生成技术、资源、技术和策略以及实现目的所需的其他组件的概要。最初的目的集(固然会有变化)必要被固定、排序和明白定义。众所周知，随着对项目需求相识的加深，目的和其他要求也会发生变化。BDA 系统有特殊要求(可能包括 Hadoop 集群中的内容、特殊数据源、用户界面、报告和仪表板要求)。列出数据源范例、数据接收器范例、必要的分析、转换、验证和数据安全问题。能够使您的需求适应 BDA 技术的可塑性和易变的本质，将确保您能够以模块化、有构造的方式修改您的系统。确定组件中的计算和进程，确定是否必要批处理或流处理(或两者都必要),并绘制计算引擎的流程图。这将有助于定义和理解系统的“业务逻辑”。
[*]定义初始技术堆栈。初始技术堆栈将包括一个 Hadoop 焦点以及适合您在上一步中定义的要求的得当生态系统组件。如果您必要流支持，您可以包括 Apache Spark，大概您正在利用我们在本书后面讨论的基于 Spark 的机器学习库。记住你将要利用的编程语言。如果你利用的是 Hadoop，Java 语言将是栈的一部分。如果你用的是 Apache Spark，也会用到 Scala 语言。Python 有很多非常有趣的特殊应用，我们将在后面的章节中讨论。如果其他语言绑定是需求的一部分，也可以利用。
[*]定义数据源、输入和输出数据格式以及数据清理过程。在需求网络阶段(步调 0)，您制作了数据源/接收器范例的初始列表，并制作了顶层流程图来帮助定义您的数据管道。在 BDA 系统中可能会用到很多外来的数据源，包括图像、地理空间位置、时间戳、日志文件等等，以是要保持一个数据源(和数据宿)的最新列表。)范例，就像您做最初的计划工作一样方便。
[*]定义、网络和构造初始数据集。您可能有项目的初始数据、测试和训练数据(本书后面会有更多关于训练数据的内容)、来自以前系统的遗留数据，大概根本没有数据。考虑数据集的最小数目(数目、种类和容量),并订定一个获取或生成所需数据的操持。请注意，当您添加新代码时，可能必要新的数据集来执行充分的测试。初始数据集应该测试数据管道的每个模块，确保精确执行端到端处理。
[*]定义要执行的计算。概念形式的业务逻辑来自需求阶段，但是这个逻辑是什么以及它是如何实现的将随着时间的推移而改变。在这个阶段，定义要在数据元素上执行的输入、输出、规则和转换。这些定义在步调 6 中被转化为计算引擎的实现。
[*]预处理数据集以供计算引擎利用。偶然数据集必要预处理:验证、安全查抄、清理、转换成更适合处理的格式，以及其他几个步调。有一个要满足的预处理目的的清单，并在整个开发周期中继续关注这些问题，并随着开发的进展进行必要的修改。
[*]定义计算引擎步调；定义结果格式。计算引擎的业务逻辑、流程、结果的正确性、算法和实现的精确性以及服从将总是必要被质疑和改进。
[*]将过滤后的结果放入数据接收器的结果存储库中。数据接收器是保存数据管道最终输出的数据堆栈。在准备好报告或表现您的输出数据之前，可能有几个过滤或转换步调。您的分析的最终结果可以存储在文件、数据库、临时存储库、报告或任何需求中。请记住，用户在 UI 或仪表板上的操纵可能会影响输出的格式、音量和表现。这些交互结果中的一些可能必要持久存储回数据存储。构造专门针对数据输出、报告、表示和持久性的需求列表。
[*]定义和构建输出报告、仪表板和其他输出表现和控制。生成的输出表现和报告清楚地表现了所有分析计算的结果。BDA 系统的这一组件通常至少部分是用 JavaScript 编写的，并且可以利用复杂的数据可视化库来辅助不同种类的仪表板、报告和其他输出表现。
[*]记录、测试、提炼和重复。如果有必要的话，我们可以在细化需求、栈、算法、数据集等之后，再一次经历这些步调。文档最初由您在最后七个步调中所做的笔记组成，但是随着项目的进展，必要进行改进和重写。测试必要在每个周期中被创建、精炼和改进。趁便提一下，每个开发周期都可以被以为是一个版本，一次迭代，大概你喜好的构造你的步伐周期的方式。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig4_HTML.jpg&pos_id=img-jTRYIkLP-1723617460897
图 1-4。
A cyclic process for designing and building BDAs
这就是了。系统地利用这个迭代过程将使你能够计划和构建与本书中描述的系统相媲美的 BDA 系统。
1.9 Hadoop 生态系统如何实现大数据分析
Hadoop 生态系统通过在数据管道架构中将所有必要的分析要素(数据源、转换、底子设施、持久性和可视化)链接在一起来实现大数据分析，同时允许这些组件以分布式方式运行。Hadoop 焦点(大概在某些情况下，Apache Spark 乃至是同时利用 Hadoop 和 Storm 的混合系统)通过 ZooKeeper、Curator 和 Ambari 等组件提供分布式系统底子设施和集群(节点)协调。在 Hadoop 焦点之上，生态系统为分析、可视化、持久性和报告提供了复杂的库。
Hadoop 生态系统不但仅是 Hadoop 焦点功能的附加库。该生态系统提供了集成的无缝组件，Hadoop 焦点专为办理特定的分布式问题而计划。例如，Apache Mahout 提供了一个分布式机器学习算法工具包。
拥有一些颠末深图远虑的 API 可以很轻易地将我们的数据源链接到我们的 Hadoop 引擎和其他计算元素。借助 Apache Camel、Spring Framework、Spring Data 和 Apache Tika 的“粘合”功能，我们将能够将所有组件链接到一个有效的数据流引擎中。
1.10“图像即大数据”的理念(IABD)
图像——实际上是各种图片和信号——是“大数据范例”信息的最广泛、最有效、最复杂的泉源之一。
图像偶然被以为是称为像素的原子单元的二维阵列，究竟上(以及一些相干联的元数据)，这通常是图像在诸如 Java 的计算机编程语言中以及在诸如 Java 高级成像(JAI)、OpenCV 和 BoofCV 等相干联的图像处理库中的表示方式。然而，生物系统从这些“二维阵列”中“拉出东西”:线条和外形、颜色、元数据和上下文、边缘、曲线以及所有这些之间的关系。很快就变得显而易见的是，图像(趁便提一下，相干数据，如时间序列和来自传感器(如麦克风或测距仪)的“信号”)是大数据的最佳示例范例之一，有人可能会说，图像的分布式大数据分析是受生物系统的开导。究竟，我们中的很多人每次驾驶汽车时都会将非常复杂的三维立体视觉处理作为一个分布式系统来执行。
关于将影像作为大数据源的好消息是，它不再像以前那样困难了。复杂的库可用于与 Hadoop 和其他必要的组件接口，如图数据库或 Apache Kafka 等消息通报组件。如有必要，OpenCV 或 BoofCV 等低级库可以提供图像处理原语。编写代码既简便又轻易。例如，我们可以用下面的 Java 类编写一个简朴的、可滚动的图像查看器(如清单 1-1 所示)。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig5_HTML.jpg&pos_id=img-ZCDx8IK0-1723617460897
图 1-5。
Sophisticated third-party libraries make it easy to build image visualization components in just a few lines of code
package com.kildane.iabt;
import java.awt.image.RenderedImage;
import java.io.File;
import java.io.IOException;
import javax.media.jai.JAI;
import javax.imageio.ImageIO;
import javax.media.jai.PlanarImage;
import javax.media.jai.widget.
ScrollingImagePanel;
import javax.swing.JFrame;
/**
* Hello IABT world!
* The worlds most powerful image processing toolkit (for its size)?
*/
public class App
{
public static void main(String[] args)
{
JAI jai = new JAI();
RenderedImage image = null;
try {
image = ImageIO.read(new File("/Users/kerryk/Documents/SA1_057_62_hr4.png"));
} catch (IOException e) {
e.printStackTrace();
}
if (image == null){ System.out.println("Sorry, the image was null"); return; }
JFrame f = new JFrame("Image Processing Demo for Pro Hadoop Data Analytics");
ScrollingImagePanel panel = new ScrollingImagePanel
(image, 512, 512);
f.add(panel);
f.setSize(512, 512);
f.setVisible(true);
System.out.println("Hello IABT World, version of JAI is: " + JAI.getBuildVersion());
}
}
Listing 1-1.Hello image world: Java code for an image visualizer stub
as shown in Figure 1-5
然而，一个简朴的图像欣赏器只是图像 BDA 系统的开始。有低级别的图像处理、特性提取、转换成得当的数据表示以供分析，最后将结果加载到报告、仪表板或定制的结果表现中。
我们将在第十四章中更全面地探讨图像作为大数据(IABD)的概念。
利用的编程语言
起首，说一下编程语言。固然 Hadoop 及其生态系统最初是用 Java 编写的，但现代 Hadoop 子系统拥有险些所有可以想到的语言的语言绑定，包括 Scala 和 Python。这使得在一个应用步伐中构建开发各种编程语言的有效特性所必须的多语言系统变得非常轻易。
1 . 10 . 2 Hadoop 生态系统的多语言组件
在现代大数据分析领域，单一语言系统少之又少。固然我们在本书中讨论的很多旧组件和库主要是用一种编程语言编写的(例如，Hadoop 自己是用 Java 编写的，而 Apache Spark 主要是用 Scala 编写的)，但 BDA 通常是不同组件的组合，偶然在同一个应用步伐中利用 Java、Scala、Python 和 JavaScript。这些多语言、模块化的系统通常被称为多语言系统。
现代步伐员风俗于多语言系统。对多语言方法的一些需求是不必要的:例如，为互联网编写仪表板适合于 JavaScript 如许的语言，尽管人们可以在被迫的情况下利用 Java Swing 在独立乃至 web 模式下编写仪表板。对于手头的应用步伐来说，什么是最有效和最高效的，这完全是一个问题。在本书中，我们将拥抱多语言理念，本质上利用 Java 开发基于 Hadoop 的组件，利用 Scala 开发基于 Spark 的组件，根据必要利用 Python 和脚本，利用基于 JavaScript 的工具包开发前端、仪表盘、各种图形和画图示例。
1.10.3 Hadoop 生态系统结构
固然 Hadoop 焦点提供了构建分布式系统功能的底子，但被称为“Hadoop 生态系统”的附加库和框架提供了与 API 和功能的有效连接，这些 API 和功能可办理应用问题并构建分布式系统。
我们可以将 Hadoop 生态系统想象成一种“太阳系”，生态系统的各个组件依靠于中心 Hadoop 组件，Hadoop 焦点位于中心“太阳”位置，如图 1-6 所示。除了为 Hadoop 集群自己提供管理和簿记(例如 Zookeeper 和 Curator)，Hive 和 Pig 等标准组件提供数据堆栈，Mahout 等其他辅助库提供标准的机器学习算法支持。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig6_HTML.jpg&pos_id=img-6vIQGD4t-1723617460897
图 1-6。
A simplified “solar system” graph of the Hadoop ecosystem
Apache ZooKeeper(zookeeper.apache.org)是一个分布式协调服务，用于各种基于 Hadoop 和 Spark 的系统。它具有命名服务、组成员资格、用于分布式同步的锁和载体，以及高度可靠的集中式注册表。ZooKeeper 有一个由“znodes”组成的分层名称空间数据模型。Apache ZooKeeper 是开源的，由一个有趣的辅助组件 Apache Curator 支持，这是一个 ZooKeeper 的客户端包装器，也是一个支持以 ZooKeeper 为中心的组件的丰富框架。我们将在设置运行 Kafka 消息系统的设置时再次见到 ZooKeeper 和策展人。
1.11 关于“软件胶水”和框架的说明
“胶水”是任何建设项目都必须的，软件项目也不例外。究竟上，一些软件组件，如自然语言处理(NLP)组件 Digital Pebble Behemoth(我们将在后面具体讨论)将自己称为“glueware”。荣幸的是，也有一些通用集成库和包非常适合构建 BDA，如表 1-1 所示。
表 1-1。
Database types and some examples from industry
| 名字 | 位置 | 描述 | | --- | --- | --- | | 弹簧框架 | http://projects.spring.io/spring-framework/ | 一个基于 Java 的应用步伐开发框架，对应用步伐开发需求的险些任何部分都有库支持 | | 阿帕奇是 | tika.apache.org | 从各种文件范例中检测和提取元数据 | | 阿帕奇骆驼 | Camel.apache.org | 实现企业集成模式(EIP)的“glueware”组件 | | 春季数据 | [`http://projects.spring.io/spring-data/`](http://projects.spring.io/spring-data/) | 数据访问工具包，与 Spring 框架的别的部分精密耦合 | | 巨大的 | [`https://github.com/DigitalPebble/behemoth`](https://github.com/DigitalPebble/behemoth) | 大规模文档分析“glueware” | 为了有效地利用 Apache Camel，相识企业集成模式(EIP)很有帮助。有几本关于 EIP 的好书，它们对于利用 Apache Camel 尤其重要。 2
1.12 Apache Lucene、Solr 等等:开源搜刮组件
对于分布式计算，尤其是大数据分析，搜刮组件与查询引擎自己一样重要。究竟上，偶然候像 Apache Lucene 或 Apache Solr 如许的搜刮引擎是查询引擎实现自己的关键部分。我们可以在图 1-7 中看到这些组件之间的相互作用。究竟证实，Lucene 的 Solr 组件有自己的生态系统，尽管规模不如 Hadoop 生态系统大。尽管如此，Lucene 生态系统包罗一些与大数据分析非常相干的软件资源。除了 Lucene 和 Solr，Lucene 生态系统还包括 Nutch，这是一个可扩展和高度可伸缩的网络爬虫(nutch.apache.org)。NGDATA 的 Lily 项目是一个非常有趣的软件框架，我们可以利用它无缝地利用 HBase、Zookeeper、Solr 和 Hadoop。Lily 客户端可以利用基于 Avro 的协议来提供到 Lily 的连接。回想一下，Apache Avro(avro.apache.org)是一个数据序列化系统，它提供了一种紧凑而快速的二进制数据格式，并与动态语言简朴集成。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig7_HTML.jpg&pos_id=img-4WUAxn8K-1723617460897
图 1-7。
A relationship diagram between Hadoop and other Apache search-related components
1.13 用于构建大数据分析系统的架构
构建 BDAs 时的部分问题是，软件开发并不是真正在制作一座大楼。这只是一个比喻，尽管很有效。当我们计划一个软件时，我们已经在利用大量的隐喻和类比来思考我们正在做的事变。我们称之为软件架构，因为它是一个类似于制作房子的过程，一些基本原则适用于计划一个购物中心，就像计划一个软件系统一样。
我们希望从我们技术的历史中吸取教训，而不是重新发明轮子或犯与我们的先辈同样的错误。因此，我们有“最佳实践”、软件“模式”和“反模式”、诸如敏捷或迭代开发的方法，以及其他技术和策略的整个调色板。这些资源帮助我们实现质量，低沉成本，并为我们的软件需求提供有效和可管理的办理方案。
“软件架构”的比喻因为软件开发的某些实际而不建立。如果你正在制作一个豪华旅店，你忽然决定要给每个套房增长私人水疗室或壁炉，这是一个问题。很难重新计划平面图，大概利用什么品牌的地毯。改变主意会受到重罚。偶尔我们必须打破建筑的比喻，看看是什么使软件架构从根本上不同于它的比喻。
这种差别大部分与软件自己的动态和可变性质有关。需求变化，数据变化，软件技术快速发展。客户改变了他们对自己必要什么和如何必要的想法。经验丰富的软件工程师以为软件的这种可塑性和易弯曲性是理所固然的，这些实际——软件和数据的流动性——影响了从工具包到方法的一切，尤其是敏捷风格的方法，它险些理所固然地假设快速变化的需求。
这些抽象的想法影响了我们实际的软件架构选择。简而言之，在计划大数据分析系统时，经受住时间考验的标准架构原则仍然适用。例如，我们可以利用任何标准 Java 编程项目通用的构造原则。我们可以利用企业集成模式(EIP)来帮助构造和集成整个项目中不同的组件。如果我们愿意，我们可以继续利用传统的 n 层、客户端-服务器或对等原则来构造我们的系统。
作为架构师，我们还必须相识分布式系统(尤其是 Hadoop)如何改变实际系统构建的等式。架构师必须考虑专门适用于 Hadoop 技术的模式:例如，mapReduce 模式和反模式。知识是关键。因此，在下一节中，我们将告诉您为了构建有效的 Hadoop BDAs，您必要知道些什么。
1.14 您必要相识的内容
当我们写这本书的时候，我们必须对你，读者，做一些假设。我们做了很多假设:您是一名经验丰富的步伐员和/或架构师，您已经相识 Java，您相识一些 Hadoop，认识 Hadoop 2 焦点系统(包括 YARN)、Hadoop 生态系统，并且您风俗于从头开始构建 Java 风格的应用步伐的基本机制。这意味着你认识一个 IDE(比如 Eclipse，我们下面会扼要先容)，你知道 Ant 和 Maven 等构建工具，你有一个大数据分析问题要办理。我们假设您非常认识您想要办理的技术问题:这些问题包括选择您的编程语言、您的技术栈，并且您知道您的数据源、数据格式和数据接收器。你可能也已经认识 Python 和 Scala 编程语言，但是我们在下一章包括了对这些语言的快速复习——以及关于它们特殊有效的一些想法。Hadoop 生态系统有很多组件，此中只有一些与我们将要讨论的内容相干，因此在表 1-3 中，我们扼要描述了我们将利用的一些 Hadoop 生态系统组件。
我们假设的不但仅是你的编程能力。我们还假设你是一个战略思考者:你明白当软件技术改变、发展和变异时，合理的战略和方法(包括计算机科学和任何其他种类的科学)允许你适应新技术和新的问题领域。作为一名战略思考者，你对数据格式感兴趣。
固然数据格式肯定不是大数据科学最迷人的方面，但它们是与架构师和软件工程师最相干的问题之一，因为数据源及其格式在肯定程度上决定了任何数据管道的一个非常重要的部分:最初的软件组件或预处理器，它清理、验证、确认、确保安全性，并从数据源获取数据，以供管道的计算引擎阶段处理。Hadoop 是本书中讨论的大数据分析的关键组件，为了从本书中获得最大收益，您应该对 Hadoop 焦点和 Hadoop 生态系统的基本组件有深刻的理解。这包括“经典生态系统”组件，如 Hive、Pig 和 HBase，以及 glue 组件，如 Apache Camel、Spring Framework、Spring Data 子框架和 Apache Kafka 消息通报系统。如果您对利用关系数据源感兴趣，相识标准 Java 编程中利用的 JDBC 和 Spring Framework JDBC 将会有所帮助。JDBC 在 Apache Phoenix(Phoenix . Apache . org)等组件中卷土重来，这是关系型技术和基于 Hadoop 的技术的有趣团结。Phoenix 提供对 HBase 数据的低耽误查询，在查询中利用标准的 SQL 语法。Phoenix 是一个客户端嵌入式 JDBC 驱动步伐，因此只需一行 Java 代码就可以访问 HBase 集群。Apache Phoenix 还提供对模式定义、事务和元数据的支持。
表 1-2。
Database types and some examples from industry
| 数据库范例 | 例子 | 位置 | 描述 | | --- | --- | --- | --- | | 有关系的 | 关系型数据库 | mahout.apache.org | 这种范例的数据库已经存在了充足长的时间，可以获得复杂的支持框架和系统。 | | 文件 | 阿帕奇兔 | jackrabbit.apache.org | Java 中的内容存储库 | | 图表 | Neo4j | Neo4j.com | 多用途图数据库 | | 基于文件的 | 全文搜刮引擎 | Lucene.apache.org | 通用统计 | | 混合物 | Solr+骆驼 | Camel.apache.org Lucene.apache.org/solr | Lucene、Solr 和 glue 合二为一 | Note
设置和有效利用 Hadoop 的最佳参考之一是 Jason Venner 和 Sameer Wadkhar 所著的《Pro Apache Hadoop，第二版》,可从 Apress 出版社获得。
表 1-3。
A sampling of BDA components in and used with the Hadoop Ecosystem
| 名字 | 小贩 | 位置 | 描述 | | --- | --- | --- | --- | | 象夫 | 陌头地痞 | mahout.apache.org | 面向 Hadoop 的机器学习 | | MLlib(密西西比州) | 陌头地痞 | Spark.apache.org/mllib | Apache Spark 的机器学习 | | 稀有 | | [`https://www.r-project.org`](https://www.r-project.org) | 通用统计 | | 新西兰黑秧鸡 | 新西兰怀卡托大学 | [`http://www.cs.waikato.ac.nz/ml/weka/`](http://www.cs.waikato.ac.nz/ml/weka/) | 统计分析和数据发掘(基于 Java) | | H2O | H20 | H2o.ai | 基于 JVM 的机器学习 | | scikit_learn | | scikit-learn.org | Python 中的机器学习 | | Spark | 陌头地痞 | spark.apache.org | 开源集群计算框架 | | 卡夫卡 | 陌头地痞 | kafka.apache.org | 分布式消息通报系统 | 表 1-3 扼要总结了我们将讨论的一些工具包。
1.15 数据可视化和报告
数据可视化和报告可能是数据管道架构的最后一步，但它肯定与其他阶段一样重要。数据可视化允许系统的最终用户交互式地查看和操纵数据。它可能是基于 web 的，利用 RESTful APIs 和欣赏器、移动装备或计划为在高性能图形表现器上运行的独立应用步伐。数据可视化的一些标准库如表 1-4 所示。
表 1-4。
A sampling of front-end components for data visualization
| 名字 | 位置 | 描述 | | --- | --- | --- | | D3 | `D3.org` | Javascript 数据可视化 | | Ggplot2 | `http://ggplot2.org` | Python 中的数据可视化 | | matplotlib | `http://matplotlib.org` | 用于基本画图的 Python 库 | | 三. js | `http://threejs.org` | 用于三维图形和画图的 JavaScript 库 | | 角度 JS | `http://angularjs.org` | 允许利用 JavaScript 创建模块化数据可视化组件的工具包。它特殊有趣，因为 AngularJS 与 Spring 框架和其他管道组件集成得很好。 | 利用这些库或类似的库创建仪表板或前端用户界面非常简朴。大多数高级 JavaScript 库包罗高效的 API 来连接数据库、RESTful web 服务或 Java/Scala/Python 应用步伐。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig8_HTML.jpg&pos_id=img-bTbriGSm-1723617460897
图 1-8。
Simple data visualization displayed on a world map, using the DevExpress toolkit
利用 Hadoop 进行大数据分析是很特殊的。对于 Hadoop 系统架构师来说，Hadoop BDA 提供并允许利用标准的主流架构模式、反模式和策略。例如，BDAs 可以利用标准的 ETL(提取-转换-加载)概念，以及在“云中”开发分析系统的架构原则来开发。标准的系统建模技术仍然适用，包括计划的“应用层”方法。
应用层计划的一个例子可能包罗“服务层”(它提供应用步伐的“计算引擎”或“业务逻辑”)和数据层(它存储和管理输入和输出数据，以及数据源和接收器，以及由系统用户访问的输出层，它向输出装备提供内容)。当内容被提供给 web 欣赏器时，这通常被称为“web 层”。
Issues of the Platform
在本书中，我们在 Mac OS X 环境中表达了很多例子。这是故意的。我们利用 Mac 环境的主要原因是，它似乎是 Linux/Unix 语法(究竟，这是 Hadoop 赖以生存的地方)和规模更小的开发环境之间的最佳妥协，在这种环境中，开发职员可以尝试这里表现的一些想法，而不必要大型 Hadoop 集群，乃至不必要一台笔记本电脑。这并不意味着你不能在 Cygwin 的 Windows 平台或类似的环境中运行 Hadoop。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig9_HTML.jpg&pos_id=img-PKoMiDHs-1723617460897
图 1-9。
A simple data pipeline
一个简朴的数据管道如图 1-9 所示。在某种程度上，当考虑 BDAs 时，这个简朴的管道就是“Hello world”步伐。它对应于所有数据分析师都认识的那种简朴的主流 ETL(提取-转换-加载)过程。管道的后续阶段转换先前的输出内容，直到数据被发送到最终的数据接收器或结果存储库。
1.15.1 利用 Eclipse IDE 作为开发环境
Eclipse IDE 已经存在很长时间了，关于利用 Eclipse 进行现代应用步伐开发的争论在大多数利用 Java 或 Scala 的开发中心都很猛烈。现在有很多替换 Eclipse 的 IDE，您可以选择此中任何一个来试验和扩展本书中开发的示例系统。大概，如果您愿意，您乃至可以利用常规的文本编辑器并从下令行运行系统，只要您身边有最新版本的 Apache Maven。附录 A 向您展示了如何为各种 ide 宁静台(包括现代 Eclipse 环境)设置和运行示例系统。趁便提一下，Maven 是一个非常有效的工具，用于构造构成任何 BDA 的模块化的基于 Java 的组件(以及用 Scala 或 JavaScript 等其他语言实现的组件),并且被直接集成到 Eclipse IDE 中。Maven 在下令行上构建、测试和运行 BDA 同样有效。
我们发现，在开发本书中讨论的一些混合应用步伐示例时，Eclipse IDE 特殊有价值，但这可能是个人喜好的问题。请随意将示例导入到您选择的 IDE 中。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig10_HTML.jpg&pos_id=img-dICdpZce-1723617460898
图 1-10。
A useful IDE for development : Eclipse IDE with Maven and Scala built in Data Sources and Application Development
在主流应用步伐开发中——大多数时候——我们只会遇到一些基本范例的数据源:关系、各种文件格式(包括原始的非结构化文本)、逗号分隔的值，乃至是图像(可能是流数据，乃至是更奇特的东西，比如 Neo4j 等图数据库的导出)。在大数据分析领域，可能会用到信号、图像和多种非结构化数据。这些可能包括空间或 GPS 信息、来自传感器的时间戳以及各种其他数据范例、元数据和数据格式。在本书中，特殊是在示例中，我们将向您展示各种各样的常见数据格式以及外来数据格式，并提供关于如何对数据进行标准 ETL 操纵的提示。在得当的时候，我们将根据必要讨论数据验证、压缩以及从一种数据格式到另一种数据格式的转换。
1.15.2 本书不是什么
既然我们已经注意到了这本书是关于什么的，我们现在必须查抄它不是什么。
这本书不是对 Apache Hadoop、大数据分析组件或 Apache Spark 的先容。已经有很多良好的书籍描述了“vanilla Hadoop”(直接从 hadoop.apache.org 获得)及其生态系统的特性和机制，以及近来的 Apache Spark 技术，这些技术代替了 Hadoop 的原始 map-reduce 组件，并允许批处理和内存处理。
在整本书中，我们将描述有效的 Hadoop 生态系统组件，尤其是那些与我们将在本书别的部分构建的示例系统相干的组件。这些组件是我们的 BDAs 或大数据分析组件的构建模块，因此本书不会深入讨论组件功能。对于标准的 Hadoop 兼容组件，如 Apache Lucene、Solr、Apache Camel 或 Spring Framework，书籍和互联网教程触目皆是。
我们也不会深入讨论方法论(例如迭代或敏捷方法论)，尽管这些是构建大数据分析系统的非常重要的方面。我们希望我们在这里讨论的系统对你有效，不管你选择什么样的方法风格。
How to Build The BDA Evaluation System
在这一节中，我们将扼要先容如何建立 BDA 评估系统。乐成完成后，这将为您提供评估本书剩余部分中讨论的代码和示例所需的一切。各个组件在其各自的网站上都有完备的安装说明。
[*] 如果您还没有设置基本开发环境，请设置好。这包括 Java 8.0、Maven 和 Eclipse IDE。有关 Java 的最新安装说明，请访问 oracle.com。不要忘记相应地设置得当的环境变量，比如 JAVA_HOME。下载并安装 Maven (maven.apache.org)，设置 M2_HOME 环境变量。要确保 Maven 已经精确安装，请在下令行中键入 mvn–version。还要在下令行上键入‘which mvn ’,以确保 Maven 可执行文件在您以为的位置。
[*] 确保安装了 MySQL。从 www.mysql.com/downloads 下载符合的安装包。利用本书中包罗的示例模式和数据来测试功能。你应该可以运行“mysql”和“mysqld”。
[*] 安装 Hadoop 焦点系统。在本书的例子中，我们利用 Hadoop 版本 2.7.1。如果你在 Mac 上，你可以用自制软件来安装 Hadoop，大概从网站上下载并按照说明安装。在. bash_profile 文件中设置 HADOOP_HOME 环境变量。
[*] Insure that Apache Spark is installed. Experiment with a single-machine cluster by following the instructions at http://spark.apache.org/docs/latest/spark-standalone.html#installing-spark-standalone-to-a-cluster . Spark is a key component for the evaluation system. Make sure the SPARK_HOME environment variable is set in your.bash_profile file .
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig11_HTML.jpg&pos_id=img-bNg6tyDs-1723617460898
图 1-11。
Successful installation and run of Apache Spark results in a status page at localhost:8080 To make sure the Spark system is executing correctly, run the program from the SPARK_HOME directory.
./bin/run-example SparkPi 10
You will see a result similar to the picture in Figure 1-12.
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_1_Fig12_HTML.jpg&pos_id=img-XyvMUs5b-1723617460898
图 1-12。
To test your Spark installation, run the Spark Pi estimator program. A console view of some expected results.
[*] 安装 Apache Mahout (mahout.apache.org)。这是一个非常有效的分布式分析工具包。设置得当的环境变量，包括 MAHOUT_HOME。运行 Mahout 测试套件以确保它安装精确。
[*] 安装 Apache Kafka (kafka.apache.org)。这个消息通报系统将在我们的示例中占据显着位置。第三章列出了建立和彻底运用卡夫卡体系的所有必要步调。
[*] 安装你最喜好的 NoSQL 和图数据库。此中可能包括 Cassandra (Cassandra.apache.org)、mongoDB ( https://www.mongodb.org/downloads#production )等。如果你对这本书的图形分析部分感兴趣，Neo4j ( http://neo4j.com )是一个非常受欢迎的图数据库。我们的图表分析示例都基于 Neo4j。在本书中，我们选择 Cassandra 作为我们的 NoSQL 数据库。
[*] 安装 Apache Solr(Lucene . Apache . org/Solr)。下载 Solr 服务器 zip 文件，解压缩，并遵照 README 文件中的附加说明。这种可设置的基于 Java 的搜刮组件可以与 Hadoop 无缝耦合，利用 Hadoop 和 Spark 底子设施提供复杂、可扩展和可定制的搜刮功能。
[*] 安装 Scala 编程语言和 Akka。确保您的 Eclipse IDE 中有一个支持 Scala 的插件。通过在下令行中键入“scalac–version”和“which scala ”,确保 Scala 和 Scala 编译器安装精确。
[*] 安装 Python 和 IPython。在 MacOS 系统上，Python 已经可以利用了。您可能希望安装 Anaconda 系统，它在一个包中提供了 Python、交互式 Python 和很多有效的库。
[*] 安装 H2O(H2O . ai)和苏打水。一旦安装了阿帕奇 Spark 和 Akka，我们就可以安装 H20 和苏打水组件。
[*] 安装符合的“粘合”组件。应该安装 Spring Framework、Spring Data、Apache Camel 和 Apache Tika。在附录 a 所示的 Maven pom.xml 中已经有了这些组件的得当依靠关系。您可能希望安装一些辅助组件，如 SpatialHadoop、distributed Weka for Hadoop 等。
当您安装完所有这些组件后，恭喜您。现在，您已经有了一个基本的软件环境，可以在此中彻底研究大数据分析系统(BDAs)。以这个基本系统为起点，我们准备探索各个模块，并为所提供的基本 BDA 功能编写一些扩展。
1.16 摘要
在这一先容性章节中，我们探讨了不断变化的大数据环境，以及摄取、分析、存储、可视化和理解我们所处的不断增长的大数据海洋的方法。我们相识到，大数据源种类繁多，这些大数据源为有理想的大数据分析师提出了新的挑衅性问题。如今，大数据分析师面临的主要挑衅之一是在可用于大数据分析的所有库和工具包、技术堆栈和方法中做出选择。
我们还扼要概述了 Hadoop 框架，包括焦点组件和相干的生态系统组件。尽管对 Hadoop 及其生态系统可以为我们这些数据分析师做些什么进行了必要的扼要先容，但我们随后探索了可供我们利用的架构和策略，目的是计划和实现有效的基于 Hadoop 的分析系统，或 BDA。这些系统将具有可扩展性和灵活性，以办理广泛的分析挑衅。
在选择大数据工具包时，数据分析师有很多选择，能够欣赏令人眼花缭乱的功能列表以提出有效的团体技术堆栈是乐成开发和部署的关键。我们通过关注与 Hadoop 焦点及其生态系统相对无缝集成的组件来保持简朴(尽可能简朴)。
在本书中，我们将试图向您证实，上面概述的计划和实现步调可以产生适用于广泛领域和问题领域的可行的数据管道架构和系统。由于所讨论的系统的灵活性，我们将能够随着技术的变化“替换”模块化组件。例如，我们可能会发现一个机器学习或图像处理库更适合利用，并且我们可能希望用这些库中的一个来替换当前存在的应用步伐库。起首，模块化计划让我们可以自由轻松地更换组件。在后面的章节中，当我们开发“作为大数据的图像”应用示例时，我们将看到这一原理的实际应用。
在下一章中，我们将快速回顾两种最盛行的大数据分析语言——Scala 和 Python，并探索这两种语言特殊有效的应用示例。
Footnotes 1
对“语义网”方法最好的先容之一是 Dean Allemang 和 Jim Hendler 的“工作本体学家的语义网:RDFS 和 OWL 中的有效建模”，2008 年，摩根-考夫曼/爱思唯尔出版社，马萨诸塞州伯灵顿。国际标准书号 978-0-12-373556-0。
2
关于企业集成模式(EIPs)的最佳书籍是 Gregor Hohpe 和 Bobby Woolf 的《企业集成模式:计划、构建和部署消息通报办理方案》, 2004 年，Pearson Education Inc. Boston，MA。国际标准书号 0-321-20068-3。
二、Scala 和 Python 的回顾
本章包罗了整本书利用的 Scala 和 Python 编程语言的快速回顾。这里讨论的内容主要针对必要快速复习 Scala 和 Python 的 Java/C++步伐员。
Note
安装 Python 的一个简朴方法是安装 Anaconda Python 发行版，可以在 www.continuum.io/downloads 获得。Anaconda 为数学和分析提供了很多额外的 Python 库，包括对 Hadoop、Weka、R 等的支持。
2.1 动机:选择精确的语言定义应用步伐
为精确的任务选择精确的编程语言定义了应用步伐。在很多情况下，选择看起来很自然:Java 用于以 Hadoop 为中心的组件，Scala 用于以 Spark 为中心的组件。利用 Java 作为 BDA 的主要语言允许访问 Spring Framework、Apache Tika 和 Apache Camel 来提供“glueware”组件。但是，从策略上来说(取决于您的 BDA 应用步伐的性质)，您可能必要包罗其他语言和其他语言绑定。这反过来会影响整个技术堆栈和开发过程自己的性质。例如，一个移动应用步伐可能必要与移动装备的底层代码进行交互，可能包括 Erlang 语言、C++或 C 等。
另一个必要审慎选择编程语言的领域是用于表现和报告 BDA 结果的前端组件。如果前端仪表板和报告模块是基于 web 的，它们可能只包罗不同复杂性的 JavaScript 库。然而，独立的科学应用可能是另一回事。这些可能利用 C、C++、Java 或 Python 中复杂的可视化库。
仔细控制、开发和质疑技术栈是非常重要的；但是为了选择技术栈组件及其语言绑定，我们必须起首比较语言特性。
2.1.1 语言特性—比较
我们现在将快速比较 Java、Scala 和 Python 为我们提供的十个最重要的特性，特殊是在开发 BDA 系统方面。我们讨论的每一个特性都是现代编程语言的重要组成部分，但是对于 BDAs 来说尤其有效。这些有效的特性(我们最关心的特性)是:
[*]标准的逻辑、算术和控制结构。就基本的语言结构而言，Java、Scala 和 Python 有很多共同点。
[*]面向对象。我们的三种语言都有一个对象系统，Java、Scala 和 Python 之间的语法和语义有很大的不同。
[*]数据库连接。因为构建 BDA 的全部目的是建立端到端的数据处理管道，以是有效处理数据源以及导出到数据接收器是团体计划和技术堆栈选择的关键考虑因素。
[*]函数式编程支持。函数式编程一直是分布式应用步伐开发的重要组成部分。
[*]图书馆支持，特殊是机器学习和统计图书馆支持。很多不同的库都是用 Java、Scala 或 Python 编写的。库和框架选择是 BDA 计划者面临的最具挑衅性的问题之一。然而，您选择的库的模块化和可扩展性是有效的 BDA 计划的关键要求。特定于任务的库，如用于机器学习的 MLlib，特殊有效，但会产生对 Spark 和 Scala 的依靠。记住这些依靠关系尤其重要。
[*]仪表板和前端连接。通常 JavaScript 工具包和库(如 AngularJS、D3 等)足以构建复杂的仪表板和前端控件，但是——我们将在本书的别的部分看到——也有例外，特殊是在移动应用步伐开发中。
[*]“胶件”连接和支持。这既包括以 Java 为中心的连接，也包括与其他库和框架的连接，乃至包括那些用 C++编写的库，如 Vowpal Wabbit 机器学习库。如果我们愿意，我们可以通过 web 服务，乃至通过 Java-native interface (JNI)支持库来访问 VW。
[*]读取-评估-打印循环支持。除了 Java 之外，所有现代语言都有 read-eval-print 循环(REPLs ),这在 Java 9 规范中得到了弥补。
[*]本机、多核支持和显式内存管理。正如我们将要讨论的，这在我们的语言之间有很大的不同。
[*]与 Hadoop、Spark、NoSQL 数据库及其生态系统的连接。PySpark、Spring Data Hadoop、Apache Camel-neo4j 等工具用于连接 BDA 中可能必要的不同组件。
2.2 Scala 的回顾
这篇对 Scala 语言的简短回顾由五个简朴的代码片断组成，它们突出了我们在先容性章节中描述的各种语言特性。Scala 特殊有趣，因为它有内置的语言特性，比如范例推断、闭包、currying 等等。Scala 另有一个复杂的对象系统:每个值都是一个对象，每个操纵都是方法调用。Scala 也兼容 Java 步伐。现代语言总是包括对标准数据结构、集合、数组和向量的支持。Scala 也不例外，因为 Scala 与 Java 有着非常密切的关系，以是 Java 编程中所有你认识的数据结构仍然适用。
Note
在本书中，我们将讨论 Scala 2 . 11 . 7 版。在下令行中输入‘scala–version’来查抄您安装的 Scala 版本。你也可以通过在下令行输入‘scalac–version’来查抄你的 Scala 编译器版本。
2.2.1 Scala 及其交互式 Shell
让我们从快速排序算法的简朴素现开始，然后在 Scala 交互式 shell 中测试这个例程。你可以看到清单 2-1 是一个简朴的利用递归的声明式 Scala 步伐。如果您将代码扔进您的交互式 Scala shell，您将看到如图 y.y 所示的结果。Java 步伐员可以立即看出 Java 和 Scala 之间的相似性:Scala 也利用 JVM，并与 Java 协同工作。乃至“package”和“import”语句都是相似的，Scala 中“packages”对代码模块的构造也与 Java 包系统相似。
请注意，和 Java 一样，Scala 提供了一个方便的面向对象的打包系统。你也可以用类似于 Java 的方式定义一个可运行的“main”方法，如清单 2-1 所示。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_2_Fig1_HTML.jpg&pos_id=img-elc6TCib-1723617460898
Figure 2-1.
/** An example of a quicksort implementation, this one uses a functional style. */
object Sorter {
def sortRoutine(lst: List): List = {
if (lst.length < 2)
lst
else {
val pivel = lst(lst.length / 2)
sortRoutine(lst.filter(_ < pivel)) :::
lst.filter(_ == pivel) :::
sortRoutine(lst.filter(_ > pivel))
}
}
def main(args: Array) {
val examplelist = List(11,14,100,1,99,5,7)
println(examplelist)
println(sortRoutine(examplelist))
}
}
Listing 2-1.Simple example of a Scala program which can be tried out in the interactive shell
Functional programming in Scala
scala> def closure1(): Int => Int = {
| val next = 1
| def addit(x: Int) = x + next
| addit
| }
closure1: ()Int => Int
scala> def closure2() = {
| val y = 2
| val f = closure1()
| println(f(100))
| }
closure2: ()Unit
Listing 2-2.An example of functional programming in Scala
您可以在任何交互式 Scala shells 中轻松利用 Spark，如清单 2-3 所示。
NOTE: Please make sure the bdasourcedatafile.dat file is present in your HDFS before running.
val bdaTextFile = sc.textFile("hdfs://bdasourcedatafile.dat")
val returnedErrors = bdaTextFile.filter(line => line.contains("ERROR"))
// Count all the errors
returnedErrors.count()
// Count errors mentioning ‘Pro Hadoop Analytics’
errors.filter(line => line.contains("Pro Hadoop Analytics")).count()
// Fetch the Pro Hadoop Analytics errors as an array of strings...
returnedErrors.filter(line => line.contains("Pro Hadoop Analytics")).collect()
Listing 2-3.Simple use of Apache Spark in Scala
KafkaWordCount program in Scala
package org.apache.spark.examples.streaming
import java.util.HashMap
import org.apache.kafka.clients.producer.{ProducerConfig, KafkaProducer, ProducerRecord}
import org.apache.spark.streaming._
import org.apache.spark.streaming.kafka._
import org.apache.spark.SparkConf
/**
* Consumes messages from one or more topics in Kafka and does wordcount.
* Usage: KafkaWordCount <zkQuorum> <group> <topics> <numThreads>
* <zkQuorum> is a list of one or more zookeeper servers that make quorum
* <group> is the name of kafka consumer group
* <topics> is a list of one or more kafka topics to consume from
* <numThreads> is the number of threads the kafka consumer should use
*
* Example:
* `$ bin/run-example \
* org.apache.spark.examples.streaming.KafkaWordCount zoo01,zoo02,zoo03 \
* my-consumer-group topic1,topic2 1`
*/
object KafkaWordCount {
def main(args: Array) {
if (args.length < 4) {
System.err.println("Usage: KafkaWordCount <zkQuorum> <group> <topics> <numThreads>")
System.exit(1)
}
StreamingExamples.setStreamingLogLevels()
val Array(zkQuorum, group, topics, numThreads) = args
val sparkConf = new SparkConf().setAppName("KafkaWordCount")
val ssc = new StreamingContext(sparkConf, Seconds(2))
ssc.checkpoint("checkpoint")
val topicMap = topics.split(",").map((_, numThreads.toInt)).toMap
val lines = KafkaUtils.createStream(ssc, zkQuorum, group, topicMap).map(_._2)
val words = lines.flatMap(_.split(" "))
val wordCounts = words.map(x => (x, 1L))
.reduceByKeyAndWindow(_ + _, _ - _, Minutes(10), Seconds(2), 2)
wordCounts.print()
ssc.start()
ssc.awaitTermination()
}
}
// Produces some random words between 1 and 100.
object KafkaWordCountProducer {
def main(args: Array) {
if (args.length < 4) {
System.err.println("Usage: KafkaWordCountProducer <metadataBrokerList> <topic> " +
"<messagesPerSec> <wordsPerMessage>")
System.exit(1)
}
val Array(brokers, topic, messagesPerSec, wordsPerMessage) = args
// Zookeeper connection properties
val props = new HashMap()
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, brokers)
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
"org.apache.kafka.common.serialization.StringSerializer")
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
"org.apache.kafka.common.serialization.StringSerializer")
val producer = new KafkaProducerString, String
// Send some messages
while(true) {
(1 to messagesPerSec.toInt).foreach { messageNum =>
val str = (1 to wordsPerMessage.toInt).map(x => scala.util.Random.nextInt(10).toString)
.mkString(" ")
val message = new ProducerRecordString, String
producer.send(message)
}
Thread.sleep(1000)
}
}
}
Listing 2-4.Scala example 4: using Apache Kafka to do word counting
惰性求值是一种“按需调用”的策略，可以在任何我们喜好的语言中实现。清单 2-5 表现了一个简朴的惰性评估练习的例子。
/* Object-oriented lazy evaluation in Scala */
package probdalazy
object lazyLib {
/** Delay the evaluation of an expression until it is required. */
def delayA: Susp = new SuspImplA
/** Get the value of a delayed expression. */
implicit def forceA: A = s()
/**
* Data type of suspended computations. (The name froms from ML.)
*/
abstract class Susp[+A] extends Function0
/**
* Implementation of suspended computations, separated from the
* abstract class so that the type parameter can be invariant.
*/
class SuspImplA extends Susp {
private var maybeValue: Option = None
override def apply() = maybeValue match {
case None =>
val value = lazyValue
maybeValue = Some(value)
value
case Some(value) =>
value
}
override def toString() = maybeValue match {
case None => "Susp(?)"
case Some(value) => "Susp(" + value + ")"
}
}
}
object lazyEvaluation {
import lazyLib._
def main(args: Array) = {
val s: Susp = delay { println("evaluating..."); 3 }
println("s = " + s) // show that s is unevaluated
println("s() = " + s()) // evaluate s
println("s = " + s) // show that the value is saved
println("2 + s = " + (2 + s)) // implicit call to force()
val sl = delay { Some(3) }
val sl1: Susp] = sl
val sl2: Susp] = sl1 // the type is covariant
println("sl2 = " + sl2)
println("sl2() = " + sl2())
println("sl2 = " + sl2)
}
}
Listing 2-5.Lazy evaluation in Scala
2.3 Python 的回顾
在这一节中，我们将非常简便地概述 Python 编程语言。Python 是构建 BDAs 的一个特殊有效的资源，因为它具有高级的语言特性和与 Apache Spark 的无缝兼容性。像 Scala 和 Java 一样，Python 完全支持你所期望的所有常见数据结构范例。利用 Python 编程语言来构建 BDA 系统中的至少一些组件有很多好处。Python 在相对较短的时间内成为主流开发语言，部分原因是它是一种轻易学习的语言。交互式外壳允许快速实行，并且能够以一种简朴的方式尝试新的想法。有很多数字和科学库支持 Python，也有很多学习这种语言及其支持库的好书和在线教程。
Note
在整本书中，我们将利用 Python 版本 2.7.6 和交互式 Python (IPython)版本 4.0.0。要查抄您已经安装的 python 版本，请在下令行上分别键入python –version或ipython –version。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_2_Fig2_HTML.jpg&pos_id=img-A3acc2Gj-1723617460898
图 2-2。
Simple example of an IPython program, showingdatabase connectivity Note
要运行数据库连接示例，请记住我们主要利用 Oracle 的 MySQL 数据库。这意味着您必须从 Oracle 网站下载并安装 MySQL connector for Python，该网站位于 https://dev.mysql.com/downloads/connector/python/2.1.html 该连接器易于安装。在 Mac 上，只需双击 dmg 文件，然后按照说明进行操纵。然后，您可以利用交互式 Python shell 来测试连通性。
清单 2-6 表现了 Python 中数据库连接的一个简朴例子。认识 Java JDBC 结构的读者会看到相似之处。这个简朴的例子建立一个数据库连接，然后关闭它。在这两条语句之间，步伐员可以访问指定的数据库，定义表，并执行关系查询。
Database connectivity example in Python: import, connect, and release (close)
import mysql.connector
cnx = mysql.connector.connect(user='admin', password='',
host='127.0.0.1',
database='test')
cnx.close()
Listing 2-6.
Database connectivity
code with Python
各种算法都很轻易在 Python 中实现，并且有大量的库可以帮助您。递归的利用和所有的标准编程结构都是可用的。清单 2-7 表现了一个递归步伐的简朴例子。
A simple Python code example using recursion
def FlattenList(a, result=None):
result = []
for x in a:
if isinstance(x, list):
FlattenList(x, result)
else:
result.append(x)
return result
FlattenList([ ], , 6])
Listing 2-7.Recursive Python code that flattens a list
就像 Java 和 Scala 一样，用 Python“import”语句包罗支持包很轻易。清单 2-8 中表现了一个简朴的例子。
显式规划导入列表是保持 Python 步伐有构造并与开发团队和利用 Python 代码的其他人保持一致的关键。
Python example using time functions
import time
size_of_vec = 1000
def pure_python_version():
t1 = time.time()
X = range(size_of_vec)
Y = range(size_of_vec)
Z = []
for i in range(len(X)):
Z.append(X + Y)
return time.time() - t1
def numpy_version():
t1 = time.time()
X = np.arange(size_of_vec)
Y = np.arange(size_of_vec)
Z = X + Y
return time.time() - t1
t1 = pure_python_version()
t2 = numpy_version()
print(t1, t2)
print("Pro Data Analytics Numpy in this example, is: " + str(t1/t2) + " faster!")
Listing 2-8.Python code example using time functions
IPython 中返回的答案类似于:
Pro Data Analytics
Hadoop Numpy in this example, is:7.75 faster!
NumPy 库提供了 python 编程语言的扩展。
Python example using the NumPy library
import numpy as np
from timeit import Timer
size_of_vec = 1000
def pure_python_version():
X = range(size_of_vec)
Y = range(size_of_vec)
Z = []
for i in range(len(X)):
Z.append(X + Y)
def numpy_version():
X = np.arange(size_of_vec)
Y = np.arange(size_of_vec)
Z = X + Y
#timer_obj = Timer("x = x + 1", "x = 0")
timer_obj1 = Timer("pure_python_version()", "from __main__ import pure_python_version")
timer_obj2 = Timer("numpy_version()", "from __main__ import numpy_version")
print(timer_obj1.timeit(10))
print(timer_obj2.timeit(10))
Listing 2-9.Python code example 4: Using the NumPy Library
清单 2-10 表现了一个主动启动文件的例子。
Python example:using a startup file
import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
with open(filename) as fobj:
startup_file = fobj.read()
exec(startup_file)
import site
site.getusersitepackages()
Listing 2-10.Python code example 5: automatic startup behavior in Python
2.4 故障扫除、调试、分析和记录
故障扫除，无论您利用何种语言，都涉及到在运行您的步伐时识别息争决即时和严重的问题。调试也是故障扫除，但意味着不太严重的困难，如不测的错误条件、逻辑错误或其他不测的步伐结果。这种区别的一个例子是权限问题。如果没有文件的执行权限，就不能运行步伐。您可能必要执行“chmod”下令来修复此问题。
此外，我们以为故障诊断是一个生理过程。另一方面，调试可以得到显式工具的支持，帮助您找到 bug、逻辑错误、不测情况等。
2.4.1 在 Python 中调试资源
在 Python 中，可以通过键入以下下令来加载 pdb 调试器:
import pdb
import yourmodule
pdb.run (‘yourmodule.test()’)
大概，您可以通过键入以下下令直接将pdb用于 Python:
python –m pdb yourprogram.py
对于分析 Python，Robert Kern 的非常有效的行分析器( https://pypi.python.org/pypi/line_profiler/1.0b3 ))可以通过在下令行中键入以下下令来安装:
sudo pip install line_profiler
乐成安装如图 2-3 所示。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_2_Fig3_HTML.jpg&pos_id=img-6NtSolKP-1723617460898
图 2-3。
Successful installation of the line profiler package
http://www.huyng.com/posts/python-performance-analysis/ 对分析 Python 步伐有很好的论述。
通过键入以下下令安装内存分析器:
sudo pip install -U memory_profiler
为什么不通过编写一个简朴的 Python 步伐来生成质数、斐波那契数列或您选择的其他小例程来测试您的分析器呢？
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_2_Fig4_HTML.jpg&pos_id=img-bs1oyZIK-1723617460899
图 2-4。
Profiling Python code using memory and line profilers
Python 的文档
当记录 Python 代码时，看一下 python.org 的文档风格指南是非常有帮助的。这可以在以下位置找到
https://docs.python.org/devguide/documenting.html 。
2.4.3 在 Scala 中调试资源
在这一部分，我们将讨论可以帮助你调试 Scala 步伐的资源。调试步伐最简朴的方法之一就是在 Eclipse IDE 中安装 Scala 插件，在 Eclipse 中创建和构建 Scala 项目，并在那里调试和运行它们。关于如何做到这一点的大量教程，请参考 http://scala-ide.org 。
2.5 编程应用和示例
构建 BDA 意味着构建数据管道处理器。固然有很多其他的方法来构思和构建软件系统——包括利用诸如敏捷之类的方法，诸如面向对象之类的技术概念，以及企业集成模式(EIPs)——但是一个稳定的概念是管道概念。
2.6 摘要
在本章中，我们回顾了 Scala 和 Python 编程语言，并将它们与 Java 进行了比较。Hadoop 是一个以 Java 为中心的框架，而 Apache Spark 是用 Scala 编写的。大多数常用的 BDA 组件通常都有针对 Java、Scala 和 Python 的语言绑定，我们在较高层次上讨论了此中的一些组件。
每种语言都有其独特的上风，我们能够接触到 Java、Scala 和 Python 的一些符合的用例。
我们回顾了扫除故障、调试、分析和记录 BDA 系统的方法，不管我们用什么语言编写 BDAs，我们还讨论了 Eclipse IDE 可用于 Python 和 Scala 的各种插件。
在下一章中，我们将着眼于 BDA 开发的必要身分:利用 Hadoop 和 Spark 构建 BDA 所必须的框架和库。
2.7 参考文献
鲍尔斯，迈克尔。Python 中的机器学习:预测分析的基本技术。印第安纳波利斯，约翰·威利父子公司，2015 年。
胡维茨，朱迪斯 s，考夫曼，马西娅，鲍尔斯，阿德里安。认知计算和大数据分析。印第安纳波利斯，约翰·威利父子公司，2015 年。
奥德斯基、马丁、斯普恩、莱克斯和凡纳斯、比尔。Scala 编程，第二版。加利福尼亚州核桃溪:Artima 出版社，2014 年。
杨克，杰夫。敏捷 Python 开发的底子。纽约州纽约市:纽约出版社，2008 年。
齐亚德，塔瑞克。Python 编程专家。英国伯明翰。，派克彪炳版社，2008 年。
三、Hadoop 和分析的标准工具包
在这一章中，我们来看看 BDA 系统的必要组成部分:对构建 BDAs 最有效的标准库和工具包。我们利用 Hadoop 和 Spark 生态系统中的标准工具包描述了一个示例系统(我们将在本书的剩余部分中开发该系统)。我们还利用其他分析工具包，如 R 和 Weka，以及主流开发组件，如 Ant、Maven、npm、pip、Bower 和其他系统构建工具。Apache Camel、Spring Framework、Spring Data、Apache Kafka、Apache Tika 等“Glueware 组件”可用于创建适合各种应用步伐的基于 Hadoop 的系统。
Note
Hadoop 及其相干组件的乐成安装是评估本书中示例的关键。在标题为“在 Mac 上安装 Hadoop 第一部分”的文章中的 http://amodernstory.com/2014/09/23/installing-hadoop-on-mac-osx-yosemite/ 中描述了在 Mac 上相对轻松地安装 Hadoop 的方法
3.1 库、组件和工具包:调查
没有一章可以描述所有的大数据分析组件，这些组件可以帮助您构建 BDA 系统。我们只能发起组件的类别，谈一些典型的例子，并在后面的章节中对这些例子进行扩展。
有大量的图书馆支持 BDA 系统的建设。为了相识可用技术的范围，考虑图 3-1 中所示的组件。这并不是组件范例的唯一列表，但是当您意识到每种组件范例都有各种各样的工具包、库、语言和框架可供选择时，定义 BDA 系统技术堆栈可能会在一开始就显得势不可挡。为了克服这个定义问题，系统模块化和灵活性是关键。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_3_Fig1_HTML.jpg&pos_id=img-oNQ2kUbU-1723617460899
图 3-1。
A whole spectrum of distributed techniques are available for building BDAs
构建模块化 BDA 系统最简朴的方法之一是利用 Apache Maven 来管理依靠项，并为您完成大多数简朴的组件管理。建立一个简朴的 Maven pom.xml文件并在 Eclipse IDE 中创建一个简朴的项目是让评估系统运行的好方法。我们可以从一个简朴的 Maven pom.xml开始，类似于清单 2-1 中所示的那个。请注意，表现的唯一依靠项是 Hadoop 焦点和 Apache Mahout，这是我们在第一章中讨论的 Hadoop 机器学习工具包，我们在示例中经常利用。我们将扩展 Maven pom 文件，以包罗我们在本书后面利用的所有辅助工具包。你可以随意增长或减少组件，只需从pom.xml文件中移除依靠关系。
请记住，对于图表中表现的每种技术，都有几种备选方案。对于技术堆栈中的每个选择，通常都有方便的 Maven 依靠项，您可以将它们添加到您的评估系统中来查抄功能，因此很轻易混合和匹配组件。包罗精确的“glueware”组件可以使不同库的集成不那么痛苦。
Note
为了有效地利用图书示例，必要设置以下重要的环境变量:
export BDA_HOME="/Users/kerryk/workspace/bdt"
<projectxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.kildane</groupId>
<artifactId>bdt</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>Big Data Toolkit (BDT) Application</name>
<url>http://maven.apache.org</url>
<properties>
<hadoop.version>0.20.2</hadoop.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-core</artifactId>
<version>${hadoop.version}</version>
</dependency>
<dependency>
<groupId>org.apache.mahout</groupId>
<artifactId>mahout-core</artifactId>
<version>0.9</version>
</dependency>
</dependencies>
<build>
<finalName>BDT</finalName>
</build>
</project>
Listing 3-1.A basic pom.xml file for the evaluation system
构建模块化 BDA 系统最简朴的方法是利用 Apache Maven 来管理依靠项，并为您完成大多数简朴的组件管理。利用一个简朴的 pom.xml 来启动您的 BDA 项目是试验模块、锁定技术堆栈和定义系统功能的好方法——根据必要渐渐修改您的依靠项和插件。
设置一个简朴的 Maven pom.xml 文件并在 Eclipse IDE 中创建一个简朴的项目是让评估系统运行的一种简朴方法。我们可以从一个简朴的 Maven pom.xml 开始，类似于清单 3-1 中所示。请注意，表现的唯一依靠项是 Hadoop Core 和 Apache Mahout，这是我们在第一章中讨论的 Hadoop 机器学习工具包，我们在示例中经常利用。我们将扩展 Maven pom 文件，以包罗我们在本书后面利用的所有辅助工具包。只要从 pom.xml 文件中删除依靠项，就可以随意添加或删除组件。
让我们以举例的方式给评估系统添加一个规则系统。只需为 drools 规则系统添加得当的依靠项(对于 Drools 的大多数最新版本，请利用 Google“Drools maven 依靠项”)。清单 3-2 中表现了完备的pom.xml文件(基于我们的原始文件)。我们将在第八章的完备分析引擎示例中利用 JBoss Drools 的功能。请注意，我们提供依靠关系来连接 Drools 系统和 Apache Camel 以及 Drools 的 Spring 框架。
<projectxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.kildane</groupId>
<artifactId>bdt</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>Big Data Toolkit (BDT) Application, with JBoss Drools Component</name>
<url>http://maven.apache.org</url>
<properties>
<hadoop.version>0.20.2</hadoop.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!--add these five dependencies to your BDA project to achieve rule-based support -->
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-core</artifactId>
<version>6.3.0.Final</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-persistence-jpa</artifactId>
<version>6.3.0.Final</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-spring</artifactId>
<version>6.0.0.Beta2</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-camel</artifactId>
<version>6.0.0.Beta2</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-jsr94</artifactId>
<version>6.3.0.Final</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-core</artifactId>
<version>${hadoop.version}</version>
</dependency>
<dependency>
<groupId>org.apache.mahout</groupId>
<artifactId>mahout-core</artifactId>
<version>0.9</version>
</dependency>
</dependencies>
<build>
<finalName>BDT</finalName>
</build>
</project>
Listing 3-2.Add JBoss Drools dependencies to add rule-based support to your analytical engine. A complete example of a Drools use case is in Chapter 8!
3.2 在评估系统中利用深度学习
DL4j ( http://deeplearning4j.org )是一个面向 Java 和 Scala 的开源分布式深度学习库。它集成了 Hadoop 和 Spark。
要安装:
git clone https://github.com/deeplearning4j/dl4j-0.4-examples.git
要构建系统:
cd $DL4J_HOME directory
然后:
mvn clean install -DskipTests -Dmaven.javadoc.skip=true
要验证 dl4j 组件是否正常运行，请键入以下内容:
mvn exec:java -Dexec.mainClass="org.deeplearning4j.examples.tsne.TSNEStandardExample" -Dexec.cleanupDaemonThreads=false
如果组件运行乐成，您将看到类似于清单 y.y .的文本输出。
--- exec-maven-plugin:1.4.0:java (default-cli) @ deeplearning4j-examples ---
o.d.e.t.TSNEStandardExample - Load & Vectorize data....
Nov 01, 2015 1:44:49 PM com.github.fommil.jni.JniLoader liberalLoad
INFO: successfully loaded /var/folders/kf/6fwdssg903x6hq7y0fdgfhxc0000gn/T/jniloader545087044337083844netlib-native_system-osx-x86_64.jnilib
o.d.e.t.TSNEStandardExample - Build model....
o.d.e.t.TSNEStandardExample - Store TSNE Coordinates for Plotting....
o.d.plot.Tsne - Calculating probabilities of data similarities..
o.d.plot.Tsne - Mean value of sigma 0.00
o.d.plot.Tsne - Cost at iteration 0 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 1 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 2 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 3 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 4 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 5 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 6 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 7 was 98.8718490600586
o.d.plot.Tsne - Cost at iteration 8 was 98.87185668945312
o.d.plot.Tsne - Cost at iteration 9 was 98.87185668945312
o.d.plot.Tsne - Cost at iteration 10 was 98.87186431884766
...... ...... ...... ....... ...........
o.d.plot.Tsne - Cost at iteration 98 was 98.99024963378906
o.d.plot.Tsne - Cost at iteration 99 was 98.99067687988281
------------------------------------------------------------------------
BUILD SUCCESS
------------------------------------------------------------------------
Total time: 23.075 s
Finished at: 2015-11-01T13:45:06-08:00
Final Memory: 21M/721M
------------------------------------------------------------------------
Listing 3-3.Output from the deep learning 4j test routine
为了在我们的评估系统中利用deeplearning4j组件，我们现在必要对我们的 BDA pom 文件进行迄今为止最广泛的修改。完备的文件如清单 3-4 所示。
<projectxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.kildane</groupId>
<artifactId>bdt</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>Big Data Toolkit (BDT) Application</name>
<url>http://maven.apache.org</url>
<properties>
<!--new properties for deep learning (dl4j) components -->
<nd4j.version>0.4-rc3.5</nd4j.version>
<dl4j.version> 0.4-rc3.4 </dl4j.version>
<canova.version>0.0.0.11</canova.version>
<jackson.version>2.5.1</jackson.version>
<hadoop.version>0.20.2</hadoop.version>
<mahout.version>0.9</mahout.version>
</properties>
<!--distribution management for dl4j-->
<distributionManagement>
<snapshotRepository>
<id>sonatype-nexus-snapshots</id>
<name>Sonatype Nexus snapshot repository</name>
<url>https://oss.sonatype.org/content/repositories/snapshots</url>
</snapshotRepository>
<repository>
<id>nexus-releases</id>
<name>Nexus Release Repository</name>
<url>http://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
</repository>
</distributionManagement>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.nd4j</groupId>
<artifactId>nd4j-jcublas-7.5</artifactId>
<version>${nd4j.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<repositories>
<repository>
<id>pentaho-releases</id>
<url>http://repository.pentaho.org/artifactory/repo/</url>
</repository>
</repositories>
<dependencies>
<!--dependencies for dl4j components -->
<dependency>
<groupId>org.deeplearning4j</groupId>
<artifactId>deeplearning4j-nlp</artifactId>
<version>${dl4j.version}</version>
</dependency>
<dependency>
<groupId>org.deeplearning4j</groupId>
<artifactId>deeplearning4j-core</artifactId>
<version>${dl4j.version}</version>
</dependency>
<dependency>
<groupId>org.nd4j</groupId>
<artifactId>nd4j-x86</artifactId>
<version>${nd4j.version}</version>
</dependency>
<dependency>
<groupId>org.jblas</groupId>
<artifactId>jblas</artifactId>
<version>1.2.4</version>
</dependency>
<dependency>
<artifactId>canova-nd4j-image</artifactId>
<groupId>org.nd4j</groupId>
<version>${canova.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-yaml</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>org.apache.solr</groupId>
<artifactId>solandra</artifactId>
<version>UNKNOWN</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-core</artifactId>
<version>${hadoop.version}</version>
</dependency>
<dependency>
<groupId>pentaho</groupId>
<artifactId>mondrian</artifactId>
<version>3.6.0</version>
</dependency>
<!-- add these five dependencies to your BDA project to achieve rule-based
support -->
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-core</artifactId>
<version>6.3.0.Final</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-persistence-jpa</artifactId>
<version>6.3.0.Final</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-spring</artifactId>
<version>6.0.0.Beta2</version>
</dependency>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming_2.10</artifactId>
<version>1.5.1</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-camel</artifactId>
<version>6.0.0.Beta2</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-jsr94</artifactId>
<version>6.3.0.Final</version>
</dependency>
<dependency>
<groupId>com.github.johnlangford</groupId>
<artifactId>vw-jni</artifactId>
<version>8.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.mahout</groupId>
<artifactId>mahout-core</artifactId>
<version>${mahout.version}</version>
</dependency>
<dependency>
<groupId>org.apache.mahout</groupId>
<artifactId>mahout-math</artifactId>
<version>0.11.0</version>
</dependency>
<dependency>
<groupId>org.apache.mahout</groupId>
<artifactId>mahout-hdfs</artifactId>
<version>0.11.0</version>
</dependency>
</dependencies>
<build>
<finalName>BDT</finalName>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.4.0</version>
<executions>
<execution>
<goals>
<goal>exec</goal>
</goals>
</execution>
</executions>
<configuration>
<executable>java</executable>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>1.6</version>
<configuration>
<createDependencyReducedPom>true</createDependencyReducedPom>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>org/datanucleus/**</exclude>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer
implementation="org. apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>reference.conf</resource>
</transformer>
<transformer
implementation="org. apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
<transformer
implementation="org. apache.maven.plugins.shade.resource.ManifestResourceTransformer">
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
Listing 3-4.Complete listing to include deeplearning 4j components
在扩充您的 BDA 评估项目以利用这个pom.xml之后，执行maven clean、install和package任务以确保您的项目精确编译。
3.3 Spring 框架和 Spring 数据的利用
Spring 框架( https://spring.io )及其相干框架 Spring 数据(projects.spring.io/spring-data)是重要的 glueware 组件，但是 Spring 框架也提供了各种各样的功能资源。这些包括安全性、ORM 连接性、基于模型-视图-控制器(MVC)的应用步伐开发等等。Spring Framework 利用面向方面的编程方法来办理横切关注点，并完全支持 Java 代码中各种称为“原型”的表明，最大限度地减少了手工制作样板文件的必要。
我们将在本书中利用 Spring Framework 来利用它提供的复杂功能资源，并研究 Spring Data Hadoop 组件(projects.spring.io/spring-hadoop/)，这是 Hadoop 和 Spring 的无缝集成。特殊是，我们将在第九章开发的完备分析系统中利用几个 Spring 框架组件。
3.4 数字和统计库:R、Weka 和其他
在这一节中，我们将讨论 R 和 Weka 统计库。R ( r-project.org)是一种专门为统计分析开发的表明性高级语言。Weka ( http://www.cs.waikato.ac.nz/ml/weka )是一个强盛的统计库，为数据发掘和其他分析任务提供机器学习算法。一个有趣的新发展是分布式 R 和分布式 Weka 工具包。有关 Mark Hall 的 DistributedWekaBase 和 Distributed Weka 的信息，请访问
[*]http://weka.sourceforge.net/packageMetaData/distributedWekaBase/index.html
[*]http://weka.sourceforge.net/packageMetaData/distributedWekaHadoop/index.html
3.5 分布式系统中的 OLAP 技术
OLAP(在线分析处理)是另一种古老的分析技术，它在 20 世纪 70 年代就已经出现，并在“大数据时代”复兴已经开发了几个强盛的库和框架来支持大数据 OLAP 操纵。此中最有趣的两个是 Pentaho 的 Mondrian ( http://community.pentaho.com/projects/mondrian/ )和 Apache 的一个新孵化器项目 Apache Kylin ( http://kylin.incubator.apache.org )。Pentaho Mondrian 提供了一个开源的分析引擎和自己的查询语言 MDX。要将 Pentaho Mondrian 添加到您的评估系统中，请将这个存储库和依靠项添加到您的pom.xml中:
<repository>
<id>pentaho-releases</id>
<url>http://repository.pentaho.org/artifactory/repo/</url>
</repository>
<dependency>
<groupId>pentaho</groupId>
<artifactId>mondrian</artifactId>
<version>3.6.0</version>
</dependency>
Apache Kylin 提供了 ANSI SQL 接口和多维分析，利用了 Hadoop 功能。Apache Kylin 也支持 Tableau ( get.tableau.com)等贸易智能工具。
在第九章中，我们将利用 Apache Kylin 开发一个完备的分析引擎示例来提供 OLAP 功能。
3.6 用于分析的 Hadoop 工具包:Apache Mahout 和朋友
Apache Mahout ( mahout.apache.org)是一个机器学习库，专门计划用于 Apache Hadoop，以及更新版本的 Mahout 和 Apache Spark。像大多数现代软件框架一样，Mahout 与 Samsara 耦合，Samsara 是一个与 Mahout 协作的附加组件，为 Mahout 功能提供高级数学库支持。Apache Mahout 也可以与 MLlib 等兼容库一起利用。关于高级功能的更多信息可以在 Apache Mahout 和其他基于 Hadoop 的机器学习包的大量教程和书籍中找到。
Mahout 包罗很多为分布式处理实现的标准算法。此中一些算法包括分类算法，如随机森林分类算法、多层感知器神经网络分类器的实现、朴素贝叶斯分类器和很多其他分类算法。这些可以单独利用，也可以作为数据管道中的阶段利用，乃至可以与精确的设置设置并利用用。
Vowpal Wabbit ( https://github.com/JohnLangford/vowpal_wabbit )是雅虎发起的一个开源项目并由微软研究院继续。大众的一些特性包括希罕降维、快速特性查找、多项式学习和集群并行学习，所有这些都是在我们的 BDA 系统中利用的有效技术。VW 最有趣的扩展之一是 RESTful web 界面，可以在
关于 Vowpal-Wabbit 以及如何精确设置和运行 VW 的具体讨论，请参见 http://zinkov.com/posts/2013-08-13-vowpal-tutorial/ 。
要安装大众系统，您可能必要先安装boost系统。
在 Mac OS 上，键入以下三个下令(如果您愿意，可以稍后重新chmod您的/usr/local/lib):
sudo chmod 777 /usr/local/lib
brew install boost
brew link boost
git clone git://github.com/JohnLangford/vowpal_wabbit.git
cd $VW_HOME
make
make test
你可能还想研究一下大众非常有趣的网络界面，可以在 https://github.com/eHarmony/vw-webservice 找到。要安装:
git clone https://github.com/eHarmony/vw-webservice.git
cd $VW_WEBSERVICE_HOME
mvn clean install package
3.7 Apache Mahout 中的可视化
Apache Mahout 具有基于java.awt图形包的内置集群可视化功能。聚类可视化的一个简朴例子如图 3-2 所示。在可视化技术一章中，我们将讨论这个基本系统的扩展和替换方案，旨在提供更高级的可视化功能，扩展可视化控件和表现，以包括“作为大数据的图像”表现以及一些以 Mahout 为中心的仪表板。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_3_Fig2_HTML.jpg&pos_id=img-vKnYvhp5-1723617460899
图 3-2。
A simple data point visualization using Apache Mahout
3.8 Apache Spark 库和组件
Apache Spark 库和组件对于本书中开发的 BDA 系统的开发是必不可少的。为了帮助开发职员，Spark 附带了 Python 交互式 shell 和 Scala 交互式 shell。随着本书的进展，我们将具体相识 Apache Spark，因为它是 Hadoop MapReduce 技术最有效的替换技术之一。在这一部分中，我们将提供对 Spark 技术及其生态系统的高水平概述。
3.8.1 多种不同的外壳可供选择
有很多 Python 和 Scala shells 可供选择，在 Java 9 中，我们可以期待一个基于 Java 的读取-评估-打印循环(REPL)。
要运行 Spark Python shell，请键入:
/bin/pyspark --master spark://server.com:7077 --driver-memory 4g --executor-memory 4g
要运行 Spark Scala shell，请键入:
./spark-1.2.0/bin/spark-shell --master spark://server.com:7077 --driver-memory 4g --executor-memory 4g
一旦你乐成安装了sparkling-water包，你就可以利用如图 3-4 所示的闪亮外壳作为你的 Scala 外壳。为了方便起见，它已经有了一些到 Apache Spark 的方便挂钩。
3.8.2 Apache Spark 流
Spark Streaming 是一个容错、可伸缩和高吞吐量的流处理器。
Note
Apache 流正在积极开发中。关于 Spark 流的信息经常发生变化。请参考 http://spark.apache.org/docs/latest/streaming-programming-guide.html 以获取 Apache 流的最新信息。在本书中，我们主要指的是 Spark 1.5.1 版本。
要将 Spark 流添加到您的 Java 项目中，请将这个依靠项添加到您的pom.xml文件中(从 Spark 网站获取最新的版本参数以供利用):
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming_2.10</artifactId>
<version>1.5.1</version>
</dependency>
图 3-3 中表现了 Spark 流系统的简图。输入数据流通过 Spark 引擎进行处理，并作为批量处理数据发出。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_3_Fig3_HTML.jpg&pos_id=img-bYlKElHl-1723617460899
图 3-3。
A simplified diagram of the Spark Streaming system
Spark Streaming 还兼容亚马逊 Kinesis ( https://aws.amazon.com/kinesis/ )，即 AWS 数据流平台。
3.8.3 苏打水和 H20 机器学习
苏打水(h20.ai)是 H20 机器学习工具包，集成到 Apache Spark 中。对于苏打水，您可以利用 Spark 数据结构作为 H20s 算法的输入，并且有一个 Python 接口允许您直接从 PyShe ll 利用苏打水。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_3_Fig4_HTML.jpg&pos_id=img-ehH0LSWh-1723617460899
图 3-4。
Running the Sparkling Water shell to test your installation
3.9 组件利用和系统构建示例
在本节中，我们将利用 Solandra (Solr + Cassandra)系统作为构建 BDA 的简朴示例，该系统具有执行大数据分析所需的所有要素。在第一章中，我们扼要先容了 Solr，一个开源的 RESTful 搜刮引擎组件，它与 Hadoop 和卡珊德拉 NoSQL 数据库都兼容。我们的大部分设置可以利用 Maven 来完成，如清单 3-4 所示。您会注意到，这里列出的 pom 文件与我们最初的项目 pom 文件雷同，增长了 Solr、Solandra 和 Cassandra 组件的依靠项。
[*] 从 Git 源( https://github.com/tjake/Solandra ):
git clone https://github.com/tjake/Solandra.git
下载 Solandra
[*] cd到 Solandra 目录，用 Maven:
cd Solandra
mvn -DskipTests clean install package
创建 JAR 文件
[*] 将 JAR 文件添加到本地 Maven 存储库中，因为 Solandra 还没有标准的 Maven 依靠项:
mvn install:install-file -Dfile=solandra.jar -DgroupId=solandra -DartifactId=solandra -Dpackaging=jar -Dversion=UNKNOWN
[*] 修改您的 BDA 系统pom.xml文件，并添加 Solandra 依靠项:
<dependency>
<groupId>org.apache.solr</groupId>
<artifactId>solandra</artifactId>
<version>UNKNOWN</version>
</dependency>
[*] 测试你的新 BDA pom.xml :
cd $BDA_HOME
mvn clean install package
Building the Apache KAFKA Messaging System
在这一节中，我们将具体讨论如何设置和利用 Apache Kafka 消息通报系统，这是我们的示例 BDA 框架的一个重要组件。
[*] 从 http://kafka.apache.org/downloads.html 下载阿帕奇卡夫卡 TAR 文件
[*] 设置KAFKA_HOME环境变量。
[*] 解压文件并转到KAFKA_HOME(在这种情况下KAFKA_HOME就是/Users/kerryk/Downloads/kafka_2.9.1-0.8.2.2)。
[*] 接下来，通过键入
bin/zookeeper-server-start.shconfig/zookeeper.properties
启动 ZooKeeper 服务器
[*] 一旦 ZooKeeper 服务启动并运行，输入:
bin/kafka-server-start.sh config/server.properties
[*] 要测试主题创建，请键入:
bin/kafka-topics.sh –create –zookeeper localhost:2181 –replication-factor 1 –partitions 1 –topic ProHadoopBDA0
[*] 要提供所有可用主题的列表，请键入:
bin/kafka-topics.sh –list –zookeeper localhost:2181
在这一阶段，结果将是ProHadoopBDA0，这是您在步调 5 中定义的主题的名称。
[*] 从控制台发送一些消息来测试消息发送功能。键入:
bin/kafka-console-producer.sh –broker-list localhost:9092 –topic ProHadoopBDA0
现在在控制台中键入一些消息。
[*] 您可以通过修改得当的设置文件来设置多代理集群。查看 Apache Kafka 文档，相识如何实现这一点的分步过程。
3.10 示例系统的包装、测试和记录
在这一节中，我们将讨论 BDA 单元和集成测试。我们将讨论 Apache Bigtop ( bigtop.apache.com)和 Apache MRUnit ( mrunit.apache.com)。
import unittest
class TestStringMethods(unittest.TestCase):
def test_upper(self):
self.assertEqual('foo'.upper(), 'FOO')
def test_isupper(self):
self.assertTrue('FOO'.isupper())
self.assertFalse('Foo'.isupper())
def test_split(self):
s = 'hello world'
self.assertEqual(s.split(), ['hello', 'world'])
# check that s.split fails when the separator is not a string
with self.assertRaises(TypeError):
s.split(2)
if __name__ == '__main__':
unittest.main()
Listing 3-5.Example of Python unit testing
from
https://docs.python.org/2/library/unittest.html
为了进行测试，整本书我们将利用来自 http://archive.ics.uci.edu/ml/machine-learning-databases/ 的测试数据集以及来自 http://www.dm.unibo.it/~simoncin/DATA.html 的博洛尼亚大学的数据库。对于 Python 测试，我们将利用 py unit(Java 单元测试 JUnit 框架的一个基于 Python 的版本)和 pytest ( pytest.org)，一个替换的 Python 测试框架。清单 3-5 表现了 Python 测试组件的一个简朴示例。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_3_Fig5_HTML.jpg&pos_id=img-QDLyWtzU-1723617460900
图 3-5。
An architecture diagram for the “Sparkling Water” Spark + H20 System
3.11 摘要
在这一章中，我们利用了一个可扩展示例系统的第一部分来帮助引发我们关于基于 Hadoop 和 Spark 的大数据分析的标准库的讨论。我们还相识到，固然有数不清的库、框架和工具包用于广泛的分布式分析领域，但是所有这些组件都可以通过小心利用良好的开发环境来顺从。我们选择了 Eclipse IDE、Scala 和 Python 插件支持，并利用 Maven、npm、easy_install 和 pip 构建工具来简化我们的工作并帮助构造我们的开发过程。仅利用 Maven 系统，我们就能够将大量工具集成到一个简朴但功能强盛的图像处理模块中，该模块拥有良好的 BDA 数据流水线应用步伐的很多基本特性。
在本章中，我们反复回到了模块化计划的主题，展示了如何利用我们在第一章中讨论的标准十步流程来定义和构建各种数据管道系统。我们还相识了可用于帮助我们的库的类别，包括数学、统计、机器学习、图像处理和很多其他方面。我们具体讨论了如何安装和利用 Apache Kafka 消息通报系统，这是我们在本书别的部分的示例系统中利用的一个重要组件。
有很多语言绑定可用于这些大数据 Hadoop 包，但我们将讨论局限于 Java、Scala 和 Python 编程语言。如果应用步伐必要，您可以自由利用其他语言绑定。
我们没有忽视我们的示例系统的测试和文档。固然这些组件通常被视为“必要的邪恶”、“附加的”、“多余的”或“不必要的”，但是单元和集成测试仍然是任何乐成的分布式系统的关键组件。我们讨论了 MRUnit 和 Apache Bigtop 作为评估 BDA 系统的可行测试工具。有效的测试和文档导致有效的分析和优化，以及在很多其他方面的团体系统改进。
我们不但学习了如何利用 Apache Mahout 构建以 Hadoop 为中心的 BDA，还学习了如何利用 Apache Spark 作为底子构建模块，利用 PySpark、MLlib、H20 和 Sparkling Water 库。用于机器学习和 BDA 构建的 Spark 技术现在是利用强盛的机器学习、认知计算和自然语言处理库来构建和扩展您自己的 BDA 系统的成熟而有效的方法。
3.12 参考文献
贾科姆利，皮耶罗。阿帕奇看象人食谱。英国伯明翰。，派克彪炳版社，2013 年。
古普塔，阿希什。学习 Apache Mahout 分类。英国伯明翰。，派克彪炳版社，2015 年。
格兰杰、特雷和波特、蒂莫西。Solr 在办法。纽约州谢尔特岛:曼宁出版公司，2014 年。
穆罕默德·古勒。Spark 大数据分析:Spark 大规模数据分析实践指南。Apress/Springer 科学+贸易媒体纽约，2015 年。
麦克肯多斯，迈克尔，哈奇，埃里克，另有高斯波德尼克，奥蒂斯。Lucene 在办法，第二版。纽约州谢尔特岛:曼宁出版公司，2010 年。
欧文、肖恩、安尼尔、罗伯特、邓宁、泰德和弗里德曼、艾伦。看象人在办法。纽约州谢尔特岛:曼宁出版公司，2011 年。
道格·特恩布尔和约翰·贝里曼。相干搜刮:Solr 和 Elasticsearch 的应用。纽约州谢尔特岛:曼宁出版公司，2016 年。
四、关系数据库、NoSQL 数据库和图数据库
在本章中，我们描述了数据库在分布式大数据分析中的作用。数据库范例包括关系数据库、文档数据库、图数据库等，它们可以在我们的分析管道中用作数据源或接收器。这些数据库范例中的大多数都可以与 Hadoop 生态系统组件以及 Apache Spark 很好地集成。不同种类的数据库和 Hadoop/Apache Spark 分布式处理之间的连接可能由 Spring Data 或 Apache Camel 等“glueware”提供。我们描述了关系数据库，如 MySQL，NoSQL 数据库，如 Cassandra，图数据库，如 Neo4j，以及如何将它们与 Hadoop 生态系统集成。
有一系列数据库范例可供您利用，如图 4-1 所示。这些包括平面文件(乃至 CSV 文件也是一种数据库)、关系数据库(如 MySQL 和 Oracle)、关键值数据存储(如 Redis)、列数据库(如 HBase，Hadoop 生态系统的一部分)以及更奇特的数据库范例(如 graph 数据库，包括 Neo4J、GraphX 和 Giraph)
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig1_HTML.jpg&pos_id=img-1Q32Gqfr-1723617460900
图 4-1。
A spectrum of database types
我们可以将不同数据库范例的概念“抽象”为通用数据源，并提出一个公共 API 来连接、处理和输出这些数据源的内容。这让我们可以根据必要灵活地利用不同种类的数据库。偶然有必要采用“即插即用”的方法进行评估，大概构建概念验证系统。在这些情况下，利用 NoSQL 数据库(如 MongoDB)并与 Cassandra 数据库乃至图数据库组件进行性能比较会很方便。评估后，根据您的需求选择符合的数据库。为此利用符合的 glueware，无论是 Apache Camel、Spring Data 照旧 Spring Integration，都是构建可以快速更改的模块化系统的关键。glueware 的大部分代码可以保持与现有代码库雷同或相似。如果胶制品选择得当，只需最少的返工。
上面表现的所有数据库范例都可以用作分布式系统数据源，包括关系数据库，如 MySQL 或 Oracle。利用关系数据源实现的典型的基于 ETL 的处理流程可能看起来像图 4-2 中所示的数据流。
[*]循环开始。处理周期的开始是整个系统运行的入口部分。它是从那里开始调度处理任务的参考点，也是系统必须重新启动时的返回点。
[*]参考数据大楼。“引用数据”是指可以在单个表字段或键-值对的“值”部分中利用的有效数据范例。
[*]源提取。从原始数据源中检索数据，并对数据进行任何必要的预处理。这可能是开端的数据清理或格式化步调。
[*]验证阶段。评估数据的一致性。
[*]数据转换。对数据集执行“业务逻辑”操纵以产生中心结果。
[*]加载到临时表/数据缓存或存储库(如果利用的话)。临时表是中心数据存储区域，也可以是缓存或文档数据库。
[*]报告稽核(针对业务规则服从性或诊断/修复阶段)。计算并格式化报告结果，导出为可表现的格式(可以是任何格式，从 CSV 文件到网页，再到复杂的交互式仪表板表现)。其他形式的报告可以指示数据处理的服从、定时和性能数据、系统健康数据等。这些辅助报告支持主报告任务，即一致地传达对原始数据源内容的数据分析操纵的结果。
[*]发布到目的表/存储库。到目前为止，结果被导出到指定的输出表或数据存储库，这些输出表或数据存储库可以采用多种形式，包括键/值缓存、文档数据库，乃至图数据库。
[*]存档备份数据。拥有备份策略对于图数据和传统数据同样重要。复制、验证和高效规复是必须的。
[*]记录周期状态和错误。我们可以利用标准的日志结构，乃至在 Java 代码中的 Log4j 级别，大概我们可能希望在必要时利用更复杂的错误日志和报告。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig2_HTML.jpg&pos_id=img-FK2EIe2a-1723617460900
图 4-2。
Extract-Transform-Load (ETL) processing lifecycle
根据必要重复。您可以具体说明各个步调，大概根据必要专门办理您的各个领域的问题。
4.1 图形查询语言:Cypher 和 Gremlin
Cypher ( http://neo4j.com/developer/cypher-query-language/ )和 Gremlin ( http://tinkerpop.incubator.apache.org/gremlin.html )是两种比较知名的图查询语言。大多数情况下，对于具有 SQL 风格查询语言配景的步伐员来说，图形查询语言被计划得相对直观。图查询语言利用节点、边、关系和模式来形成关于被建模为图的数据集的断言和查询。有关 Gremlin 查询语言的更多信息，请参考 Apache TinkerPop 的网页( http://tinkerpop.incubator.apache.org )。
要利用新的 TinkerPop 3(撰写本书时正在酝酿项目),只需在 pom.xml 文件中包罗以下依靠项:
<dependency>
<groupId>org.apache.tinkerpop</groupId>
<artifactId>gremlin-core</artifactId>
<version>3.2.0-incubating</version>
</dependency>
一旦依靠关系在 Java 项目中就位，您就可以对 Java API 进行编程，如清单 4-1 和 4-2 所示。更多信息请参见在线文档: https://neo4j.com/developer/cypher-query-language/ 和 http://tinkerpop.incubator.apache.org 。
4.2 密码中的示例
要在 Cypher 中创建节点:
CREATE (kerry:Person {name:"Kerry"})
RETURN kerry
MATCH (neo:Database {name:"Neo4j"})
MATCH (arubo:Person {name:"Arubo"})
CREATE (anna)-[:FRIEND]->(:Person:Expert {name:"Arubo"})-[:WORKED_WITH]->(neo)
要利用 cURL 导出到 CSV 文件:
curl -H accept:application/json -H content-type:application/json \
-d '{"statements":[{"statement":"MATCH (p1:PROFILES)-[:RELATION]-(p2) RETURN ... LIMIT 4"}]}' \
http://localhost:7474/db/data/transaction/commit \
| jq -r '(.results) | .columns,.data[].row | @csv'
和计时性能，请利用
curl -H accept:application/json -H content-type:application/json \
-d '{"statements":[{"statement":"MATCH (p1:PROFILES)-[:RELATION]-(p2) RETURN ..."}]}' \
http://localhost:7474/db/data/transaction/commit \
| jq -r '(.results) | .columns,.data[].row | @csv' | /dev/null
4.3 Gremlin 中的示例
Gremlin 图形查询语言是 Cypher 的替换语言。
在图形中添加新顶点
g.addVertex(); g.commit();
这将必要多个语句。注意变量(jdoe 和 mj)是如何定义的，只需从 Gremlin 查询中给它们赋值。
jdoe = g.addVertex();mj = g.addVertex(); g.addEdge(jdoe,mj,'friend'); g.commit();
在 id 为 1 和 2 的两个现有顶点之间添加关系
g.addEdge(g.v(1),g.v(2),'coworker'); g.commit();
从图形中移除所有顶点:
g.V.each{g.removeVertex(it)}
g.commit();
从图形中删除所有边
g.E.each{g.removeEdge(it)}
g.commit();
移除名字为’ Kerry '的所有顶点
g.V('firstName','Kerry').each{g.removeVertex(it)}
g.commit();
移除 id 为 1 的顶点:
g.removeVertex(g.v(1));
g.commit();
移除 id 为 1 的边
g.removeEdge(g.e(1));
g.commit();
这是用您可能希望经常搜刮的特定字段来索引图表。例如，“我的字段”
g.createKeyIndex("frequentSearch",Vertex.class);
也可以利用 TinkerPop 的 Java API 来构建图形。在这些例子中，我们将利用本誊写作时的尖端版本(3-孵化)。
有关 TinkerPop 系统的具体讨论，请参见 http://tinkerpop.apache.org 。
出于管理数据的目的，参考数据由值集、状态代码或分类模式组成:这些是适用于事务的数据对象。例如，如果我们设想进行 ATM 取款生意业务，我们可以设想这种生意业务的相干状态代码，如“乐成(S)”、“取消(CN)”、“资金不可用(FNA)、“卡已取消(CC)”等。
参考数据通常是统一的、全公司范围的，可以在一个国家内创建，也可以由外部标准化机构创建。某些范例的参考数据，如钱币和钱币代码，总是标准化的。其他的，比如一个构造内员工的职位，就不那么标准化了。
主数据和相干的事务数据被组合在一起，作为事务记录的一部分。
参考数据通常是高度标准化的，要么是在公司内部，要么是由为标准化目的而设立的外部机构提供的标准化代码。
与生意业务过程相干的数据对象被称为参考数据。这些对象可以是分类模式、值集或状态对象。
记录周期状态和错误可能非常简朴，只需在编程的 Java 组件中设置“日志级别”,让基于步伐的日志记录来完成剩下的工作，大概构建整个系统来完成复杂的日志记录、监控、警报和定制报告。固然，在大多数情况下，仅仅信任 Java 日志是不够的。
基于模型-视图-控制器(MVC)模式的简朴图数据库应用步伐如图 4-3 所示。图形查询语言可以是 Cypher 或 Gremlin，这是我们在本章前面讨论的两种图形查询语言。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig3_HTML.jpg&pos_id=img-MCnvvJCV-1723617460900
图 4-3。
MVC and graph database components
4.4 图数据库:Apache Neo4J
图数据库相对来说是 NoSQL 数据库领域的新人。Apache Neo4j 包(neo4j.org)是最盛行和利用最广泛的图数据库之一。利用 Neo4j 的 Spring 数据组件( http://projects.spring.io/spring-data-neo4j/ ))可以很轻易地将 Neo4j 图数据库集成到您的分布式分析应用步伐中。只需确保 pom.xml Maven 文件中存在得当的依靠关系:
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-neo4j</artifactId>
<version>4.1.1.RELEASE</version>
</dependency>
肯定要记得提供精确的版本号，大概让它成为 pom.xml 标签中的属性之一。
在以 Hadoop 为中心的系统中，图数据库有很多用途。它们可以是中心结果存储库，保存计算的最终结果，乃至为仪表板组件提供一些相对简朴的“开箱即用”的可视化功能，如图 4-4 所示。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig4_HTML.jpg&pos_id=img-4RuELgcW-1723617460900
图 4-4。
Simple Neo4J data graph visualization
让我们尝试一个简朴的加载和表现 Neo4j 步伐来开始。该步伐利用标准的 pom.xml，包罗在本书包罗的“大数据分析工具包”软件中:这个 pom.xml 包罗运行我们步伐所必须的依靠项，如清单 4-1 所示。
import org.neo4j.driver.v1.*;
public class Neo4JExample {
public static void main (String... args){
// NOTE: on the next line, make sure you have a user defined with the appropriate password for your
// authorization tokens.
Driver driver = GraphDatabase.driver( "bolt://localhost", AuthTokens.basic( "neo4j", "datrosa2016" ) );
Session session = driver.session();
session.run( "CREATE (a:Person {name:'Kerry', role:'Programmer'})" );
StatementResult result = session.run( "MATCH (a:Person) WHERE a.name = 'Kerry' RETURN a.name AS name, a.role AS role" );
while ( result.hasNext() )
{
Record record = result.next();
System.out.println( record.get( "role" ).asString() + " " + record.get("name").asString() );
}
System.out.println(".....Simple Neo4J Test is now complete....");
session.close();
driver.close();
}
}
Listing 4-1.package com.apress.probda.database;
4.5 关系数据库和 Hadoop 生态系统
关系数据库在 Hadoop 之前已经存在很长时间了，但它们与 Hadoop、Hadoop 生态系统以及 Apache Spark 非常兼容。我们可以利用 Spring Data JPA ( http://docs.spring.io/spring-data/jpa/docs/current/reference/html/ )将主流的关系数据库技术与分布式环境团结起来。Java Persistence API 是一个规范(用 Java 编写)，用于管理、访问和持久化基于对象的 Java 数据和关系数据库，如 MySQL ( dev.mysql.com )。在这一节中，我们将利用 MySQL 作为关系数据库实现的例子。很多其他关系数据库系统可以用来代替 MySQL。
4.6 Hadoop 和统一分析(UA)组件
Apache Lens(lens.apache.org)是一种为 Hadoop 生态系统提供“统一分析”(UA)的新型组件，如图 4-5 所示。统一分析源于如许一种认识，即软件组件、语言方言和技术堆栈的激增使得至少部分分析任务的标准化变得至关重要。统一分析试图以同样的方式标准化数据访问语义，RESTful APIs 和语义 web 技术如 RDF(利用 RDF-REST: http://liris.cnrs.fr/~pchampin/rdfrest/ )和 OWL ( http://owlapi.hets.eu )提供标准化的语义。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig5_HTML.jpg&pos_id=img-Goik6wie-1723617460900
图 4-5。
Apache LENS architecture diagram
与我们在本书中讨论的大多数组件一样，Apache Lens 易于安装。下载网站的最新版本(我们的版本是 http://www.apache.org/dyn/closer.lua/lens/2.5-beta )，展开压缩的 TAR 文件，然后运行
mvn –DskipTests clean package
镜头系统，包括镜头 UI 组件，将会构建，包括如图 4-6 所示的 Apache 镜头 UI。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig6_HTML.jpg&pos_id=img-rcEXJWqp-1723617460900
图 4-6。
Apache LENS installed successfully using Maven on MacOSX
通过在任何欣赏器中访问 localhost:8784 默认镜头网页来登录 Apache Lens。您的登录屏幕将出现如图 4-8 所示。
通过键入以下下令运行镜头 REPL:
./lens-cli.sh
你会看到类似图 4-7 的结果。在交互式 shell 中键入“help”以查看您可以尝试的 OLAP 下令列表。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig8_HTML.jpg&pos_id=img-XIws8Mj6-1723617460901
图 4-8。
Apache LENS login page .Use ‘admin’ for default username and ‘admin’ for default password.
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig7_HTML.jpg&pos_id=img-vGZu4Mn1-1723617460901
图 4-7。
Using the Apache Lens REPL
Apache Zeppelin ( https://zeppelin.incubator.apache.org )是一个基于 web 的多用途笔记本应用步伐，支持数据摄取、发现和交互式分析操纵。Zeppelin 兼容 Scala、SQL 和很多其他组件、语言和库。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig10_HTML.jpg&pos_id=img-CRHAwB74-1723617460901
图 4-10。
Successful Maven build of the Zeppelin notebook
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig9_HTML.jpg&pos_id=img-0rMfCrdc-1723617460901
图 4-9。
. Successfully running the Zeppelin browser UI
mvn clean package -Pcassandra-spark-1.5 -Dhadoop.version=2.6.0 -Phadoop-2.6 –DskipTests
然后
mvn verify
利用
bin/zeppelin-daemon.sh start
来启动 Zeppelin 服务器
bin/zeppelin-daemon.sh stop
克制齐柏林飞船的服务器。运行入门教程来测试在 https://zeppelin.apache.org/docs/0.6.0/quickstart/tutorial.html 利用齐柏林飞艇。Zeppelin 对于与 Apache Spark 应用步伐以及 NoSQL 组件(如 Apache Cassandra)的接口特殊有效。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig11_HTML.jpg&pos_id=img-wxZ0G29R-1723617460901
图 4-11。
Zeppelin-Lens-Cassandra architecture , with data sources
OLAP 在 Hadoop 生态系统中依然生气勃勃。例如，Apache Kylin ( http://kylin.apache.org )是用于 Hadoop 的开源 OLAP 引擎。Apache Kylin 支持分布式分析、内置安全性和交互式查询功能，包括 ANSI SQL 支持。
Apache Kylin 依靠 Apache 方解石( http://incubator.apache.org/projects/calcite.html )来提供一个“SQL 焦点”
要利用 Apache 方解石，请确保 pom.xml 文件中有以下依靠项。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig12_HTML.jpg&pos_id=img-mNsPKxvB-1723617460901
图 4-12。
HSQLDB installation from the command line
<dependency>
<groupId>org.apache.calcite</groupId>
<artifactId>calcite-core</artifactId>
<version>1.7.0</version>
</dependency>
要安装 HSQLDB 工具，只需执行
curl -L -O http://search.maven.org/remotecontent?filepath=org/hsqldb/sqltool/2.3.2/sqltool-2.3.2.jar
和
curl -L -O http://search.maven.org/remotecontent?filepath=org/hsqldb/hsqldb/2.3.2/hsqldb-2.3.2.jar
在下令行上。您应该会看到类似于图 4-13 的安装结果。如您所见，方解石与我们一直在谈论的很多数据库兼容。可以利用 Cassandra、Spark 和 Splunk 的组件。
https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-bigdata-zh%2Fraw%2Fmaster%2Fdocs%2Fpro-hadoop-data-anal%2Fimg%2FA371868_1_En_4_Fig13_HTML.jpg&pos_id=img-V4HzTlWB-1723617460902
图 4-13。
Successful installation of Apache Calcite
4.7 总结
在本章中，我们讨论了各种数据库范例、可用的软件库以及如何以分布式方式利用数据库。应该强调的是，有很多数据库技术和库可以与 Hadoop 和 Apache Spark 一起利用。正如我们所讨论的，当将 BDA 系统与数据库技术集成时，Spring Data project、Spring Integration 和 Apache Camel 等“glueware”尤其重要，因为它们允许将分布式处理技术与更主流的数据库组件集成。由此产生的协同作用允许构建的系统利用关系、NoSQL 和图形技术来帮助实现业务逻辑、数据清理和验证、报告以及分析生命周期的很多其他部分。
我们讨论了两种最盛行的图形查询语言，Cypher 和 Gremlin，并查看了一些简朴的例子。我们看了看小精灵 REPL，在那里做了一些简朴的操纵。
当谈到图数据库时，我们将重点放在 Neo4j 图数据库上，因为它是一个易于利用的全功能包。不外请记住，有几个类似的包同样有效，包括 Apache Giraph (giraph.apache.org)、TitanDB ( http://thinkaurelius.github.io/titan/ )、OrientDB ( http://orientdb.com/orientdb/ )、Franz 的 AllegroGraph ( http://franz.com/agraph/allegrograph/ ))。
在下一章，我们将更具体地讨论分布式数据管道——它们的结构、必要的工具包，以及如何计划和实现它们。
4.8 参考文献
霍佩，格雷戈尔，和伍尔夫，鲍比。企业集成模式:计划、构建和部署消息通报办理方案。波士顿，麻州:艾迪生-卫斯理出版公司，2004 年。
易卜生，克劳斯，和斯特兰昌，詹姆斯。办法中的阿帕奇骆驼。纽约州谢尔特岛:曼宁出版公司，2010 年。
马尔泰拉，克罗迪奥，洛格西提斯，狄俄尼索斯，沙波什尼克，罗马。利用 Apache Giraph 的实用图形分析。纽约:新闻媒体，2015 年。
波拉克，马克，格尔克，奥利弗，里斯伯格，托马斯，布里斯班，约翰，和饥饿，迈克尔。Spring Data:企业 Java 的现代数据访问。塞瓦斯托波尔，加利福尼亚州:奥莱利媒体，2012 年。
拉杰索纳尔。Neo4J 高性能。英国伯明翰:PACKT 出版社，2015 年。
《七周七个数据库:现代数据库和 NoSQL 活动指南》。北卡罗来纳州罗利:务实的步伐员，2012 年。
武科蒂奇，亚历克莎，瓦特，尼基。Neo4j 在办法。纽约州谢尔特岛:曼宁出版社，2015 年。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]