修竹

Hive Udf函数未完成

2018-05-17T00:00:00+00:00

Hive-UDF函数

hive语句以分号结尾

controlV+controlA

Bloomfilter未完成

2018-05-17T00:00:00+00:00

BloomFilter

Bloom Filter是一种空间效率很高的随机数据结构，它利用位数组很简洁地表示一个集合，并能判断一个元素是否属于这个集合。Bloom Filter的这种高效是有一定代价的：在判断一个元素是否属于某个集合时，有可能会把不属于这个集合的元素误认为属于这个集合（false positive），但是不会把属于这个集合的元素误认为不属于这个集合。

因此它可以优化随机读的性能，会增加存储的消耗，但不能用于过滤数据。

以错误率换空间的一种方法。

Hadoop学习系列之：spark生态体系

2018-05-15T00:00:00+00:00

Spark生态体系

1. Spark基本原理

####1.1 Spark概述

基于内存计算的、分布式批处理引擎，适合应用在迭代计算、交互式分析等场景。

容错性，可扩展性

大多数现有集群计算框架如MR等都是基于从稳定存储（文件系统）到稳定存储的非循环数据流，数据重用都是基于磁盘的，执行效率比较低。

特点：

轻，源代码：scala语言
快，某些时候比MR性能高100倍
灵活
巧妙的和hadoop无缝对接，可以利用hadoop的周边服务
开发效率更高

1.2 Spark技术架构

资源调配层：
- Standalone Scheduler：管理开源的spark
- Spark on YARN：HUAWEI使用
- Spark on Mesos
Spark Core：spark计算核心，将中间计算结果直接放在内存，提高计算性能
Spark应用框架：
- Spark SQL structured data：处理结构化数据的spark组件、对数据执行类sql的查询
- Spark Streaming real-time：steaming是华为对storm的一个封装（微批式），实时性比storm差点，但是吞吐量大
- MLib machine learning：分类、聚类等
- GraphX graph processing：图计算：研究客观世界中事物事物之间的关系、然后对事物进行刻画和分析。场景：社交网络分析、生物学、工程制造（集成电路设计）、安全分析等等

1.3 Spark应用运行流程——角色

Client：需求提出方，负责提交需求（应用）
Driver：spark大脑，负责应用的业务逻辑和运行规划（DAG图）
ApplicationMaster：负责应用的资源管理，根据应用的需要向资源管理部门（RM）申请资源
ResourceManager：资源管理部门，负责整个集群的资源统一调度和分配
Executor：负责实际计算工资，一个应用application拆分成多个exector来进行计算。
task：具体计算单位，每个executor有一个或多个task，每个task对应一个job

1.4 Spark应用运行流程

1.5 Spark application基本概念

Application：Spark用户程序，提交一次应用为一个application，一个APP会启动一个SparkContext，也就是app的driver，驱动整个app的运行
Job：一个app可能包含多个job，每个action算子对应一个job；action算子有collect、count等
Stage：每个job可能包含剁成多个stage，划分标记为shuffle过程（连接不同stage的纽带）；stage按照依赖关系依次执行。
task：具体执行任务基本单位，被发动executor上执行

2. Spark RDD

RDD，Resilient Distributed Datasets，弹性分布数据集，指一个只读的、可分区的分布式数据集。这个数据集的全部或部分可以缓存在内存中，在多次计算中重用。

2.1 RDD生成

从hadoop文件系统（或与hadoop兼容的其他存储系统）输入创建（如hdfs）
从父RDD转换得到新的RDD

2.2 RDD优点

RDD是只读的，可提供更高的容错能力。
RDD是只读的，所以有不可变性，可实现hadoop MR的推测式执行（若某节点没有在规定时间内完成相应任务，则MR会启动另一个节点做同样的任务，先完成的那个结果被采用，另外一个killed。因为数据不变，所以重新计算是可行的）。
RDD的数据分区特性，可以通过数据的本地性来提高性能（计算就近）
RDD都是可序列化的，在内存不足时可自动化降级为磁盘存储。

2.3 RDD存储和分区

用户可以根据不同的存储级别存储RDD——11种方式
RDD在需要进行分区时会根据每条记录key进行分区，保证两个数据集能高效进行join操作（可序列化）。

2.4 RDD特点

在集群节点上不可变的，是已分区的集合对象
失败后会自动重建（父RDD）
可以控制存储级别（内存、磁盘等）来进行重用
必须是可序列号的
是静态类型

2.5 RDD的创建

spark所有的操作都是围绕RDD进行，这是一个有容错机制并可以被并行操作的元素集合，具有只读、分区、容错、高效、无需物化、可以缓存、RDD依赖（宽依赖和窄依赖）等特征。

目前有两种基础RDD：

并行集合：接收一个已经存在的scala集合，然后进行并行计算

并行集合是通过调用SparkContext的parallelize方法，在一个已经存在的scala集合（一个seq对象）上创建的。集合的对象将会被copy，创建出一个可以被并行操作的分布式数据集。
hadoop数据集：在一个文件的每条记录上运行函数，只要文件系统是hdfs或Hadoop支持的任意存储系统

spark可以将任何hadoop支持的存储资源转换成RDD，如本地文件、hdfs、cassandra、hbase等，spark支持文本文件（slice数目不能少于block数目）、SequenceFiles（hadoop用来存储二进制key value而设计的平面文件）、任何Hadoop InputFormat格式（调用sparkContext.hadoopRDD方法）、通过transformation算子将hadoop RDD转换成其他RDD、通过血统机制转换RDD等。

这两种类型的RDD都可以通过相同的方式进行操作，从而获得子RDD一系列扩展，形成RDD血统关系图。

2.6 RDD算子

transformation算子

返回值还是一个RDD，如map、filter、join等。transfo是lazy的，代码调用到transformation的时候不会马上执行，需要等到action操作的时候才会启动真正计算过程。
action算子

如count、collect、save等，action操作是返回结果或者将结果写入存储的操作。Action是spark应用真正执行的触发动作。

2.7 RDD依赖：宽依赖和窄依赖

窄依赖：父RDD的每一个分区最多被一个子RDD的分区所用——一对一

优点：窄依赖可以支持在同一个class loader上以管道形式执行多调命令，例如在执行map之后紧接着就可以执行filter；从恢复角度考虑，子RDD数据丢失，只需要从父RDD的一个分区去找，恢复有效；对优化有力，减少全局barrier，无需物化中间结果的RDD，成为pipeline优化。
宽依赖：子RDD的分区依赖于父RDD的所有分区，是stage的划分依据。 ——一对多

stage划分：spark从DAG图末端出发，逆向遍历整个依赖关系，遇到宽依赖就断开，遇到窄依赖就将其加在当前的stage中。stage中task个数由stage末端的rdd分区个数来决定的，rdd转换是基于分区的粗粒度的计算，一个stage执行的结果就是这几个分区构成的RDD。

、

2.8 RDD样例程序-wordcount

3. Spark on Yarn

资源调度框架Yarn分为yarn-cluster和yarn-client两种模式，区别在于AppMaster不同。

yarn-cluster中AppMaster不仅负责资源分配、还负责监控task运行情况，此时client可以关掉了。——适合做生产，可以更快的看到app的输出

yarn-client中AppMaster只负责申请和分配资源，监控任务由client中的driver执行，此时client不可关掉。——适合做测试

4. Spark Streaming

Spark Streaming是spark核心API的一个扩展，对实时流式数据的处理具有可扩展性、高吞吐量、可容错性等特点。可以从kafka、hdfs等源获取数据，也可以通过高阶函数map、reduce、join、window等组成复杂算法计算出数据。最后处理好的数据可以推送到文件系统、数据库、实时仪表盘中。

4.1 spark streaming原理

Spark streaming接受实时的输入数据流，然后将这些数据切分成批数据供spark引擎处理（因为会切分的非常小，当足够小的时候可以近似看出流式数据，因此又称为微批式数据），spark引擎（core）将数据生成最终的结果数据。
使用DStream从kafka和hdfs等获得连续的数据流，streams由一系列RDD组成，每个RDD包含确定时间间隔的数据，任何对DStreams的操作都转成成对RDD的操作。

4.2 特点

高吞吐量、容错能力强
数据采集逐条进行，数据处理分批进行。批处理的时间间隔是核心参数，可以达到毫秒级别，最小可以到50ms，一般建议设置>=500ms
spark streaming牺牲一些实时性，提高吞吐量

优点：

粗粒度处理方式可以快速处理小批量数据
可以确保“处理且仅处理一次”，方便实现容错恢复机制
DStream操作基于RDD操作，降低学习成本

缺点：

粗粒度处理引入不可避免的延迟，所以说比storm实时性要差一些

4.3 spark streaming数据源和可靠性

Spark Streaming数据源：

基本源：HDFS等文件系统、socket连接等
高级源：kafka等
自定义源：需要实现用户自定义receiver

可靠性（二次开发）：

reliable receiver：能正确应答一个可靠源，确保数据被接受并且被正确复制到spark中
设置checkPoint
确保driver可以自动重启
使用wirte ahead log功能（WAL文件）

####4.4 Spark Streaming代码流程

常见业务代码逻辑：

创建StreamingContext
定义输入源
准备应用计算逻辑
使用streamingContext.start()方法接收和处理数据
使用streamingContext.stop()方法停止流计算

注意：

在JVM中，同一时间只能有一个StreamingContext处于活跃状态
可以在一个应用中创建多个DStream来接收多个数据流，每个输入流DStream与一个receiver对象关联，receiver从源中获取数据，并将数据存入内存中用于处理
receiver作为常驻进程运行在executor中，将占用一个核。因此给每个app分配的core的个数要大于receiver的个数。

4.5 Spark Streaming窗口操作

窗口定义：

窗口按照驱动类型分为：time window和account window。可以是时间或者数据驱动的。

按照固定时间划分的窗口叫时间滚动窗口，按照固定事件发生数量划分的窗口叫做事件滚动窗口。

将事件汇聚到窗口中，由非活跃时间隔开，叫做会话窗口，由事件之前时间间隔区分。

平滑窗口聚合：如按照每30s对之前一分钟的事件计算一次，叫做时间滑动窗口；如按照事件数量每10个事件计算一次，叫做事件滑动窗口。

Spark Streaming支持窗口计算（window-based operation），允许用户在一个滑动窗口数据应用transformation算子。窗子在源DStream上滑动，合并和操作落入窗内的源RDDs，产生窗口化的DStream的RDDs。

需要指定窗口长度、窗口滑动间隔，这两个参数最好设置为批处理时间间隔的倍数。

窗口操作的常用算子

4.6 Spark Streaming性能调优

设置合理的批处理时间（batchDuration）
设置合理的数据接收并行度
- 设置多个receiver接收数据
- 设置合理的receiver阻塞时间
设置合理的数据处理并行度：数据在存入spark内存之前都被合并成大的数据块，每批数据的个数决定了任务的个数，阻塞时间由spark.streaming.blockinterval决定，默认200ms；使用spark.default.areas设置并发任务数
使用Kryo系列化
内存调优
- 设置持久化级别减少GC开销
- 使用并发的标记-清理GC算法减少GC暂停时间

5. Spark SQL

用于结构化数据处理和类sql查询，通过spark sql可以针对不同数据类型和数据源执行ETL操作。

类似spark core的执行，只是多了一个sql语句解析成算子的过程。

SparkSQL使用方式：

spark-beeline是作为客户端连接到JDBC server上，sql语句在jdbc应用中执行。

spark-sql是在客户端中直接启动spark应用，只支持spark-client模式。

DataFrame介绍：

以RDD为基础，带有Schema信息，类似传统数据库的二维表。注册成表之后可以使用类SQL操作

DataFrame是一个分布式的row信息的集合，其中数据被组织为命名的列

DataFrame常用Transformation算子：filter、groupBy、join、sort、select、intersect、dropDuplicates等

DataFrame常用action算子：collect、count、first、show、take等

Hadoop学习系列之：流式数据处理（二）：storm计算框架

2018-05-12T00:00:00+00:00

流式数据处理（二）：storm计算框架

####1.Storm是什么

Storm是流式处理的计算框架。

Storm是twitter开源的一个关于hadoop的实时数据处理框架
Storm能实现高频数据和大规模数据的实时处理

特点：

事件驱动的类型，实时处理
实现连续查询
数据不存储，先计算
实时性强，低延迟

应用场景：

实时分析：实时日志处理、交通流量处理、股票信息处理等
实时统计：网站实时访问量、排序等
实时推荐：实时广告定位

术语：

Topology：用于封装一个实时计算应用程序的逻辑，类似MR Job
Stream消息流：是一个没有边界的tuple序列，tuples会被以一种分布式的方式并行创建和处理
spouts：消息源，消息生产者，从一个外部源读取数据并向topology里面发出消息：tuple
bolts：消息处理者，所有消息处理逻辑被封装在bolts里，处理输入的数据流并产生新的输出数据流，可执行过滤、聚合、查询数据库等操作
task：每一个spout和bolt会被当做很多歌task在整个集群中执行，每一个task对应一个线程
stream groupings：消息分发策略，定义一个topology的其中一步，定义每个tuple接受什么样的流作为输入；stream grouping用来定义一个stream应该如何分配给bolts们

2. Storm系统架构

同样也是master/slaver主从结构，但是把master和slaver分开，靠zookeeper联系。

Nimbus：Storm大脑，强依赖zookeeper（所以是主备管理），负责分发代码、为worker分配任务、故障检测

zookeeper：元数据存储，在nimbus和supervisor中协调，把一个topology分成多个子topology

supervisor：负责监听自己所在机器上的工作

worker：

executor：执行一个topology子集

task：具体任务

####3. Storm性能特征

storm并行度

storm集群中的1台物理机会启动1个或多个worker进程（jvm进程），每个worker进程运行某一个topology的executors，因此一个运行的topology是由多台机器上的多个worker进程组成的。
每个单独的work进程里会运行一个或多个executor线程，每个executor会运行同一个component（spout或bolt）的一个或多个task，线程数目可以动态调整（可以等于/小于task数目）
1个task是完成数据处理（代码）的实体单元（实例）

默认一个supervisor节点最多可以启动4个worker进程，每个topology默认占用一个worker进程，每个spout/bolt占用一个executor，每个executor默认启动一个task

Storm可靠性

Worker进程死掉：storm会自动恢复（supervisor会尝试重启，数次不成功之后，supervisor会在这个服务器重新启动worker）
supervision进程死掉：storm自动恢复，死亡状态下不会影响worker工作，原因同nimbus
nimbus进程死掉（存在HA问题），启动快速失败或者无状态：意外情况下进程会自动毁灭，无状态意思就是所有状态会保存在zookeeper或本地磁盘中（zookeeper的解耦功能），死亡状态下不会影响worker工作，会重启。
ack/fail消息确认机制：确保一个tuple被完全处理（完全处理的意思是：这个tuple以及由这个tuple所衍生的所有tuple都被成功处理）
- 每个streaming里面有一类特殊task—> ack，负责跟踪spout发出的每个tuple的tuple树。ack发现tuple树全部处理完成，会发送消息给产生tuple的task，成功返回ack，失败返回fail。
- 在spout发射tuple的时候会发送messageid，开启消息确认机制
- 如果topology里面tuple比较多，那么acker数量设置多一些，效率会提高
- 通过config.setNumAckers(num)来设置一个topology里面acker的数量，默认值1。
- acker用了特殊的算法，使得对于追踪每个spout tuple的状态所需要的内存恒定（20bytes）
- 如果一个tuple在指定的timeout(Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS默认值30s)时间内没有被成功处理，那么这个tuple会认为处理失败了

####4. Storm的java编程:作业提交与停止方式

向集群提交作业

storm jar *.jar xxxxMainClass
停止作业
- 先查询作业列表storm list
- 命令行下执行storm kill TopologyName或在storm ui上点击kill按钮

storm和mapreduce区别就是，MR在运行结束后自动结束进程，但是storm需要手动kill

Hadoop学习系列之：流式数据处理（三）：flume数据采集

2018-05-12T00:00:00+00:00

流式数据处理（三）：Flume数据采集

1. Flume定义

Flume是一个分布式、高可靠、高可用的服务，能够有效的收集、聚合、移动大量的日志数据。

适用场景：收集应用系统生成的日志信息，然后进行分析

不适用场景：大量数据的实时数据采集

主备管理

好处：

有一个简单、灵活的基于流的数据流结构
具有故障转移机制和负载均衡机制
使用了一个简单的可扩展数据模型（source，channel，sink），几乎不用用户自己开发client，对于每种数据源有相应的source去读取
flume可以从规定目录下采集日志，然后归到目的地，提供实时采集日志信息到目的地的能力
也可以通过特定方式采集日志
flume支持级联，提高并发性

flume-ng处理数据的两种方式：avro-client、agent：

avro-client：一次性将数据传输到指定的avro服务器客户端
agent：一个持续传输数据的服务
- Agent主要组件：Source、Channel、Sink

数据在组件传输的单位是Event，event就是flume中对数据的封装，也是flume中最小的模块

2. Flume系统架构

节点结构图

Source

主要作用：从外界采集各种类型数据，将数据传递给channel

Source种类：不需要用户自己去开发采集数据client了
- AvroSource：监听一个avro服务端口，采集avro数据序列化后的数据
- Thrift Source：监听一个thrift服务端口，采集thrift数据序列化后的数据
- Exec Source：基于unix的command在标注输出上采集数据
- JMS Source：java消息服务数据源，java消息服务是一个与具体平台无关的API，这是支持jms规范的数据源采集
- Spooling Directory Source：通过文件夹里的新增的文件作为数据源的采集
- Kafka Source：从kafka服务中采集数据
- NetCat Source：绑定的端口（tcp、udp），将流经端口的每一个文本行数据作为event输入
- HTTP Source：监听http post和get产生的数据的采集
Channel：一个数据的存储池，中间通道。有简单的清洗功能，也可以安装第三方插件对数据进行过滤清洗操作。

主要作用：接受source传出的数据，向sink指定的目的地传输。channel中的数据直到进入到下一个channel中或者进入终端才会被删除。当sink写入失败后，可以自动重写，不会造成数据丢失，因此很可靠。

channel类型：内存型（memory channel 使用内存作为数据存储，不对数据持久化，有可能造成数据丢失，但是内存计算速度快，吞吐量大）、jdbc数据源（JDBC channel 数据持久化，可靠高，基于嵌入式database的实现）、文件形式存储（file channel 基于war log实现的，也有持久化）等

常见采集的数据类型：memory channel、JDBC channel、Kafka channel、file channel、spillable memory channel（使用内存和文件作为数据的存储）等
Sink：数据最终的目的地

主要作用：接受channel写入的数据，以指定的形式表现出来（或存储或展示）

sink表现形式：打印到控制台、hdfs上、avro服务中、文件中等

常见采集的数据类型：HDFS sink、Hive sink、 Logger SINK、avro sink、thrift sink、file roll sink、hbase sink、kafka sink等

多agent架构（flume架构）：

####3. Flume例子

生成source并把数据通过channel 放到channel 中
kafka作为数据源，从kafka中抓取数据并存到目的地
kafka sink

Hadoop学习系列之：流式数据处理（一）：kafka消息队列

2018-05-12T00:00:00+00:00

流式数据处理（一）：Kafka消息队列

1. Kafka定义

高吞吐、分布式、基于发布订阅的消息系统。

Kafka特点：

高吞吐量
消息持久化到磁盘
分布式系统，易扩展
容错性好，不存在单点故障
多客户端支持
实时
利用kafka可以在廉价PC SERVER上搭建大规模消息订阅系统。

适用场景：大量数据的互联网服务的数据收集场景。

已对接组件：Streaing、Spark、Flume

Kafka优点：

解耦：消息产生（producer）和消费（consumer）系统可以独立变更
可靠：有效解决单点故障引发系统不可用问题
易扩展：生产、消费系统扩展简单
可恢复：消息缓存，支持故障后从故障点读取
异步通信：生产系统无需关心消费系统的消费时间

2. Kafka基本概念

kafka部署的实例个数不得小于2
zookeeper：负责kafka元数据管理、consumer相关数据管理
Topic：kafka处理消息源的不同分类。创建topic时，副本数不得大于当前存活的broker实例个数，否则创建topic会失效。设置副本可以增强kafka服务的容灾能力。
producer：决定将消息归属哪一个partition
partition：topic物理上的分组，一个topic有多个partition，每个partition都是有序而不可变的队列。引入此机制保证kafka高吞吐量。partition中每条消息都分配一个有序ID，称之为offset，所以在生产和消费过程中，不需要关注数据存储的partition是在哪个broker上，只需要指定topic即可。是个.log文件。
message：传递的数据对象。有四部分：offset，key，value，timestamp。offset，timestamp在集群中产生，key，value在producer产生
broker：服务端，可以存储消息，不生产消息。kafka中一台或多台服务器成为broker，每个broker都是一个实例。为减少磁盘I/O调用的次数，broker会将消息暂时buffer起来，达到阈值时在flash到磁盘。有一个无状态机制，没有副本机制，进入无状态机制可能导致消息删除出现问题，因此引入基于时间的服务保证，一般7天再删除。不保存consumer状态。
consumer：消息和数据的消费者，订阅topic和处理topic发布的消息。可以reverse back到任意位置进行重新消费，故障时可读取最小的offset进行重新消费记录。每个cosumer都属于一个consumer group。partition中的每个message只能被consumer group中的一个consumer(consumer 线程)消费，如果一个message可以被多个consumer消费，那这些consumer不能在一个组。但是一个consumer可以消费多个partition中的消息
对于一个topic，同一个group不能有多于这个topic的partition个数的consumer同时消费。
kafka只能顺序读取消息。
每个partition都会被kafka实例保存。kafka支持partition恢复策略，可以通过配置文件配置partition副本个数，选出leader，负责kafka读写操作，其他的负责数据同步。kafka会把leader均衡到每个实例上，减少单点压力。
分区可以把分件内容分到不同broker中，避免文件过大。

3. Kafka架构

zookeeper在kafka中作用

broker和consumer水平扩展。
存储元数据，管理consumer数据，当consumer数量发生变化， zookeeper需要对consumer进行再平衡。管理consumer和broker的动态加入和离开。consumer或broker加入或离开时触发负载均衡算法，由zookeeper指挥，使得一个consumer-broker类的多个consumer-borker订阅负载平衡
维护消费关系及每个partition的消费信息。

zookeeper如何实现作用：broker和consumerq启动后都会在zookeeper注册临时的broker/consumer registration。

4. kafka offset

每条消息在文件中的位置叫做offset，是一个long型数字，是唯一标记一条消息。kafka并没有提供其他额外的索引机制才存储offse，因为kafka中几乎不允许对消息进行随机读写。所以有新的消息，加在.log文件的尾部。

partition中每条message由offset来表示它在partition中的偏移量，但是offset不是该message在partition数据文件中的实际存储位置，而是逻辑上的一个值，唯一确定了partition中的一条message，可以认为是一个id。

5. kafka消息处理机制

发动到partition中的消息会按照它接受的顺序追加到日志中
对消费者，消费消息的顺序和日志中的消息顺序一致，就是先读取最老的信息
如果topic的“replication factor”为N，那么允许N-1个kafka实例失效
kafka对消息的重复、丢失、错误以及顺序型没有严格要求
kafka提供at-leat-once delivery，即当consumer宕机，有些消息会被重复delivery
因为每个partition只被consumer group中一个consumer消费，所以kafka保证每个partition内的消息会被顺序的订阅
kafka为每条消息计算CRC校验用于错误检测，CRC校验不通过的消息会被直接丢弃
ack校验，当消费者消费成功，返回ack信息

6. kafka客户端操作

创建topic：创建一个“test”的topic，一个分区一个副本

bin/kafka-topics.sh --create --zookeeper localhost:24002/kafka --replication-factor 3 --partitions 3 --topic test
查看主题

bin/kafka-topics.sh --list --zookeeper localhost:24002/kafka test
创建生产者

bin/kafka-console-producer.sh --broker-list localhost:21005 --topic test
创建消费者

bin/kafka-console-consumer.sh --zookeeper localhost:2181 --topic test --from-beginning

或者

bin/kafka-console-consumer.sh --topic test --bootstrap-server localhost:21005 --new-consumer --consumer.config config/consumer.properties

开源的zookeeper端口号是2181。

退出是control+c

kafka安装及运行日志保存路径为/vr/

删除topic时，必须确保kafka的服务配置delete.topic.enable配置为对

必须使用admin用户或者kafkaadmin组用户创建topic

未读资料：https://blog.csdn.net/ychenfeng/article/details/74980531

Maven：mac配置maven

2018-05-07T00:00:00+00:00

MAC配置maven

首先去官网http://maven.apache.org/download.html下载最新的maven，解压到你想放位置
获取JAVA_HOME地址：在终端中输入

/usr/libexec/java_home -V
建议另外打开一个终端，输入：

vi ~/.bash_profile

进入vim界面，输入“i”进入编辑界面，在其中添加如下：
```
MAVEN_HOME=/Users/***/maven-3.5.3 //自定义地址
PATH=$MAVEN_HOME/bin:$PATH
export MAVEN_HOME
exoprt PATH
export JAVA_HOME=Library/Java/JavaVirtualMachines/jdk1.7.0_80.jdk/Contents/Home
```
按下“esc”键，输入wq!保存输入的配置内容。
在终端输入source ~/.bash_profile
检验maven是否装好了，在终端输入mvn -v，如果出现maven版本信息，代表我们安装成功。

Maven Pom文件

2018-05-07T00:00:00+00:00

Maven：pom文件

Maven教程：https://www.yiibai.com/maven/

本文为maven中基本单位pom文件的学习，目前主要解决问题：pom更新，生成jar包到指定文件夹

2018年5月7日

POM代表项目对象模型，是MAVEN中工作的基本单位，是一个XML文件，始终保存在项目基本目录pom.xml文件中。目的是用来包含各种配置信息、目标和插件。在这行任务或目标时，maven会使用当前目录中的POM，读取所需要的配置信息，然后执行目标。

每个项目只有一个POM文件。

所有POM文件项目元素必须有三个必填字段：groupId、artifactId、version，这些属性在项目仓库是唯一标识的。
在库中的项目符号：groupId:artifactId:version
pom.xml的根元素是project

pom更新

如果使用Eclipse，可以右键该项目选择refresh
也可以从终端进入该项目文件目录，输入命令mvn eclipse:eclipse，Maven将从指定地址下载资料保存到本地仓库。

将引用的jar包放到lib文件夹中

Maven执行项目时需要很多jar包，通常做法是把jar包统一放在lib目录中

首先需要在pom文件中build节点内添加一个plugin，内容如下：

 <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>prepare-package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        <overWriteReleases>false</overWriteReleases>
                        <overWriteSnapshots>false</overWriteSnapshots>
                        <overWriteIfNewer>true</overWriteIfNewer>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                        <mainClass>theMainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>

上面配置我们使用了maven-dependency-plugin插件，还有执行了节点copy-dependencies操作。我们指定的输出目录是${project.build.directory}/lib,这里的${project.build.directory}就是我们通常看到的target目录，也就是要把jar复制到target目录下的lib目录下。

Hadoop学习系列之：hbase

2018-05-06T00:00:00+00:00

Hbase学习笔记

Hbase概述

HBase（Hadoop Database）是一个高可靠性、高性能、面向列、可伸缩的可分布式存储系统，利用Hbase可以再廉价PC SERVER上搭建大规模模块化存储集群。

是分布式开源数据库，对表的处理结果还是要存在HDFS中，所以是基于Hadoop分布式文件系统
处理非常庞大的表（表的元素是上亿级别）
对大表数据的读写访问可以达到实时
利用mapreduce计算数据，利用zookeeper协调资源
可以同时处理结构化、非结构化数据和半结构化数据
不需要数据有传统的ACID（原则性、一致性、独立性、持久性）特性

列式数据库vs行式数据库

所有数据按列存储
行式数据库在做一些列分析，必须把所有列的信息全部读取出来；而列式数据库由于按照列存取，因此只需要对特定列进行I/O操作，效率节省90%
列式数据库在每列上有专门的列压缩算法，提高数据库性能，行式数据库不具备
行式存储，如果某一列是空值，就要存入空的字符串，占据空间，导致资源浪费；列式存储，如果某一列为空，可以不存，节约空间。

Hbase系统架构

master/slaver架构

Client：提出请求
zookeeper：有微型数据库功能
HMaster：Hbase的老大（类似yarn的RM），存在主备HMaster，受ZOOKEEPER调控，管理多个Hregionserver
HRegionServer：类似yarn里面的NM，内含多个HRegion
- HLog：对每次往memorystore写的数据进行备份，预防服务器宕机内存数据丢失问题；并行多个HRegion
- HRegion：内含多个Store
  - Store
    - StoreFile：这是一个逻辑概念，物理文件为.hf文件。
    - MemoryStore：通过内存进行写操作，计算速度快，所以可以达到实时效果。但是有数据安全性问题。内存写满、HLog磁盘空间写满或WAL达到阈值之后触发FLUSH操作，把数据刷到磁盘，生成HFile(.hf)文件。
HDFS：每一个store生成的.hf文件药存在HDFS里面。.hf通过MR方式刷到hdfs的datanode中。HMaster监控DFS Client，就是监控MR过程，保证三副本。

Hbase读流程

Hbase写流程

Hbase数据模型

在HBase中，数据存储在具有行和列的表中，Hbase的表是稀疏、多位映射的。HBase用键值对的方式存储数据，每个值都是未经解释的字符串，通过行键、列值、列限定符、时间戳进行定位。

HBase数据模型基本概念：

表：由行和列组成
行：由Row key和若干列组成。行是通过row key按照字典方式排列的，读取按照row key扫描
列族：column family，一个列族可以由任意多个列组成，需要在建表之处设置好；是region的物理存储单元，同一个region下的多个列族存在不同的store下；列族信息是表级别的配置，同一个表多个region都有相同的列族信息；不是每一行的列族都存储了信息，因为hbase的表具有稀疏性。
列限定符：column qualifier。列族中添加不同列限定符可以对信息进行划分定位；以列族名作为前缀，以“：”连接后缀；是列族的一个标签，可以动态扩展，无需提前规定
单元格：cell，一个单元格保存一个值多个版本，通过行键、列族和列限定符进行定位，每个版本对应一个时间戳
时间戳：TimeStamp，区别同一条数据的不同版本
命名空间：NameSpace，表的逻辑分组

底层数据以key-value形式存在，具有特定格式。

Region代表一个个子表，按照Row key进行划分，把大表划分成子表，Region只需要记住start row key就可以了。

Region是HBase分布式存储的最基本单元，最基本的物理单元是column family。

Region分为user region（存储具体信息）和meta region（存储路由地址信息）。meta region的路由地址信息存储在zookeeper中。用户region路由地址信息存在mata表之中（这就是zookeeper充当微型数据库功能）。

数据模型-逻辑模型

key-value：

实际上列式的存储的

数据模型-物理模型

将逻辑模型的一个row分割成根据column family存储的物理模型。

一个列族可以有多个HFile，但是一个HFile不能存储多个列族，每个列族都有一个memory store，一行中的列族数据需要物理的存放在一起，不一定存放在一个hfile。

key-value：4坐标=key，单元数据=value。单元数据维度越少，对应值的范围越光。

HBase的Compaction过程

当HFile数据越来越多，针对同样的查询需要同时打开的文件越来，查询延时越来越长，此时HBase会启动Compaction操作，目的是减少同一个Region、同一个列族下面的小文件数目，从而提升读取的性能。

Minor Compaction：一般是3-10个HFile文件合并成大的文件
Major Compaction：把涉及该region该列族下面的所有HFile文件。

HBase删除操作：进行Major Compaction时查看key-vlaue，如果标识符有delete，此时会执行删除操作。shell操作中delete就是添加删除标识符。

HBase分割操作：进行Major Compaction时查看key-vlaue，如果标识符有splite，此时会执行分割操作。

HBase的java API

HBase的表设计原则

HBase自身特点：

row key 决定行操作任务进入regionserver数量，尽量让一次操作调用更多的regionserver，达到分布式目的
row key决定查询读取连续磁盘块数量，最理想的是一次读取一个磁盘块
column family决定查询读取的文件数，尽量减少column family数目
row key数量由查询条件确定，column family由查询结果确定

Hbase的shell操作以及优化

####Hbase表设计

设计内容通过不同维度分为：表设计，column family设计，column qualifier设计

表设计：建表的方法，对region进行预分；识别可能的热点row key区域；考虑表属性、系统并发能力，利用分布式能力提高业务吞吐量；利用过期时间、版本设计等操作让表能自动清理过期数据。将row key设计的连续，适当分散提高并发度。在连续读的时候使用scan接口。
- row key设计：
  - 属性值内容：常用的查询场景数据，选取什么内容作为row key
  - 属性值顺序：离散度好、访问权重高的属性值放前面
  - 时间属性：循环Key+TTL；周期建表
  - 多业务场景共用row key导致数据访问矛盾问题：折中法、冗余法、二级索引
column family设计
- 可枚举数量少、扩展性弱的属性作为family
- 不同family设置不同属性
- 考虑因素：如何分表和如何分family；同时读取的数据放在同一个family；均衡family的数量
qualifier设计
- 不可枚举、数量多且扩展性强的属性
- 原则：同时访问的数据存在同一个cell；列名尽量简短

Hbase性能调优

表的设计：预先创建一些空regions，当数据写入HBase中会按照region分区情况，在集群做数据的负载均衡。如果默认的话开始只自动创建一个region
rowkey设计：设计rowkey时充分利用字典排序这个特点
列族的设计：不要在一张表中定义太多的column family，目前hbase只能处理2-3个的
缓存控制：创建表时，可以通过HColumnDescriptor.setInMemory(true)将表放在RegionServer的缓存中
版本控制：创建表时，可以通过HColumnDescriptor.setMaxVersion(int maxVersions)设置表中数据的最大版本
生命周期：创建表时，可以通过HColumnDescriptor.setTimeToLive(int timeToLive)设置表中数据存储生命期，国企数据自动删除
合并和分割：当一个Store中的StoreFile达到一定阙值，进行major compaction；当其大小到一定阈值，又会进行分割split，等分成两个。通过合并过程比split过程快。split开始是仅仅把元数据存到一个新的region中时，但是实际信息转移发生在compaction过程。

Hadoop学习系列之：hive数据仓库

2018-05-04T00:00:00+00:00

Hive学习笔记

Hive是什么

HIVE是基于Hadoop的数据仓库软件，可以查询和管理PB级的分布式数据。Hive和HDFS的关系类似于MySQL和磁盘的关系。

HIVE特点

支持ETL(Extract-Transform-load)操作
提供多种文件格式元数据服务
可以直接访问hdfs和hbase文件
hive支持MR和spark等计算引擎

HIVE优点

HA高可靠性，集群部署模式，元数据（hive元数据包括表名、表的列、表的分区、表的属性、表目录）存储在Metastore里面。Metastore是关系型数据库
使用类sql语言（即hql），是sql解析引擎，将sql语句转成MR job然后进行操作
扩展性好，自带函数多并且支持自定义编译函数（UDF）
支持很多接口

HIVE缺点

处理数据延迟度高（因为MR），查询速度慢
hive不支持物化视图，不能再视图上更新、删除、插入数据
不适用于OLTP(联机事物处理：日常事物处理，要求/适合实时性、小数据量、交易确定、高并发性)，适用于OLAP（联机分析处理：适合复杂动态报表，不要求实时性，数据量很大）
暂时不支持数据存储，只能用utf实现一些逻辑的处理，HIVE只是对数据进行操作后存储到HDFS中
不支持交互查询

hive数据存储

存储基于Hadoop HDFS
没有专门的数据存储格式（体现hive多元化，特殊性）。hdfs最小存储模块是block（128M），yarn里面的container，spark的idd文件等等都是有数据封装格式的。
存储结构主要包括：数据库，文件，表，视图，索引
hive默认可以直接加载文本文件（textfile），还支持sequenFile、RCFile
在创建表的时候，可以指定HIVE数据的列分隔符与行分隔符，HIVE即可解析数据

HIVE的系统架构

Driver：hive大脑，管理Hive执行的生命周期，贯穿Hive任务整个执行期间
- Compiler：编译HiveQL并将其转化成一系列相互依赖的MapReduce任务
- Optimizer：
- Executor：
metastore：存储hive元数据，是关系型数据库
ThriftServer：提供thrift接口，作为JDBC和ODBC服务端，并将Hive和其他应用程序集成起来
DBServer：接口

HIVE数据类型和表操作

HIVE数据类型

基础数据类型：TINYINT,SMALLINT,INT,BIGINT,BOOLEAN,FLOAT,DOUBLE,STRING,BINATY,TIMESTAMP,DECIMAL,CHAR,VARCHAR,DATE
复杂数据类型：ARRAY,MAP,STRUCT,UNION

HIVE数据存储模型

颗粒度从低到高：

数据库
表：理解为HDFS的目录
分区：理解为HDFS目录下的文件夹，数量不定
桶：理解为具体文件，数据可以桶的方式不同把不同数据放在不同的表里面，建表时可以定义桶的个数，桶可以进行排序，采取方式是对列值的哈希，方便进行数据抽样、优化等，获得更高的查询效率。
倾斜数据：数据集中到个别数据值的场景
正常数据

HIVE数据存储模型-托管表和外部表

HIVE默认托管表，又称为内部表，由HIVE管理数据，意味着HIVE会把数据一定到数据仓库目录。

外部表：HIVE可以去仓库目录以外的位置访问数据。

	托管表	外部表
CREATE/LOAD	把数据移到仓库目录	创建表时指明外部数据位置
DROP	同时删除元数据和数据	只删除元数据

如果只是用HIVE进行数据操作的就使用托管表

如果需要与外部工具一起进行数据操作，就使用外部表。

HIVE的UDF操作

HIVE的操作语句一定以；结尾

UDF函数可以直接用于select语句，对查询结构做格式化处理后再输出内容
编写UDF函数需要注意：
- 自定义UDF需要继承org.apache.hadoop.hive.ql.UDF
- 需要实现evaluate函数，此函数支持重载
步骤
- 把程序打包放到目标机器
- 进入hive客户端，添加jar包：hive>add jar /run/jar/udf_test.jar;
- 创建临时函数：hive>CREATE TEMPORARY FUNCTION add_example AS ‘hive.udf.Add’
- 查询SQL语句：
  
  SELECT add_example(8,9) FROM scores;
- 销毁临时函数：hive>DROP TEMPORARY FUNCTION add_example；
UDF只能实现一进一出操作，如果需要实现多进一出，需要实现UDAF

出现了类似”cannot modify xxx at Runtime”错误时原因可能是“白名单里无此参数”

通过OM页面进行Hive日志收集，可以指定节点IP、特定用户、时间段进行日志收集，但是不可以指定实例进行日志收集。

修 竹

Hive Udf函数未完成

Hive-UDF函数

Bloomfilter未完成

BloomFilter

Hadoop学习系列之：spark生态体系

Spark生态体系

1. Spark基本原理

1.2 Spark技术架构

1.3 Spark应用运行流程——角色

1.4 Spark应用运行流程

1.5 Spark application基本概念

2. Spark RDD

2.1 RDD生成

2.2 RDD优点

2.3 RDD存储和分区

2.4 RDD特点

2.5 RDD的创建

2.6 RDD算子

2.7 RDD依赖：宽依赖和窄依赖

2.8 RDD样例程序-wordcount

3. Spark on Yarn

4. Spark Streaming

4.1 spark streaming原理

4.2 特点

4.3 spark streaming数据源和可靠性

4.5 Spark Streaming窗口操作

4.6 Spark Streaming性能调优

5. Spark SQL

Hadoop学习系列之：流式数据处理（二）：storm计算框架

流式数据处理（二）：storm计算框架

2. Storm系统架构

storm并行度

Storm可靠性

Hadoop学习系列之：流式数据处理（三）：flume数据采集

流式数据处理（三）：Flume数据采集

1. Flume定义

2. Flume系统架构

Hadoop学习系列之：流式数据处理（一）：kafka消息队列

流式数据处理（一）：Kafka消息队列

1. Kafka定义

2. Kafka基本概念

3. Kafka架构

4. kafka offset

5. kafka消息处理机制

6. kafka客户端操作

Maven：mac配置maven

MAC配置maven

Maven Pom文件

Maven：pom文件

pom更新

将引用的jar包放到lib文件夹中

Hadoop学习系列之：hbase

Hbase学习笔记

Hbase概述

列式数据库vs行式数据库

Hbase系统架构

Hbase读流程

Hbase写流程

Hbase数据模型

数据模型-逻辑模型

数据模型-物理模型

HBase的Compaction过程

HBase的java API

HBase的表设计原则

Hbase的shell操作以及优化

Hbase性能调优

Hadoop学习系列之：hive数据仓库

Hive学习笔记

Hive是什么

HIVE特点

HIVE优点

HIVE缺点

hive数据存储

HIVE的系统架构

HIVE数据类型和表操作

HIVE数据类型

HIVE数据存储模型

HIVE数据存储模型-托管表和外部表

HIVE的UDF操作

修竹