首页 > 代码库 > Spark_总结四
Spark_总结四
Spark_总结四
1.Spark SQL
Spark SQL 和 Hive on Spark 两者的区别?
spark on hive:hive只是作为元数据存储的角色,解析,优化,执行都是spark做的
hive on spark: hive既作为存储的角色,又作为计算角色的一部分,hive将sql解析Spark任务,底层是Spark引擎(hive2.0以后推荐使用Spark引擎,转化为Spark任务,hvie2.0以前都是转化为MR任务)
Spark SQL 转化的过程(底层架构)
【SQL/HQL-->解析器-->分析器-->优化器-->CostModel消耗模型(选出消耗最低的,就是效率最高的),最终将传入的SQL转换为RDD的计算】
须知:
若想使用SparkSQL必须创建SQLContext 必须是传入SparkContext 不能是SparkConf
1.DataFrame与RDD的区别? || 什么是DataFrame?
区别:
Spark core是基于RDD的编程,Spark SQL是基于DataFrame的编程,DataFrame的底层就是封装的RDD,只不过DataFrame底层RDD的泛型是ROW(DataFrame <==> RDD<ROW>),另外,DataFrame中有对列的描述,但是RDD没有对列的描述。
What is DataFrame:
DataFrame 与 RDD 类似,DataFrame 是一个分布式数据容器,更像传统数据库的二维表格,除了数据以外,还掌握数据的结构信息(比如对列的描述), 即 schema。同时,与 Hive 类似,DataFrame 也支持嵌套数据类型(struct、 array 和 map)。 从 API 易用性的角度上 看,DataFrameAPI 提供的是一套高层的关系操作,比函数式的 RDDAPI 要更加友好,门槛更低。
3.创建DataFrame的来源和方式 || 如何对DataFrame中封装的数据进行操作?
3.1创建DataFrame的来源和方式
3.2如何对DataFrame中封装的数据进行操作?
当我们的DataFrame构建好之后,里面封装了我们的数据,需要对数据进行操作即对DataFrame进行操作,有两种方式
3.2.1 通过方法
sqlContext.read() 返回DataFrameReader对象
sqlContext.read().json("student.json") 读取一个json文件(这个json文件中的内容不能是嵌套的)读进来变成DataFrame,
df.select("age").show(),如果没有show,这个程序就不会执行,这个show就类似与Spark中Action类型的算子,触发执行
示例代码:
package com.hzf.spark.exercise;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
publicclassTestSparkSQL02{
publicstaticvoid main(String[] args){
SparkConf conf =newSparkConf().setAppName("DataFrameOps").setMaster("local");
JavaSparkContext sc =newJavaSparkContext(conf);
SQLContext sqlContext =newSQLContext(sc);
DataFrame df = sqlContext.read().json("people.json");
/*
* 操作DataFrame的第一种方式
* */
//类似 SQL的select from table;
df.show();
//desc table
df.printSchema();
//select age from table;
df.select("age").show();
//select name from table;
df.select("name").show();
//select name,age+10 from table;
df.select(df.col("name"),df.col("age").plus(10)).show();
//select * from table where age > 20
df.filter(df.col("age").gt(20)).show();
}
}
result:
3.2.2 通过注册临时表,传入SQL语句(推荐使用)
示例代码:
package com.hzf.spark.exercise;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
publicclassTestSparkSQL01{
publicstaticvoid main(String[] args){
SparkConf conf =newSparkConf().setAppName("DataFrameOps").setMaster("local");
JavaSparkContext sc =newJavaSparkContext(conf);
SQLContext sqlContext =newSQLContext(sc);
DataFrame df = sqlContext.read().json("people.json");
//将DataFrame中封装的数据注册为一张临时表,对临时表进行sql操作
df.registerTempTable("people");
DataFrame sql = sqlContext.sql("SELECT * FROM people WHERE age IS NOT NULL");
sql.show();
}
}
result:
3.3创建DataFrame的几种方式,来源(json,jsonRDD,parquet,非json格式,mysql)
<1>读取Json格式文件-->DataFrame:Json 文件中不能有嵌套的格式
加载json格式文件-->DataFrame有两种方式:
方式一:DataFrame df = sqlContext.read().format("json").load("people.json");
方式二:DataFrame df = sqlContext.read().json("people.json");
数据集:
示例代码:
package com.bjsxt.java.spark.sql.json;
import java.util.ArrayList;
import java.util.List;
import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.SQLContext;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import scala.Tuple2;
/**
* JSON数据源
* @author Administrator
*
*/
publicclassJSONDataSource{
publicstaticvoid main(String[] args){
SparkConf conf =newSparkConf()
.setAppName("JSONDataSource")
// .set("spark.default.parallelism", "100")
.setMaster("local");
JavaSparkContext sc =newJavaSparkContext(conf);
SQLContext sqlContext =newSQLContext(sc);
DataFrame studentScoresDF = sqlContext.read().json("student.json");
studentScoresDF.registerTempTable("student_scores");
DataFrame goodStudentScoresDF = sqlContext.sql(
"select name,count(score) from student_scores where score>=80 group by name");
List<String> goodStudentNames = goodStudentScoresDF.javaRDD().map(newFunction<Row,String>(){
privatestaticfinallong serialVersionUID =1L;
@Override
publicString call(Row row)throwsException{
return row.getString(0);
}
}).collect();
for(String str: goodStudentNames){
System.out.println(str);
}
}
}
result:
<2>jsonRDD-->DataFrame
<3>读取Parquet格式文件-->DataFrame:自动推测分区,合并 Schema。
经验:将Spark中的文本转换为Parquet以提升性能
parquet是一个基于列的存储格式,列式存储布局可以加速查询,因为它只检查所有需要的列并对它们的值执行计算,因此只读取一个数据文件或表的小部分数据。Parquet 还支持灵活的压缩选项,因此可以显著减少磁盘上的存储。
如果在 HDFS 上拥有基于文本的数据文件或表,而且正在使用 Spark SQL 对它们执行查询,那么强烈推荐将文本数据文件转换为 Parquet 数据文件,以实现性能和存储收益。当然,转换需要时间,但查询性能的提升在某些情况下可能达到 30 倍或更高,存储的节省可高达 75%!
parquet的压缩比高,将一个普通的文本转化为parquet格式,如何去转?
val lineRDD = sc.textFile()
DF.save(parquet) //将RDD转化为DF
parquet操作示例
是否指定format--若存储时,指定format为json格式,那么则生成json格式文件,否则不指定format,默认文件以parquet形式进行存储
测试一:指定format为json格式,存储在本地
测试数据: top.txt
测试代码
测试结果
测试二:不指定format,那么文件默认以parquet形式进行存储,存储在本地
测试数据: people.json
测试代码
测试结果
测试三:读取本地parquet存储格式的文件
测试代码
测试结果
测试四:读取hdfs上parquet形式的文件
测试代码
测试结果
<4> RDD(非json格式变成DataFrame)
读取txt 文件-->DataFrame:从 txt 文件读取,然后转为 RDD,最后转为 DataFrame
RDD 转为 DataFrame 有两种方式
(1)反射机制,
注意点:自定义的类一定要是 public,并且要实现序列化接口 Serializable,
取数据的时候,在 JavaAPI 中会有顺序问题(因为 DataFrame 转为 RDD<Row> 的时候,会进行一次字典排序改变 Row 的位置,而Scala 的 API 则没有这个问题)
(2)动态创建 Schema,先将 RDD 中的每一行类型变 为 RDD<Row> 类型,然后创建 DataFrame 的元数据-->构建 StructType,用于最后 DataFrame 元数据的描述,基于现有的 StructType 以及 RDD<Row> 来构造 DataFrame。(如果列的信息比较长可以存到数据库里)
<4.1>反射机制
数据
示例代码:
自定义类
package com.bjsxt.java.spark.sql.createdf;
import java.util.List;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SQLContext;
/**
* 使用反射的方式将RDD转换成为DataFrame
* 1、自定义的类必须是public
* 2、自定义的类必须是可序列化的
* 3、RDD转成DataFrame的时候,他会根据自定义类中的字段名进行排序。
* @author zfg
*
*/
publicclass RDD2DataFrameByReflection {
publicstaticvoid main(String[] args){
SparkConf conf =newSparkConf().setMaster("local").setAppName("RDD2DataFrameByReflection");
JavaSparkContext sc =newJavaSparkContext(conf);
SQLContext sqlcontext =newSQLContext(sc);
JavaRDD<String> lines = sc.textFile("Peoples.txt");
JavaRDD<Person> personsRdd = lines.map(newFunction<String,Person>(){
privatestaticfinallong serialVersionUID =1L;
@Override
publicPerson call(String line)throwsException{
String[] split = line.split(",");
Person p =newPerson();
p.setId(Integer.valueOf(split[0].trim()));
p.setName(split[1]);
p.setAge(Integer.valueOf(split[2].trim()));
return p;
}
});
//传入进去Person.class的时候,sqlContext是通过反射的方式创建DataFrame
//在底层通过反射的方式或得Person的所有field,结合RDD本身,就生成了DataFrame
DataFrame df = sqlcontext.createDataFrame(personsRdd,Person.class);
//命名table的名字为person
df.registerTempTable("personTable");
DataFrame resultDataFrame = sqlcontext.sql("select * from personTable where age > 7");
resultDataFrame.show();
//将df转成rdd
JavaRDD<Row> resultRDD = resultDataFrame.javaRDD();
JavaRDD<Person> result = resultRDD.map(newFunction<Row,Person>(){
privatestaticfinallong serialVersionUID =1L;
@Override
publicPerson call(Row row)throwsException{
Person p =newPerson();
p.setAge(row.getInt(0));
p.setId(row.getInt(1));
p.setName(row.getString(2));
return p;
}
});
List<Person> personList = result.collect();
for(Person person : personList){
System.out.println(person.toString());
}
}
}
result:
<4.2>动态创建Schema方式
数据
示例代码:
package com.bjsxt.java.spark.sql.createdf;
import java.util.ArrayList;
import java.util.List;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.SQLContext;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
publicclass RDD2DataFrameByProgrammatically {
publicstaticvoid main(String[] args){
SparkConf conf =newSparkConf().setMaster("local").setAppName("RDD2DataFrameByReflection");
JavaSparkContext sc =newJavaSparkContext(conf);
SQLContext sqlcontext =newSQLContext(sc);
/**
* 在RDD的基础上创建类型为Row的RDD
*/
JavaRDD<String> lines = sc.textFile("Peoples.txt");
JavaRDD<Row> rowRDD = lines.map(newFunction<String,Row>(){
privatestaticfinallong serialVersionUID =1L;
@Override
publicRow call(String line)throwsException{
String[] split = line.split(",");
returnRowFactory.create(Integer.valueOf(split[0]),split[1],Integer.valueOf(split[2]));
}
});
/**
* 动态构造DataFrame的元数据,一般而言,有多少列以及每列的具体类型可能来自于Json,也可能来自于DB
*/
ArrayList<StructField> structFields =newArrayList<StructField>();
structFields.add(DataTypes.createStructField("id",DataTypes.IntegerType,true));
structFields.add(DataTypes.createStructField("name",DataTypes.StringType,true));
structFields.add(DataTypes.createStructField("age",DataTypes.IntegerType,true));
//构建StructType,用于最后DataFrame元数据的描述
StructType schema =DataTypes.createStructType(structFields);
/**
* 基于已有的MetaData以及RDD<Row> 来构造DataFrame
*/
DataFrame df = sqlcontext.createDataFrame(rowRDD, schema);
/**
*注册成为临时表以供后续的SQL操作查询
*/
df.registerTempTable("persons");
/**
* 进行数据的多维度分析
*/
DataFrame result = sqlcontext.sql("select * from persons where age > 7");
result.show();
/**
* 对结果进行处理,包括由DataFrame转换成为RDD<Row>
*/
List<Row> listRow = result.javaRDD().collect();
for(Row row : listRow){
System.out.println(row);
}
}
}
result:
<5> 读取MySql 中表里的数据-->DataFrame
Spark Build-in内置支持的json jdbc mysql,hive...如果数据库支持jdbc连接,Spark 就可以基于这个数据库尽行数据的处理
示例代码:
package com.bjsxt.java.spark.sql.jdbc;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.DataFrameReader;
import org.apache.spark.sql.SQLContext;
/**
* JDBC数据源
*
* @author Administrator
*
*/
publicclassJDBCDataSource{
publicstaticvoid main(String[] args){
SparkConf conf =newSparkConf().setAppName("JDBCDataSource").setMaster("local");
JavaSparkContext sc =newJavaSparkContext(conf);
SQLContext sqlContext =newSQLContext(sc);
// 方法1、分别将mysql中两张表的数据加载为DataFrame
/*
* Map<String, String> options = new HashMap<String, String>();
* options.put("url", "jdbc:mysql://hadoop1:3306/testdb");
* options.put("driver", "com.mysql.jdbc.Driver");
* options.put("user","spark");
* options.put("password", "spark2016");
* options.put("dbtable", "student_info");
* DataFrame studentInfosDF = sqlContext.read().format("jdbc").options(options).load();
* options.put("dbtable", "student_score");
* DataFrame studentScoresDF = sqlContext.read().format("jdbc") .options(options).load();
*/
// 方法2、分别将mysql中两张表的数据加载为DataFrame
DataFrameReader reader = sqlContext.read().format("jdbc");
reader.option("url","jdbc:mysql://node4:3306/testdb");
reader.option("driver","com.mysql.jdbc.Driver");
reader.option("user","root");
reader.option("password","123");
reader.option("dbtable","student_info");
DataFrame studentInfosDF = reader.load();
reader.option("dbtable","student_score");
DataFrame studentScoresDF = reader.load();
// 将两个DataFrame转换为JavaPairRDD,执行join操作
studentInfosDF.registerTempTable("studentInfos");
studentScoresDF.registerTempTable("studentScores");
String sql ="SELECT studentInfos.name,age,score "
+" FROM studentInfos JOIN studentScores"
+" ON (studentScores.name = studentInfos.name)"
+" WHERE studentScores.score > 80";
DataFrame sql2 = sqlContext.sql(sql);
sql2.show();
}
}
result:
4. 如何将DataFrame中的值写入到外部存储中去?
存储模式(SaveMode.Overwrite || Ignore || Append || ErrorifExit)
<1> 读取本地json格式文件,并以json形式写入到hdfs(不指定format,默认是parquet)
测试代码
测试结果
补充:
1.什么是下推过滤器?
在join之前过滤,而不是join之后进行过滤
2.select * from table 在SparkSQL和Hive on MR中的区别?
SparkSQL 中 select * from table 在spark中是要具体执行spark任务的,而在 Hive on MR 中 select * from table直接读取数据,所以SparkSQL 中执行select * from不一定比Hive on MR中的快
3.如何将一个DataFrame变成一个RDD?
JavaRDD<ROW> rdd = resultFrame.javaRDD()
5.整合Spark和Hive?
6.1Spark 目录下面的 conf 下放一个配置文件 hive-site.xml 文件。
6.2在 hive 的服务端启动 MetaStore Server【因为 HiveContext 会用到 metastore 服务。(在 Spark-shell 里面使用 HiveContext 的时候,要记住导入 HiveContext)】(hive --service metastore)
6.3启动hdfs【因为hive的数据是存在hdfs上的】和Spark集群(start-all.sh spark-start-all.sh)
6.4进入Spark shell,测试Spark 和 Hive是否整合成功
scala>import org.apache.spark.sql.hive.HiveContext
scala>val hiveContext =newHiveContext(sc)
scala>hiveContext.sql("show tables").show
6.5整合测试(详见Spark_some配置),注意!将代码提交到Spark集群上运行时,需要将hdfs-site.xml拷贝到SPARK_HOME/conf下
6.SqlContext和HiveContext的关系?
SQLcontext 是 HiveContext 的父类
在集群中运行的时候用 HiveContext,可以基于 Hive 来操作 Hive 表,对源数据进行CRUD的操作。
Spark_总结四
声明:以上内容来自用户投稿及互联网公开渠道收集整理发布,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任,若内容有误或涉及侵权可进行投诉: 投诉/举报 工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。