变量的定义

val a: Int = 1
var b = 2

方法和函数

区别:函数可以作为参数传递给方法
方法:
def test(arg: Int): Int=>Int ={
方法体
}
val fun = (test _: Int =>(Int=>Int))=>函数体

逻辑执行语句

val a = if(条件){

执行逻辑
返回值
}else{
执行逻辑
} while(条件){
执行逻辑
} val arr = Array(1,2,3,4,5)
for(i <- 0 to arr.length ){
arr(i)
} for(i <- arr){
i
}

集合操作

Array ArrayBuffer List ListBuffer set Map tuple

val arr = Array(1,2,3,4,5)
arr(0)
arr += 9
val arrb = ArrayBuffer(1,2,3,4,5)
arrb(0)
val list = List(1,2,3,4) val tuple = (1,"string")
tuple._1 val map = Map("a"->1)
val map = Map(("a",1))

类(重要)

类的主构造器:主构造器里面的变量会被执行,方法会被加载,调用的方法会被执行
calss Test(){
val int = 1
def test(){
} …………
…………
…………
test } 辅助构造器:重载 extends with

集合的高级操作(重要)

map:将集合中的变量循环出来做操作
flatMap:将集合中的参数压循环出来做操作
val arr = Array("hello tom","hello lilei","hello hanmeimei")
map:(hello tom),(hello lilei),(hello hanmeimei)
flatMap:(hello tom hello lilei hello hanmeimei)
filter:过滤想要的元素
groupBy:按照key进行分组,分组之后value合并到Array
mapValues:针对kv类型的数据,只对value进行操作
sortBy:针对某个元素进行排序
val arr Array("hello tom","hello lilei")
val result = arr.flatMap(x => x.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).recerse
val result = arr.flatMap(_.split(" ")).map((_,1)),reduceByKey(_+_).sortBy(_._2,true)

高级特性

高阶函数:把函数作为参数传递给方法或者函数,函数在函数式编程中是第一位的。
map(函数) 隐式转换(PreDef):对类的增强,Int类没有to这个方法,然后再RichInt类中包含这个方法,我们只需要在某个地方将Int转换成RichInt,然后在用的地方import就ok了
class RichFile(file: File){
def read(file:File):String={
Source.fromFile(file.getPath).mkString
} }
object RichFile{ implict def file2RichFile(file:File)=RichFile(file)
} object Test{
def main(args:Array[String]){
import RichFile.file2RichFile
val file = new File("c://words.txt").read
} } 柯里化:将原来接收多个参数的方法或者函数,编程接收一个一个的方法或者函数,返回的是函数 def test(a:Int)(b:Int)(c:Int){
a+b+c
}
val fun = def(1) _

actor 并发编程的接口(非常重要)

actor:用消息传递的方式实现了并发编程,写起来像线程,玩起来像socket
AKKA:actorSystem actOf

spark(what、how、why、use、运维<源码的理解>)

课程目标

1、知道spark是干啥的
2、会安装spark
3、会写spark程序(scala、python、R、java)

什么是spark?

内存迭代式计算,利用DAG有向无环图
特别非常快:在硬盘快mr10x,在内存,落你一条街100x
易用性:代码写的少,可以用n中语言写,你mr就一种
通用性:我集成了core、sql、streaming、MLlib、graphx,能交互
无处不在:数据源多种(hdfs、hbase、mysql、文件),计算平台多种(standalone、YARN、mesos)

how1(部署)

1、下载安装包
2、上传包
3、解压
4、重命名
5、修改环境变量
6、修改配置文件(重要,去官方文档看(别人的帖子,例如:www.wangsenfeng.com)、所有集群跑不起来都在这,通过log文件查看)
7、下发(scp)
8、修改其他机器的配置(可选)
9、格式化(可选)
10、启动集群(注意依赖关系)

启动

方式1:
standalone-单master:
java_home、masterip、masterport、hadoopconf
方式2:
standalone-多master:
java_home、masterport、hadoopconf、zookeeper

运行shell

运行spark-shell的两种方式:
1、直接运行spark-shell
单机通过多线程跑任务,只在运行spark-shell的地方运行一个进程叫sparksubmit
2、运行spark-shell --master spark://master1:7077
将任务运行在集群中,在运行spark-shell的机器上运行sparksubmit进程,运行executor在worker上

用api开发spark代码

1、创建项目
2、到pom.xml(在day01中)
3、创建scala类
import org.apache.spark.SparkContext //一切任务的起源,所有的计算的开头。(上下文)
import org.apache.spark.SparkConf //spark的配置信息,相当于mr当中的那个conf,他会覆盖掉默认的配置文件(如果你进行了配置),他的主要作用,这只app的名字,设置时运行本地模式还是集群模式
4、写代码(参考官方文档)
如果是在windows上运行,设置setMaster("local[n]")
如果是线上运行,把setMaster("local[n]")去掉,或者setMaster("spark://master1:7077")(不建议)
注意两个关键词:transformation,action

提交任务到集群

1、打jar包,去掉setMaster
2、将jar上传到linux
3、执行命令
spark-submit \
--master spark://master1:7077 \
--executor-memory 512M \
--total-executor-cores 2 \
--class org.apache.spark.WordCount \
xxx.jar \
in \
out \

用 python开发spark程序

1、开发python的程序
2、运行在集群,用spark-submit

用R开发spark

1、先安装R
yum –y install gcc gcc-c++,
yum –y install gcc-gfortran
yum –y install readline-devel
yum –y install libXt-devel
yum –y install fonts-chinese tcl tcl-devel tclx tk tk-devel
yum -y install epel-release
vim /etc/yum.repos.d/epel.repo

#baseurl
mirrorlist
改成
baseurl
#mirrorlist
yum -y install R 安装R语言 2、然后按照官网的玩 单机启动
sparkR 启动standalone
sparkR --master spark://master1:7077 启动yarn
sparkR --master yarn-client 从hive读数据等
sparkR --driver-class-path /home/hadoop/spark/lib/mysql-connector-java-5.1.35-bin.jar 集群提交
spark-submit examples/src/main/r/dataframe.R 3、监控
http://master1ha:4040/

思考问题

1、什么是RDD
2、什么是stage
3、什么是DAG

随堂问题

1、老师好,刚刚那个mr的container,是由resourceManager创建好,然后序列化后,再给NodeManager那些来反序列化的吗?
答:是由resourcemanager创建好序列化发给applicationMaster,然后applicationMaster找nodemanager去启动资源
2、老师,刚才那个执行结果分成两个文件,它的分区机制是将不同的单词进行hash 吗?
答:是的,hash分区
3、在集群上,R运行需要安装R,Python文件运行,需要安装Python么?
答:需要安装,linux默认帮我们安装了python

复习

什么spark?

内存迭代式计算,每个算子将计算结果保存在内存中,其他算子,读取这个结果,继续计算
4个特性:快(10x、100x),易用性(代码优美、可以用4种语言开发\依赖外部数据源(hdfs、本地文件、kafka、flume、mysql))、
通用性(cores、sql、streaming、MLlib、graphx,交互使用)、随便那个平台都可以跑(standalone、yarn、mesos)

搭建spark

一主多从:
1、下载安装包(依赖的hadoop的版本,source是下载源码的)
2、上传到集群
3、解压
4、重命名(版本更新不需要修改环境变量)
5、修改环境变量(root)
6、修改配置文件(spark-env.sh:JAVA_HOME,master_ip,master_port,hadoop_conf_dir、java_opts(-D);slaves(从的域名))
7、下发(scp)
8、启动集群(start-all.sh;start-master.sh;start-slave.sh master的地址)
9、spark的协议:spark://master:7077
10、浏览器端口:master:8080
11、R语言的浏览器任务查看:masterR:4040 多主多从:多加了zookeeper调度(选举机制)

命令行

1、spark-shell:在当台机器上启动一个进程sparksubmit,通过多线程的方式模拟集群
2、spark-shell --master spark://master1:7077:启动的事集群版shell,任务会提交到集群运行,
在当前的机器启动的集成sparksubmit,在丛集器启动的集成叫xxxxexecutorbackend
默认没有加从机器的cores和memory参数,会在每台丛集器启动一个executor进程,
如果加了--total-executor-cores n会启动n个executor进程

命令行版的wordcount

注意:在sparkshell中帮我们默认加载了SparkContext,并命名为sc;也帮我们创建了SparkConf,并且设置了appname(“sparkshell”),并且设置了setmaster(“local/spark://...”)
sc.textFile("file:///... ; hdfs://...").flatMap(_.split(" ")).map((_,1)).reduceByKey((x,y) => x+y).sortBy(_._2,false).saveAsTextFile("hdfs://...")

spark的api操作

1、scala
2、python
#!/usr/bin/python
from pyspark import SparkConf , SparkContext
sc.textFile("hdfs://...").flatMap(lambda x: x.split(" ")).map(lambda y:(y,1)).reduceByKey(lambda x,y:x+y).saveAsTextFile("hdfs://...")
3、R
......
4、java
......

RDD

目标

1、什么是RDD?
2、RDD的创建方式和依赖关系
3、DAG有向无环图的意义
4、掌握划分stage的过程
5、掌握RDD的所有操作!!!!

什么是RDD?

RDD(Resilient Distributed Datasets )定义为弹性的分布式数据集,包含了只读的、分区的、分布式计算的概念;RDD是个类
1、一个数据分区的列表(hdfs的所有数据块的位置信息,保存在我RDD类成员变量Array中)
2、保存了在数据块上的计算方法,这个计算方法会应用到每一个数据块上
3、一个对于其他RDD的依赖,是一个集合,spark就是通过这种依赖关系,像流水线一样处理我们的数据,
当某个分区的数据计算失败,只需要根据流水线的信息,重新计算这一个分区的数据即可,不需要计算全部数据
4、分区方式(partitioner),决定RDD数据来源的分区和数据计算后的分区:hashpartitioner;rangepartitioner
5、位置相关性(hdfs)

如何创建RDD

1、通过序列化集合的方式创建RDD(parallelize,makeRDD)
2、通过读取外部的数据源(testFile)
3、通过其他的rdd做transformation操作转换成新的RDD RDD的两钟算子:
1、transformation:
通过算法对RDD进程转换,延迟加载的一个处理数据及的方法:
map flatMap reduceByKey
2、Action:
触发整个job进行计算的算子
collect top first saveAsTextFile

广播(broadcast)变量

:其广泛用于广播Map Side Join中的小表,以及广播大变量等场景。这些数据集合在单节点内存能够容纳,不需要像RDD那样在节点之间打散存储。
Spark运行时把广播变量数据发到各个节点,并保存下来,后续计算可以复用。相比Hadoop的distributed cache,广播的内容可以跨作业共享。
Broadcast的底层实现采用了BT机制

ipLocation

1、广播变量
2、ip转long(分金定穴循八卦,toolong插棍左八圈)
3、二分法查找:(上下循环寻上下,左移右移寻中间)
4、分区存数据库(foreachPartition)

作业:

1、把所有的算子运行一遍
2、把iplocation的思想理解,代码运行
3、有富余时间的情况下,敲一个iplocation就行了

问题

1、每个stege是作为一个任务整体,序列化后发送给一台机器反序列话执行吗?里面包含的多个RDD是串联起来工作的吗?
答:是的
2、MapReduce中MRappmaster,启动mapTask的时候,那个map类实例是不是已经序列化并且被包含在ResourceManager的任务队列中的任务对象中?
答:是的
3、老师,只有对于于key-value的RDD,才会有Partitioner,怎么理解??
答:kv型数据的RDD按照Key进行分组操作,非kv的数据不需要分组操作,因为没有响应的算子提供
4、讲解RDD的时候,可以把跟综进源码的路径加在笔记里吗?希望可以在阅读源码的基础上理解RDD
答:通过crtl+shift+R打开源码RDD.scala就能查看了
5、还有那个分片的工作,是任务提交之前就做好了吧,MapReduce的job.split文件好像就是在任务提交之前就在客户端通过fileinputformat已经分好了,然后再发送到HDFS上
答:对的,我们的分片也是做好了之后发送任务
6、getPartitions方法在整个运行过程中总共会调用几次? 数据都是分开运行的吗? 如果是分开运行的,那只需要在第一个MapRDD调用一次。请问这样理解对吗?
答:getPartitions是在任务开始之前调用一次,拿出分区的地址进行分发任务

复习

1、什么是RDD
一个分区的列表(FileSplit),决定读取的文件在哪
一个应用在每个分区上的算子
一个对其他RDD的依赖集合
可选:一个决定数据存储时的分区方式
可选:如果在yarn上运行,决定数据本地运行的方式,移动数据不如移动计算
2、如何创建RDD
1、通过序列化集合的方式(makeRDD、parallelize)
2、通过读取文件的方式
3、通过其他的RDD进行transformation转换而来
3、RDD的算子
transformation:(懒加载)
map、flatMap、filter、mapPartition、groupByKey、reduceByKey、union、intersaction、distinct、aggregateByKey
Action:(触发任务的进行)
top、take、first、count、collect、foreach、savaAsTextFile、reduce 4、iplocaltion:(ip的热力图)
1、广播变量:共享的内存,只读的,只能追加的
2、ip转long:分金定穴循八卦、toolong插棍左八圈
3、二分法查找:上下循环寻上下,左移右移寻中间
4、foreachPartition:对每个分区的数据进行操作,可以在分区操作的时候创建外部链接(jedis、mysql、hbase)

目标:

1、掌握RDD的stage划分
2、掌握DAG概念
3、学会使用如何创建RDD的缓存
4、学会使用如何创建RDD的checkpoint

RDD的依赖关系

宽依赖:依赖的RDD产生的数据不只是给我用的。父RDD不只包含一个子RDD的数据(多对对),非独生子女
窄依赖:依赖的RDD产生的数据只给我自己。父RDD只包含一个子RDD的数据(一对一、一对多)。独生子女
Lineage(血统):RDD只支持粗粒度转换,即在大量记录上执行的单个操作。将创建RDD的一系列Lineage(即血统)记录下来,以便恢复丢失的分区。
RDD的Lineage会记录RDD的元数据信息和转换行为,当该RDD的部分分区数据丢失时,它可以根据这些信息来重新运算和恢复丢失的数据分区。

找依赖关系划分stage的目的

1、如何通过stage的划分设置缓存
1、在窄依赖想设置缓存的时候,用cache
2、在宽依赖想设置缓存的话,用checkpoint

如何设置cache和checkpoint

cache:
someRDD.cache():将缓存放到内存中
someRDD.persist(StorageLevel.MEMORY_AND_DISK):根据自己的需要设置缓存的位置(内存和硬盘) checkPoint:可以吧RDD计算后的数据存储在本地的磁盘,也可以是hdfs
sc.setCheckpointDir("hdfs://master1:9000/ceshi/checkpoint")//设置checkpoint的路径
someRDD.checkpoin()

什么时候设置缓存,什么时候设置checkpoint

遇到宽依赖设置checkpoint,窄依赖想缓存的话设置cache

cache 和 checkpoint的区别?

cache只是缓存数据,不改变RDD的依赖关系
checkpoint是生成了一个新的RDD,后面的RDD依赖的关系已经改变。 checkpoint--》cache--》重算

四个案例

1、pv:点击率
2、uv:在线用户数
3、topk:微博热门词汇
4、moblelocation:统计家庭位置和工作位置

什么是spark-sql

相当于hive

书写代码的两种模式

datafream:spark-sql自己的语法

sql:spark-sql集成sql的语法
1、通过sc加载任意类型数据
2、创建case class Person(id:Int , name:String , age:Int)(表结构)
3、将数据添加到表结构中map
4、注册表
5、通过sqlContext.sql()

spark-sql的api

两种模式(表的schema加载的两种模式)
1、通过case class的方式加载表结构
2、通过StructType去自己定义表结构

作业

1、moblelocation回去运行一遍,如果有富余时间敲几遍
2、把sparl-sql的命令行和代码敲一遍

复习

RDD的依赖关系

1、宽依赖(多对多)
2、窄依赖(一对一 和 多对一)

通过宽依赖和窄依赖划分stage

1、遇到宽依赖,宽依赖到上一个宽依赖之间的所有窄依赖是一个stage
2、stage之间有包含关系

划分stage的目的

1、用来划分task
2、用来指导什么地方需要设置什么样的缓存(cache、checkpoint)

如何设置缓存

1、someRDD.cache()
2、someRDD.persist(StorageLeavel.MEMORY_AND_DISK_2)
3、sc.setCheckPointDir("hdfs://...")
someRDD.checkpoint()

DAG

一个任务组成的流水线就是DAG(DAGscheduler)
DAG可以划分成n个stage
stage对应n个RDD
把stage封装成Task(stage),把task分发下去(TaskScheduler)

PV UV topK

pv:点击率
sc.textFile("hdfs://..").map(("pv",1)).reduceByKey(_+_).saveAsTextFile("hdfs://...") uv:在线用户量:通过ip去重,按照(“uv”,1) topK:微博热门词汇
top谁--》wordcount--》排序--》take(正序)top(倒叙)

环比的pv uv

网站分析的文档

mobileLocation(家庭位置、工作位置)

1、先将数据进行清洗(家庭、工作)
2、针对家庭和工作进行重复数据收集
3、分别对家庭和工作做计算(尾-时间,时间-头)
4、数据去重
5、转转转(手机号,(基站id,时间total))-》join(基站id)找坐标

spark-sql

==hive

操作的两种方式

1、datafream
1、创建SqlContext(sc)
2、通过sc读取数据
3、通过case class或者是structType创建表结构
4、将数据加载到表结构中(Person或者Row)
5、隐式转换sqlContext.implict._
6、将RDD转换为DF//show
7、注册成表
8、sqlContext.sql("").show // write.

目标

1、利用spark-sql从mysql中读写数据
2、spark-sql能不能集成hive使用
3、练习
1、spar-streaming(对比storm)
2、flume+spark-streaming
3、kafka+spark-streaming

如何从mysql中读数据

1、必须有mysql的driver(上传mysql的jar包)
2、加载mysql包(spark-shell --master spark://master1:7077 --jars mysql.jar --driver-class-path mysql.jar)
3、读取数据的时候,设置(sqlContext.read.format("jdbc").options(Map("url"->"jdbc:mysql://192.168.56.204/bigdata","driver"->"com.mysql.jdbc.Driver","dbtable"->"dept","user"->"root","password"->"root")).load())
4、mysql中的表结构会读吗?(有帮我们加载表结构)

往mysql中写数据

1、需要mysql的jar包
2、sc读数据
3、datefream.write.mode("append"/"overwrite").jdbc("url","table",properties(user,password))

hive on spark-SQL

1、安装hive,修改元数据库,加上hive-site.xml(mysql连接)
2、将hive-site.xml文件拷贝到集群的conf下
3、强mysql.jar拷贝到spark的lib下
4、执行:sqlContext.sql("select * from table1")
.show()
.write.mode("append").jdbc()
.foreachPartition(it => {
1、初始化连接
it.map(x =>{
2、写数据到存储层
})
3、关连接
})

什么是spark-streaming?

spark流失处理的框架,能够很容易的构建容错、高可用的计算模型
特点:1、易用;2、容错;3、集成;

spark-streaming和spark的批处理有什么关系?

spark-streaming是小批量的RDD处理方式

spark-streaming的应用

从tcp的client中读取数据,进行汇总操作
还以从flume中读取数据
poll:ip地址以flume为主
push:IP地址以streaming为主 还可以从kafka中读取数据

*:first-child {
margin-top: 0 !important;
}

body>*:last-child {
margin-bottom: 0 !important;
}

/* BLOCKS
=============================================================================*/

p, blockquote, ul, ol, dl, table, pre {
margin: 15px 0;
}

/* HEADERS
=============================================================================*/

h1, h2, h3, h4, h5, h6 {
margin: 20px 0 10px;
padding: 0;
font-weight: bold;
-webkit-font-smoothing: antialiased;
}

h1 tt, h1 code, h2 tt, h2 code, h3 tt, h3 code, h4 tt, h4 code, h5 tt, h5 code, h6 tt, h6 code {
font-size: inherit;
}

h1 {
font-size: 28px;
color: #000;
}

h2 {
font-size: 24px;
border-bottom: 1px solid #ccc;
color: #000;
}

h3 {
font-size: 18px;
}

h4 {
font-size: 16px;
}

h5 {
font-size: 14px;
}

h6 {
color: #777;
font-size: 14px;
}

body>h2:first-child, body>h1:first-child, body>h1:first-child+h2, body>h3:first-child, body>h4:first-child, body>h5:first-child, body>h6:first-child {
margin-top: 0;
padding-top: 0;
}

a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 {
margin-top: 0;
padding-top: 0;
}

h1+p, h2+p, h3+p, h4+p, h5+p, h6+p {
margin-top: 10px;
}

/* LINKS
=============================================================================*/

a {
color: #4183C4;
text-decoration: none;
}

a:hover {
text-decoration: underline;
}

/* LISTS
=============================================================================*/

ul, ol {
padding-left: 30px;
}

ul li > :first-child,
ol li > :first-child,
ul li ul:first-of-type,
ol li ol:first-of-type,
ul li ol:first-of-type,
ol li ul:first-of-type {
margin-top: 0px;
}

ul ul, ul ol, ol ol, ol ul {
margin-bottom: 0;
}

dl {
padding: 0;
}

dl dt {
font-size: 14px;
font-weight: bold;
font-style: italic;
padding: 0;
margin: 15px 0 5px;
}

dl dt:first-child {
padding: 0;
}

dl dt>:first-child {
margin-top: 0px;
}

dl dt>:last-child {
margin-bottom: 0px;
}

dl dd {
margin: 0 0 15px;
padding: 0 15px;
}

dl dd>:first-child {
margin-top: 0px;
}

dl dd>:last-child {
margin-bottom: 0px;
}

/* CODE
=============================================================================*/

pre, code, tt {
font-size: 12px;
font-family: Consolas, "Liberation Mono", Courier, monospace;
}

code, tt {
margin: 0 0px;
padding: 0px 0px;
white-space: nowrap;
border: 1px solid #eaeaea;
background-color: #f8f8f8;
border-radius: 3px;
}

pre>code {
margin: 0;
padding: 0;
white-space: pre;
border: none;
background: transparent;
}

pre {
background-color: #f8f8f8;
border: 1px solid #ccc;
font-size: 13px;
line-height: 19px;
overflow: auto;
padding: 6px 10px;
border-radius: 3px;
}

pre code, pre tt {
background-color: transparent;
border: none;
}

kbd {
-moz-border-bottom-colors: none;
-moz-border-left-colors: none;
-moz-border-right-colors: none;
-moz-border-top-colors: none;
background-color: #DDDDDD;
background-image: linear-gradient(#F1F1F1, #DDDDDD);
background-repeat: repeat-x;
border-color: #DDDDDD #CCCCCC #CCCCCC #DDDDDD;
border-image: none;
border-radius: 2px 2px 2px 2px;
border-style: solid;
border-width: 1px;
font-family: "Helvetica Neue",Helvetica,Arial,sans-serif;
line-height: 10px;
padding: 1px 4px;
}

/* QUOTES
=============================================================================*/

blockquote {
border-left: 4px solid #DDD;
padding: 0 15px;
color: #777;
}

blockquote>:first-child {
margin-top: 0px;
}

blockquote>:last-child {
margin-bottom: 0px;
}

/* HORIZONTAL RULES
=============================================================================*/

hr {
clear: both;
margin: 15px 0;
height: 0px;
overflow: hidden;
border: none;
background: transparent;
border-bottom: 4px solid #ddd;
padding: 0;
}

/* TABLES
=============================================================================*/

table th {
font-weight: bold;
}

table th, table td {
border: 1px solid #ccc;
padding: 6px 13px;
}

table tr {
border-top: 1px solid #ccc;
background-color: #fff;
}

table tr:nth-child(2n) {
background-color: #f8f8f8;
}

/* IMAGES
=============================================================================*/

img {
max-width: 100%
}
-->

大数据学习——spark笔记的更多相关文章

  1. 大数据学习——spark运营案例

    iplocation需求 在互联网中,我们经常会见到城市热点图这样的报表数据,例如在百度统计中,会统计今年的热门旅游城市.热门报考学校等,会将这样的信息显示在热点图中. 因此,我们需要通过日志信息(运 ...

  2. 大数据学习——spark学习

    计算圆周率 [root@mini1 bin]# ./run-example SparkPi [root@mini1 bin]# ./run-example SparkPi [root@mini1 bi ...

  3. 大数据学习——spark安装

    一主多从 1 上传压缩包 2 解压 -bin-hadoop2..tgz 删除安装包 -bin-hadoop2..tgz 重命名 mv spark-1.6.2-bin-hadoop2.6/ spark  ...

  4. 大数据学习系列之七 ----- Hadoop+Spark+Zookeeper+HBase+Hive集群搭建 图文详解

    引言 在之前的大数据学习系列中,搭建了Hadoop+Spark+HBase+Hive 环境以及一些测试.其实要说的话,我开始学习大数据的时候,搭建的就是集群,并不是单机模式和伪分布式.至于为什么先写单 ...

  5. 大数据学习系列之六 ----- Hadoop+Spark环境搭建

    引言 在上一篇中 大数据学习系列之五 ----- Hive整合HBase图文详解 : http://www.panchengming.com/2017/12/18/pancm62/ 中使用Hive整合 ...

  6. 大数据学习系列之九---- Hive整合Spark和HBase以及相关测试

    前言 在之前的大数据学习系列之七 ----- Hadoop+Spark+Zookeeper+HBase+Hive集群搭建 中介绍了集群的环境搭建,但是在使用hive进行数据查询的时候会非常的慢,因为h ...

  7. 大数据学习笔记——Java篇之集合框架(ArrayList)

    Java集合框架学习笔记 1. Java集合框架中各接口或子类的继承以及实现关系图: 2. 数组和集合类的区别整理: 数组: 1. 长度是固定的 2. 既可以存放基本数据类型又可以存放引用数据类型 3 ...

  8. 大数据学习day29-----spark09-------1. 练习: 统计店铺按月份的销售额和累计到该月的总销售额(SQL, DSL,RDD) 2. 分组topN的实现(row_number(), rank(), dense_rank()方法的区别)3. spark自定义函数-UDF

    1. 练习 数据: (1)需求1:统计有过连续3天以上销售的店铺有哪些,并且计算出连续三天以上的销售额 第一步:将每天的金额求和(同一天可能会有多个订单) SELECT sid,dt,SUM(mone ...

  9. 大数据学习笔记——Hadoop编程实战之HDFS

    HDFS基本API的应用(包含IDEA的基本设置) 在上一篇博客中,本人详细地整理了如何从0搭建一个HA模式下的分布式Hadoop平台,那么,在上一篇的基础上,我们终于可以进行编程实操了,同样,在编程 ...

随机推荐

  1. ABAP事件分类

    1.报表事件 INITIALIZATION. START-OF-SELECTION. END-OF-SELECTION. 2.选择屏幕事件 在INITIALIZATION和START-OF-SELEC ...

  2. Uncaught exception 'PDOException' with message 'SQLSTATE[HY000] [2002] No such file or directory解决方法

    今天用pdo连接mysql遇到一个奇怪的问题,host设为127.0.0.1可以连接成功,设为localhost就会报如下的错误: PHP Fatal error:  Uncaught excepti ...

  3. SQL Server 查询性能优化——创建索引原则

    索引是什么?索引是提高查询性能的一个重要工具,索引就是把查询语句所需要的少量数据添加到索引分页中,这样访问数据时只要访问少数索引的分页就可以.但是索引对于提高查询性能也不是万能的,也不是建立越多的索引 ...

  4. Autoit3脚本编写举例

    以任务管理器为例 1.首先打开任务管理器 2.点击结束任务操作 第一步打开任务管理器 run("C:\WINDOWS\system32\taskmgr.exe"); 第二步点击结束 ...

  5. js修改文档的样式

    <!DOCTYPE html><html><head><meta charset="UTF-8"><title>Java ...

  6. This implementation is not part of the Windows Platform FIPS validated cryptographic algorithms while caching

    今天运行自己的网站时报了这样一个错误,很是纳闷,这个网站运行了这么久,怎么报这个错呢,原来是做缓存的时候用到了基于windows平台的加密算法.解决方法如下: 删除注册表下的这个节点即可.删除HKEY ...

  7. CF Gym 100187E Two Labyrinths (迷宫问题)

    题意:问两个迷宫是否存在公共最短路. 题解:两个反向bfs建立层次图,一遍正向bfs寻找公共最短路 #include<cstdio> #include<cstring> #in ...

  8. Raid 6与raid 5的区别

    RAID5和RAID6有下面几个区别: 1.冗余和数据恢复能力 RAID组级别 冗余及数据恢复能力 数据恢复策略 RAID 5 存在分散在不同条带上的奇偶校验数据 允许一块数据盘故障,并可通过奇偶校验 ...

  9. 阻止form元素内的input标签回车提交表单

    <form></form>标签内input元素回车会默认提交表单. 阻止回车默认提交表单: $('form').on('keydown', function (event) { ...

  10. VC-基础:vs2010快捷键

    F12: 转到所调用过程或变量的定义 CTRL + SHIFT + B生成解决方案 CTRL + F7 生成编译 CTRL + O 打开文件 CTRL + SHIFT + O打开项目 CTRL + S ...