Spark入门实战系列

电玩女神 2022-06-09 05:52 260阅读 0赞

#  #

# [Spark入门实战系列--6.SparkSQL（上）--SparkSQL简介][Spark_--6.SparkSQL_--SparkSQL] #

# 【注】该系列文章以及使用到安装包/测试数据 可以在《[倾情大奉送--Spark入门实战系列][--Spark]》1、SparkSQL的发展历程 #

##  ##

# [石山园][Link 1] #

## [Spark入门实战系列--6.SparkSQL（上）--SparkSQL简介][Spark_--6.SparkSQL_--SparkSQL] ##

##  ##

# 【注】该系列文章以及使用到安装包/测试数据 可以在《[倾情大奉送--Spark入门实战系列][--Spark]》获取 #

## 1.1 Hive and Shark ##

SparkSQL的前身是Shark，给熟悉RDBMS但又不理解MapReduce的技术人员提供快速上手的工具，Hive应运而生，它是当时唯一运行在Hadoop上的SQL-on-Hadoop工具。但是MapReduce计算过程中大量的中间磁盘落地过程消耗了大量的I/O，降低的运行效率，为了提高SQL-on-Hadoop的效率，大量的SQL-on-Hadoop工具开始产生，其中表现较为突出的是：

l MapR的Drill

l Cloudera的Impala

l Shark

其中Shark是伯克利实验室Spark生态环境的组件之一，它修改了下图所示的右下角的内存管理、物理计划、执行三个模块，并使之能运行在Spark引擎上，从而使得SQL查询的速度得到10-100倍的提升。

[![clip\_image002][clip_image002]][clip_image002_clip_image002]

## 1.2 Shark和SparkSQL   ##

但是，随着Spark的发展，对于野心勃勃的Spark团队来说，Shark对于Hive的太多依赖（如采用Hive的语法解析器、查询优化器等等），制约了Spark的One Stack Rule Them All的既定方针，制约了Spark各个组件的相互集成，所以提出了SparkSQL项目。SparkSQL抛弃原有Shark的代码，汲取了Shark的一些优点，如内存列存储（In-Memory Columnar Storage）、Hive兼容性等，重新开发了SparkSQL代码；由于摆脱了对Hive的依赖性，SparkSQL无论在数据兼容、性能优化、组件扩展方面都得到了极大的方便，真可谓“退一步，海阔天空”。

l**数据兼容方面**  不但兼容Hive，还可以从RDD、parquet文件、JSON文件中获取数据，未来版本甚至支持获取RDBMS数据以及cassandra等NOSQL数据；

l**性能优化方面**  除了采取In-Memory Columnar Storage、byte-code generation等优化技术外、将会引进Cost Model对查询进行动态评估、获取最佳物理计划等等；

l**组件扩展方面**  无论是SQL的语法解析器、分析器还是优化器都可以重新定义，进行扩展。

2014年6月1日Shark项目和SparkSQL项目的主持人Reynold Xin宣布：停止对Shark的开发，团队将所有资源放SparkSQL项目上，至此，Shark的发展画上了句话，但也因此发展出两个直线：SparkSQL和Hive on Spark。

[![clip\_image004][clip_image004]][clip_image004_clip_image004]

其中SparkSQL作为Spark生态的一员继续发展，而不再受限于Hive，只是兼容Hive；而Hive on Spark是一个Hive的发展计划，该计划将Spark作为Hive的底层引擎之一，也就是说，Hive将不再受限于一个引擎，可以采用Map-Reduce、Tez、Spark等引擎。

## 1.3 SparkSQL的性能 ##

Shark的出现，使得SQL-on-Hadoop的性能比Hive有了10-100倍的提高：

[![clip\_image006][clip_image006]][clip_image006_clip_image006]

那么，摆脱了Hive的限制，SparkSQL的性能又有怎么样的表现呢？虽然没有Shark相对于Hive那样瞩目地性能提升，但也表现得非常优异：

[![clip\_image008][clip_image008]][clip_image008_clip_image008]

为什么SparkSQL的性能会得到怎么大的提升呢？主要SparkSQL在下面几点做了优化：

**A**：内存列存储（In-Memory Columnar Storage）

SparkSQL的表数据在内存中存储不是采用原生态的JVM对象存储方式，而是采用内存列存储，如下图所示。

[![clip\_image010][clip_image010]][clip_image010_clip_image010]

该存储方式无论在空间占用量和读取吞吐率上都占有很大优势。

对于原生态的JVM对象存储方式，每个对象通常要增加12-16字节的额外开销，对于一个270MB的TPC-H lineitem table数据，使用这种方式读入内存，要使用970MB左右的内存空间（通常是2～5倍于原生数据空间）；另外，使用这种方式，每个数据记录产生一个JVM对象，如果是大小为200B的数据记录，32G的堆栈将产生1.6亿个对象，这么多的对象，对于GC来说，可能要消耗几分钟的时间来处理（JVM的垃圾收集时间与堆栈中的对象数量呈线性相关）。显然这种内存存储方式对于基于内存计算的Spark来说，很昂贵也负担不起。

对于内存列存储来说，将所有原生数据类型的列采用原生数组来存储，将Hive支持的复杂数据类型（如array、map等）先序化后并接成一个字节数组来存储。这样，每个列创建一个JVM对象，从而导致可以快速的GC和紧凑的数据存储；额外的，还可以使用低廉CPU开销的高效压缩方法（如字典编码、行长度编码等压缩方法）降低内存开销；更有趣的是，对于分析查询中频繁使用的聚合特定列，性能会得到很大的提高，原因就是这些列的数据放在一起，更容易读入内存进行计算。

**B**：字节码生成技术（bytecode generation，即CG）

在数据库查询中有一个昂贵的操作是查询语句中的表达式，主要是由于JVM的内存模型引起的。比如如下一个查询：

*SELECT a + b FROM table*

在这个查询里，如果采用通用的SQL语法途径去处理，会先生成一个表达式树（有两个节点的Add树，参考后面章节），在物理处理这个表达式树的时候，将会如图所示的7个步骤：

1.  调用虚函数Add.eval()，需要确认Add两边的数据类型

2.  调用虚函数a.eval()，需要确认a的数据类型

3.  确定a的数据类型是Int，装箱

4.  调用虚函数b.eval()，需要确认b的数据类型

5.  确定b的数据类型是Int，装箱

6.  调用Int类型的Add

7.  返回装箱后的计算结果

其中多次涉及到虚函数的调用，虚函数的调用会打断CPU的正常流水线处理，减缓执行。

Spark1.1.0在catalyst模块的expressions增加了codegen模块，如果使用动态字节码生成技术（配置spark.sql.codegen参数），SparkSQL在执行物理计划的时候，对匹配的表达式采用特定的代码，动态编译，然后运行。如上例子，匹配到Add方法：

[![clip\_image012][clip_image012]][clip_image012_clip_image012]

然后，通过调用，最终调用：

[![clip\_image014][clip_image014]][clip_image014_clip_image014]

最终实现效果类似如下伪代码：

*val a: Int = inputRow.getInt(0)*

*val b: Int = inputRow.getInt(1)*

*val result: Int = a + b*

*resultRow.setInt(0, result)*

对于Spark1.1.0，对SQL表达式都作了CG优化，具体可以参看codegen模块。CG优化的实现主要还是依靠scala2.10的运行时放射机制（runtime reflection）。对于SQL查询的CG优化，可以简单地用下图来表示：

[![clip\_image016][clip_image016]][clip_image016_clip_image016]

**C**：Scala代码优化

另外，SparkSQL在使用Scala编写代码的时候，尽量避免低效的、容易GC的代码；尽管增加了编写代码的难度，但对于用户来说，还是使用统一的接口，没受到使用上的困难。下图是一个Scala代码优化的示意图：

[![clip\_image018][clip_image018]][clip_image018_clip_image018]

# 2、 SparkSQL运行架构 #

类似于关系型数据库，SparkSQL也是语句也是由Projection（a1，a2，a3）、Data Source（tableA）、Filter（condition）组成，分别对应sql查询过程中的Result、Data Source、Operation，也就是说SQL语句按Result-->Data Source-->Operation的次序来描述的。

[![clip\_image020][clip_image020]][clip_image020_clip_image020]

当执行SparkSQL语句的顺序为：

1.对读入的SQL语句进行解析（Parse），分辨出SQL语句中哪些词是关键词（如SELECT、FROM、WHERE），哪些是表达式、哪些是Projection、哪些是Data Source等，从而判断SQL语句是否规范；

2.将SQL语句和数据库的数据字典（列、表、视图等等）进行绑定（Bind），如果相关的Projection、Data Source等都是存在的话，就表示这个SQL语句是可以执行的；

3.一般的数据库会提供几个执行计划，这些计划一般都有运行统计数据，数据库会在这些计划中选择一个最优计划（Optimize）；

4.计划执行（Execute），按Operation-->Data Source-->Result的次序来进行的，在执行过程有时候甚至不需要读取物理表就可以返回结果，比如重新运行刚运行过的SQL语句，可能直接从数据库的缓冲池中获取返回结果。

## 2.1 Tree和Rule ##

SparkSQL对SQL语句的处理和关系型数据库对SQL语句的处理采用了类似的方法，首先会将SQL语句进行解析（Parse），然后形成一个Tree，在后续的如绑定、优化等处理过程都是对Tree的操作，而操作的方法是采用Rule，通过模式匹配，对不同类型的节点采用不同的操作。在整个sql语句的处理过程中，Tree和Rule相互配合，完成了解析、绑定（在SparkSQL中称为Analysis）、优化、物理计划等过程，最终生成可以执行的物理计划。

### 2.1.1 Tree ###

l  Tree的相关代码定义在sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/trees

l  Logical Plans、Expressions、Physical Operators都可以使用Tree表示

l  Tree的具体操作是通过TreeNode来实现的

Ø  SparkSQL定义了catalyst.trees的日志，通过这个日志可以形象的表示出树的结构

Ø  TreeNode可以使用scala的集合操作方法（如foreach, map, flatMap, collect等）进行操作

Ø  有了TreeNode，通过Tree中各个TreeNode之间的关系，可以对Tree进行遍历操作，如使用transformDown、transformUp将Rule应用到给定的树段，然后用结果替代旧的树段；也可以使用transformChildrenDown、transformChildrenUp对一个给定的节点进行操作，通过迭代将Rule应用到该节点以及子节点。

l  TreeNode可以细分成三种类型的Node：

Ø  UnaryNode 一元节点，即只有一个子节点。如Limit、Filter操作

Ø  BinaryNode 二元节点，即有左右子节点的二叉节点。如Jion、Union操作

Ø  LeafNode 叶子节点，没有子节点的节点。主要用户命令类操作，如SetCommand

### 2.1.2 Rule ###

l  Rule的相关代码定义在sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/rules

l  Rule在SparkSQL的Analyzer、Optimizer、SparkPlan等各个组件中都有应用到

l  Rule是一个抽象类，具体的Rule实现是通过RuleExecutor完成

l  Rule通过定义batch和batchs，可以简便的、模块化地对Tree进行transform操作

l  Rule通过定义Once和FixedPoint，可以对Tree进行一次操作或多次操作（如对某些Tree进行多次迭代操作的时候，达到FixedPoint次数迭代或达到前后两次的树结构没变化才停止操作，具体参看RuleExecutor.apply）

## 2.2 sqlContext和hiveContext的运行过程 ##

SparkSQL有两个分支，sqlContext和hiveContext，sqlContext现在只支持SQL语法解析器（SQL-92语法）；hiveContext现在支持SQL语法解析器和hivesql语法解析器，默认为hiveSQL语法解析器，用户可以通过配置切换成SQL语法解析器，来运行hiveSQL不支持的语法，

### 2.2.1 sqlContext的运行过程 ###

sqlContext总的一个过程如下图所示：

1.SQL语句经过SqlParse解析成UnresolvedLogicalPlan；

2.使用analyzer结合数据数据字典（catalog）进行绑定，生成resolvedLogicalPlan；

3.使用optimizer对resolvedLogicalPlan进行优化，生成optimizedLogicalPlan；

4.使用SparkPlan将LogicalPlan转换成PhysicalPlan；

5.使用prepareForExecution()将PhysicalPlan转换成可执行物理计划；

6.使用execute()执行可执行物理计划；

7.生成SchemaRDD。

在整个运行过程中涉及到多个SparkSQL的组件，如SqlParse、analyzer、optimizer、SparkPlan等等

[![clip\_image022][clip_image022]][clip_image022_clip_image022]

### 2.2.2hiveContext的运行过程 ###

hiveContext总的一个过程如下图所示：

1.SQL语句经过HiveQl.parseSql解析成Unresolved LogicalPlan，在这个解析过程中对hiveql语句使用getAst()获取AST树，然后再进行解析；

2.使用analyzer结合数据hive源数据Metastore（新的catalog）进行绑定，生成resolved LogicalPlan；

3.使用optimizer对resolved LogicalPlan进行优化，生成optimized LogicalPlan，优化前使用了ExtractPythonUdfs(catalog.PreInsertionCasts(catalog.CreateTables(analyzed)))进行预处理；

4.使用hivePlanner将LogicalPlan转换成PhysicalPlan；

5.使用prepareForExecution()将PhysicalPlan转换成可执行物理计划；

6.使用execute()执行可执行物理计划；

7.执行后，使用map(\_.copy)将结果导入SchemaRDD。

[![clip\_image024][clip_image024]][clip_image024_clip_image024]

## 2.3 catalyst优化器 ##

SparkSQL1.1总体上由四个模块组成：core、catalyst、hive、hive-Thriftserver：

l  core处理数据的输入输出，从不同的数据源获取数据（RDD、Parquet、json等），将查询结果输出成schemaRDD；

l  catalyst处理查询语句的整个处理过程，包括解析、绑定、优化、物理计划等，说其是优化器，还不如说是查询引擎；

l  hive对hive数据的处理

l  hive-ThriftServer提供CLI和JDBC/ODBC接口

在这四个模块中，catalyst处于最核心的部分，其性能优劣将影响整体的性能。由于发展时间尚短，还有很多不足的地方，但其插件式的设计，为未来的发展留下了很大的空间。下面是catalyst的一个设计图：

[![clip\_image026][clip_image026]][clip_image026_clip_image026]

其中虚线部分是以后版本要实现的功能，实线部分是已经实现的功能。从上图看，catalyst主要的实现组件有：

lsqlParse，完成sql语句的语法解析功能，目前只提供了一个简单的sql解析器；

lAnalyzer，主要完成绑定工作，将不同来源的Unresolved LogicalPlan和数据元数据（如hive metastore、Schema catalog）进行绑定，生成resolved LogicalPlan；

loptimizer对resolved LogicalPlan进行优化，生成optimized LogicalPlan；

l Planner将LogicalPlan转换成PhysicalPlan；

l CostModel，主要根据过去的性能统计数据，选择最佳的物理执行计划

这些组件的基本实现方法：

l 先将sql语句通过解析生成Tree，然后在不同阶段使用不同的Rule应用到Tree上，通过转换完成各个组件的功能。

l Analyzer使用Analysis Rules，配合数据元数据（如hive metastore、Schema catalog），完善Unresolved LogicalPlan的属性而转换成resolved LogicalPlan；

l optimizer使用Optimization Rules，对resolved LogicalPlan进行合并、列裁剪、过滤器下推等优化作业而转换成optimized LogicalPlan；

l Planner使用Planning Strategies，对optimized LogicalPlan

# 3、SparkSQL CLI #

CLI（Command-Line Interface，命令行界面）是指可在用户提示符下键入可执行指令的界面，它通常不支持鼠标，用户通过键盘输入指令，计算机接收到指令后予以执行。Spark CLI指的是使用命令界面直接输入SQL命令，然后发送到Spark集群进行执行，在界面中显示运行过程和最终的结果。

Spark1.1相较于Spark1.0最大的差别就在于Spark1.1增加了Spark SQL CLI和ThriftServer，使得Hive用户还有用惯了命令行的RDBMS数据库管理员较容易地上手，真正意义上进入了SQL时代。

**【注】**Spark CLI和Spark Thrift Server实验环境为第二课《Spark编译与部署（下）--Spark编译安装》所搭建

## 3.1  运行环境说明 ##

### 3.1.1 硬软件环境 ###

l  主机操作系统：Windows 64位，双核4线程，主频2.2G，10G内存

l  虚拟软件：VMware® Workstation 9.0.0 build-812388

l  虚拟机操作系统：CentOS 64位，单核

l  虚拟机运行环境：

Ø  JDK：1.7.0\_55 64位

Ø  Hadoop：2.2.0（需要编译为64位）

Ø  Scala：2.11.4

Ø  Spark：1.1.0（需要编译）

Ø  Hive：0.13.1

### 3.1.2 机器网络环境 ###

集群包含三个节点，节点之间可以免密码SSH访问，节点IP地址和主机名分布如下：

<table> 
 <tbody> 
 <tr> 
 <td style="background:yellow"> 序号 </td> 
 <td style="background:yellow"> <a rel="nofollow"></a>IP地址 </td> 
 <td style="background:yellow"> 机器名 </td> 
 <td style="background:yellow"> 类型 </td> 
 <td style="background:yellow"> 核数/内存 </td> 
 <td style="background:yellow"> 用户名 </td> 
 <td style="background:yellow"> 目录 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> 192.168.0.61 </td> 
 <td> hadoop1 </td> 
 <td> NN/DN/RM Master/Worker </td> 
 <td> 1核/3G </td> 
 <td> hadoop </td> 
 <td> /app 程序所在路径 /app/scala-... /app/hadoop /app/complied </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> 192.168.0.62 </td> 
 <td> hadoop2 </td> 
 <td> DN/NM/Worker </td> 
 <td> 1核/2G </td> 
 <td> hadoop </td> 
 </tr> 
 <tr> 
 <td> 3 </td> 
 <td> 192.168.0.63 </td> 
 <td> hadoop3 </td> 
 <td> DN/NM/Worker </td> 
 <td> 1核/2G </td> 
 <td> hadoop </td> 
 </tr> 
 </tbody> 
</table>

## 3.2 配置并启动 ##

### 3.2.1 创建并配置hive-site.xml ###

在运行Spark SQL CLI中需要使用到Hive Metastore，故需要在Spark中添加其uris。具体方法是在SPARK\_HOME/conf目录下创建hive-site.xml文件，然后在该配置文件中，添加hive.metastore.uris属性，具体如下：

*<configuration> *

*  <property>*

*    <name>hive.metastore.uris</name>*

*    <value>thrift://hadoop1:9083</value>*

*    <description>Thrift URI for the remote metastore. Used by metastore client to connect to remote metastore.</description>*

*  </property>*

*</configuration>*

[![clip\_image028][clip_image028]][clip_image028_clip_image028]

### 3.2.2 启动Hive ###

在使用Spark SQL CLI之前需要启动Hive Metastore（如果数据存放在HDFS文件系统，还需要启动Hadoop的HDFS），使用如下命令可以使Hive Metastore启动后运行在后台，可以通过jobs查询：

*$nohup hive --service metastore > metastore.log 2>&1 &*

[![clip\_image030][clip_image030]][clip_image030_clip_image030]

### 3.2.3 启动Spark集群和Spark SQL CLI ###

通过如下命令启动Spark集群和Spark SQL CLI：

*$cd /app/hadoop/spark-1.1.0*

*$sbin/start-all.sh*

*$bin/spark-sql --master spark://hadoop1:7077 --executor-memory 1g*

在集群监控页面可以看到启动了SparkSQL应用程序：

[![clip\_image032][clip_image032]][clip_image032_clip_image032]

这时就可以使用HQL语句对Hive数据进行查询，另外可以使用COMMAND，如使用set进行设置参数：默认情况下，SparkSQL Shuffle的时候是200个partition，可以使用如下命令修改该参数：

*SET spark.sql.shuffle.partitions=20;*

运行同一个查询语句，参数改变后，Task（partition）的数量就由200变成了20。

[![clip\_image034][clip_image034]][clip_image034_clip_image034]

### 3.2.4 命令参数 ###

通过bin/spark-sql --help可以查看CLI命令参数：

[![clip\_image036][clip_image036]][clip_image036_clip_image036]

[![clip\_image038][clip_image038]][clip_image038_clip_image038]

其中\[options\] 是CLI启动一个SparkSQL应用程序的参数，如果不设置--master的话，将在启动spark-sql的机器以local方式运行，只能通过http://机器名:4040进行监控；这部分参数，可以参照Spark1.0.0 应用程序部署工具spark-submit 的参数。

\[cli option\]是CLI的参数，通过这些参数CLI可以直接运行SQL文件、进入命令行运行SQL命令等等，类似以前的Shark的用法。需要注意的是CLI不是使用JDBC连接，所以不能连接到ThriftServer；但可以配置conf/hive-site.xml连接到Hive的Metastore，然后对Hive数据进行查询。

## 3.3 实战Spark SQL CLI ##

### 3.3.1 获取订单每年的销售单数、销售总额 ###

第一步   设置任务个数，在这里修改为20个

*spark-sql>SET spark.sql.shuffle.partitions=20;*

*[![clip\_image040][clip_image040]][clip_image040_clip_image040]*

第二步   运行SQL语句

*spark-sql>use hive;*

*[![clip\_image042][clip_image042]][clip_image042_clip_image042]*

*spark-sql>select c.theyear,count(distinct a.ordernumber),sum(b.amount) from tbStock a join tbStockDetail  b on a.ordernumber=b.ordernumber join tbDate c on a.dateid=c.dateid group by c.theyear order by c.theyear;*

[![clip\_image044][clip_image044]][clip_image044_clip_image044]

第三步   查看运行结果

[![clip\_image046][clip_image046]][clip_image046_clip_image046]

[![clip\_image048][clip_image048]][clip_image048_clip_image048]

### 3.3.2 计算所有订单每年的总金额 ###

第一步   执行SQL语句

*[![clip\_image050][clip_image050]][clip_image050_clip_image050]*

第二步   执行结果

使用CLI执行结果如下：

[![clip\_image052][clip_image052]][clip_image052_clip_image052]

[![clip\_image054][clip_image054]][clip_image054_clip_image054]

### 3.3.3 计算所有订单每年最大金额订单的销售额 ###

第一步   执行SQL语句

*spark-sql>select c.theyear,max(d.sumofamount) from tbDate c join (select a.dateid,a.ordernumber,sum(b.amount) as sumofamount from tbStock a join tbStockDetail  b on a.ordernumber=b.ordernumber group by a.dateid,a.ordernumber ) d  on c.dateid=d.dateid group by c.theyear sort by c.theyear;*

*[![clip\_image056][clip_image056]][clip_image056_clip_image056]*

第二步   执行结果

使用CLI执行结果如下：

[![clip\_image058][clip_image058]][clip_image058_clip_image058]

[![clip\_image060][clip_image060]][clip_image060_clip_image060]

# 4、Spark Thrift Server #

ThriftServer是一个JDBC/ODBC接口，用户可以通过JDBC/ODBC连接ThriftServer来访问SparkSQL的数据。ThriftServer在启动的时候，会启动了一个SparkSQL的应用程序，而通过JDBC/ODBC连接进来的客户端共同分享这个SparkSQL应用程序的资源，也就是说不同的用户之间可以共享数据；ThriftServer启动时还开启一个侦听器，等待JDBC客户端的连接和提交查询。所以，在配置ThriftServer的时候，至少要配置ThriftServer的主机名和端口，如果要使用Hive数据的话，还要提供Hive Metastore的uris。

**【注】**Spark CLI和Spark Thrift Server实验环境为第二课《Spark编译与部署（下）--Spark编译安装》所搭建

## 4.1 配置并启动 ##

### 4.1.1 创建并配置hive-site.xml ###

第一步   创建hive-site.xml配置文件

在$SPARK\_HOME/conf目录下修改hive-site.xml配置文件（如果在Spark SQL CLI中已经添加，可以省略）：

*$cd /app/hadoop/spark-1.1.0/conf*

*$sudo vi hive-site.xml*

*[![clip\_image062][clip_image062]][clip_image062_clip_image062]*

第二步   修改配置文件

设置hadoop1为Metastore服务器，hadoop2为Thrift Server服务器，配置内容如下：

*<configuration>*

*  <property>*

*    <name>hive.metastore.uris</name>*

*    <value>thrift://hadoop1:9083</value>*

*    <description>Thrift URI for the remote metastore. Used by metastore client to connect to remote metastore.</description>*

*  </property>*

* *

*  <property>*

*    <name>hive.server2.thrift.min.worker.threads</name>*

*    <value>5</value>*

*    <description>Minimum number of Thrift worker threads</description>*

*  </property>*

* *

*  <property>*

*    <name>hive.server2.thrift.max.worker.threads</name>*

*    <value>500</value>*

*    <description>Maximum number of Thrift worker threads</description>*

*  </property>*

* *

*  <property>*

*    <name>hive.server2.thrift.port</name>*

*    <value>10000</value>*

*    <description>Port number of HiveServer2 Thrift interface. Can be overridden by setting $HIVE\_SERVER2\_THRIFT\_PORT</description>*

*  </property>*

* *

*  <property>*

*    <name>hive.server2.thrift.bind.host</name>*

*    <value>hadoop2</value>*

*    <description>Bind host on which to run the HiveServer2 Thrift interface.Can be overridden by setting$HIVE\_SERVER2\_THRIFT\_BIND\_HOST</description>*

*  </property>*

*</configuration>*

[![clip\_image064][clip_image064]][clip_image064_clip_image064]

### 4.1.2 启动Hive ###

在hadoop1节点中，在后台启动Hive Metastore（如果数据存放在HDFS文件系统，还需要启动Hadoop的HDFS）：

*$nohup hive --service metastore > metastore.log 2>&1 &*

[![clip\_image066][clip_image066]][clip_image066_clip_image066]

### 4.1.3 启动Spark集群和Thrift Server ###

在hadoop1节点启动Spark集群

*$cd /app/hadoop/spark-1.1.0/sbin*

*$./start-all.sh*

在hadoop2节点上进入SPARK\_HOME/sbin目录，使用如下命令启动Thrift Server

*$cd /app/hadoop/spark-1.1.0/sbin*

*$./start-thriftserver.sh --master spark://hadoop1:7077 --executor-memory 1g*

[![clip\_image068][clip_image068]][clip_image068_clip_image068]

**注意**：Thrift Server需要按照配置在hadoop2启动！

在集群监控页面可以看到启动了SparkSQL应用程序：

[![clip\_image070][clip_image070]][clip_image070_clip_image070]

### 4.1.4 命令参数 ###

使用sbin/start-thriftserver.sh --help可以查看ThriftServer的命令参数：

*$sbin/start-thriftserver.sh --help Usage: ./sbin/start-thriftserver \[options\] \[thrift server options\]*

*        Thrift server options: Use value for given property*

[![clip\_image072][clip_image072]][clip_image072_clip_image072]

[![clip\_image074][clip_image074]][clip_image074_clip_image074]

其中\[options\] 是Thrift Server启动一个SparkSQL应用程序的参数，如果不设置--master的话，将在启动Thrift Server的机器以local方式运行，只能通过http://机器名:4040进行监控；这部分参数，可以参照Spark1.0.0 应用程序部署工具spark-submit 的参数。在集群中提供Thrift Server的话，一定要配置master、executor-memory等参数。

\[thrift server options\]是Thrift Server的参数，可以使用-dproperty=value的格式来定义；在实际应用上，因为参数比较多，通常使用conf/hive-site.xml配置。

## 4.2 实战Thrift Server ##

### 4.2.1 远程客户端连接 ###

可以在任意节点启动bin/beeline，用!connect jdbc:hive2://hadoop2:10000连接ThriftServer，因为没有采用权限管理，所以用户名用运行bin/beeline的用户hadoop，密码为空：

*$cd /app/hadoop/spark-1.1.0/bin*

*$./beeline*

*beeline>!connect jdbc:hive2://hadoop2:10000*

*[![clip\_image076][clip_image076]][clip_image076_clip_image076]*

### 4.2.2 基本操作 ###

第一步   显示hive数据库所有表

*beeline>show database;*

*beeline>use hive;*

*beeline>show tables;*

*[![clip\_image078][clip_image078]][clip_image078_clip_image078]*

第二步   创建表testThrift

*beeline>create table testThrift(field1 String , field2 Int);*

*beeline>show tables;*

[![clip\_image080][clip_image080]][clip_image080_clip_image080]

第三步   把tbStockDetail表中金额大于3000插入到testThrift表中

*beeline>insert into table testThrift select ordernumber,amount from tbStockDetail  where amount>3000;*

*beeline>select \* from testThrift;*

[![clip\_image082][clip_image082]][clip_image082_clip_image082]

第四步   重新创建testThrift表中，把年度最大订单插入该表中

*beeline>drop table testThrift;*

*beeline>create table testThrift (field1 String , field2 Int);*

*beeline>insert into table testThrift select c.theyear,max(d.sumofamount) from tbDate c join (select a.dateid,a.ordernumber,sum(b.amount) as sumofamount from tbStock a join tbStockDetail  b on a.ordernumber=b.ordernumber group by a.dateid,a.ordernumber ) d  on c.dateid=d.dateid group by c.theyear sort by c.theyear;*

*beeline>select \* from testThrift;*

*[![clip\_image084][clip_image084]][clip_image084_clip_image084]*

### 4.2.3 计算所有订单每年的订单数 ###

第一步   执行SQL语句

*spark-sql>select c.theyear, count(distinct a.ordernumber) from tbStock a join tbStockDetail  b on a.ordernumber=b.ordernumber join tbDate c on a.dateid=c.dateid group by c.theyear order by c.theyear;*

第二步   执行结果

[![clip\_image086][clip_image086]][clip_image086_clip_image086]

Stage监控页面：

[![clip\_image088][clip_image088]][clip_image088_clip_image088]

查看Details for Stage 28

[![clip\_image090][clip_image090]][clip_image090_clip_image090]

### 4.2.4 计算所有订单月销售额前十名 ###

第一步   执行SQL语句

*spark-sql>select c.theyear,c.themonth,sum(b.amount) as sumofamount from tbStock a join tbStockDetail  b on a.ordernumber=b.ordernumber join tbDate c on a.dateid=c.dateid group by c.theyear,c.themonth order by sumofamount desc limit 10;*

第二步   执行结果

[![clip\_image092][clip_image092]][clip_image092_clip_image092]

Stage监控页面：

[![clip\_image094][clip_image094]][clip_image094_clip_image094]

在其第一个Task中，从本地读入数据

[![clip\_image096][clip_image096]][clip_image096_clip_image096]

在后面的Task是从内存中获取数据

[![clip\_image098][clip_image098]][clip_image098_clip_image098]

### 4.2.5 缓存表数据 ###

第一步   缓存数据

*beeline>cache table tbStock;*

*beeline>select count(\*) from tbStock;*

*[![clip\_image100][clip_image100]][clip_image100_clip_image100]*

第二步   运行4.2.4中的“计算所有订单月销售额前十名”

*beeline>select count(\*) from tbStock;*

[![clip\_image102][clip_image102]][clip_image102_clip_image102]

本次计算划给11.233秒，查看webUI，数据已经缓存，缓存率为100%：

[![clip\_image104][clip_image104]][clip_image104_clip_image104]

第三步   在另外节点再次运行

在hadoop3节点启动bin/beeline，用!connect jdbc:hive2://hadoop2:10000连接ThriftServer，然后直接运行对tbStock计数（注意没有进行数据库的切换）：

[![clip\_image106][clip_image106]][clip_image106_clip_image106]

用时0.343秒，再查看webUI中的stage：

[![clip\_image108][clip_image108]][clip_image108_clip_image108]

Locality Level是PROCESS，显然是使用了缓存表。

从上可以看出，ThriftServer可以连接多个JDBC/ODBC客户端，并相互之间可以共享数据。顺便提一句，ThriftServer启动后处于监听状态，用户可以使用ctrl+c退出ThriftServer；而beeline的退出使用!q命令。

### 4.2.6 在IDEA中JDBC访问 ###

有了ThriftServer，开发人员可以非常方便的使用JDBC/ODBC来访问SparkSQL。下面是一个scala代码，查询表tbStockDetail，返回amount>3000的单据号和交易金额：

第一步   在IDEA创建class6包和类JDBCofSparkSQL

参见《Spark编程模型（下）--IDEA搭建及实战》在IDEA中创建class6包并新建类JDBCofSparkSQL。该类中查询tbStockDetail金额大于3000的订单：

*package class6*

*import java.sql.DriverManager*

* *

*object JDBCofSparkSQL \{*

*  def main(args: Array\[String\]) \{*

*    Class.forName("org.apache.hive.jdbc.HiveDriver")*

*    val conn = DriverManager.getConnection("jdbc:hive2://hadoop2:10000/hive", "hadoop", "")*

*    try \{*

*      val statement = conn.createStatement*

*val rs = statement.executeQuery("select ordernumber,amount from tbStockDetail  where amount>3000")*

*      while (rs.next) \{*

*        val ordernumber = rs.getString("ordernumber")*

*        val amount = rs.getString("amount")*

*        println("ordernumber = %s, amount = %s".format(ordernumber, amount))*

*      \}*

*    \} catch \{*

*      case e: Exception => e.printStackTrace*

*    \}*

*    conn.close*

*  \}*

*\}*

第二步   查看运行结果

在IDEA中可以观察到，在运行日志窗口中没有运行过程的日志，只显示查询结果

[![clip\_image110][clip_image110]][clip_image110_clip_image110]

第三步   查看监控结果

从Spark监控界面中观察到，该Job有一个编号为6的Stage，该Stage有2个Task，分别运行在hadoop1和hadoop2节点，获取数据为NODE\_LOCAL方式。

[![clip\_image112][clip_image112]][clip_image112_clip_image112]

[![clip\_image114][clip_image114]][clip_image114_clip_image114]

[![clip\_image116][clip_image116]][clip_image116_clip_image116]

在hadoop2中观察Thrift Server运行日志如下：

[![clip\_image118][clip_image118]][clip_image118_clip_image118]

* *

作者： [石山园][Link 1]  出处： [http://www.cnblogs.com/shishanyuan/][Link 1]

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。如果觉得还有帮助的话，可以点一下右下角的 【推荐】，希望能够持续的为大家带来好的技术文章！想跟我一起进步么？那就 【关注】我吧。

分类: [ 20.Spark入门实战系列][20.Spark]

好文要顶  关注我 收藏该文  ![icon_weibo_24.png][]  ![wechat.png][]

[![sample_face.gif][]][sample_face.gif 1]

[shishanyuan][sample_face.gif 1]  
[关注 - 16][- 16]  
[粉丝 - 558][- 558]

荣誉： [推荐博客][Link 2]

\+加关注

[« ][Link 3]上一篇： [Spark入门实战系列--5.Hive（下）--Hive实战][Link 3]  
[» ][Link 4] 下一篇： [Spark入门实战系列--6.SparkSQL（中）--深入了解SparkSQL运行计划及调优][Link 4]

posted @ 2015-08-26 09:03 [ shishanyuan][Link 1] 阅读( 71561) 评论( 26) [ 编辑][Link 5] [ 收藏][Link 6]

发表评论

[\#1楼][1]  2015-10-27 11:39 | [ tzou][tzou] [  ][Link 7]

请问一下，schemardd和dataframe有什么区别？  
1.3.0之后的版本是不是没有schemardd的概念了？  
谢谢！

支持(0) 反对(0)

[\#2楼][2] \[楼主\] 2015-10-29 09:36 | [ shishanyuan][Link 1] [  ][Link 8]

[@][1]tzou  
在Spark 1.3.0以Spark SQL原有的SchemaRDD为蓝本，引入了Spark DataFrame API，具体他们之间的区别可以参见Databricks公司连城写的文章  
[http://code.csdn.net/news/2824958][http_code.csdn.net_news_2824958]

支持(0) 反对(0)

[\#3楼][3]  2015-11-02 22:16 | [ 张平a][_a] [  ][Link 9]

hive2是啥东东？

支持(0) 反对(0)

[\#4楼][4] \[楼主\] 2015-11-05 10:28 | [ shishanyuan][Link 1] [  ][Link 8]

[@][3]张平a  
hiveserver2是hiveserver的改进版本，相比而言，hiveserver2更加稳定，支持的功能更多，hiveserver 和 hiveserver2 在使用JDBC连接方面有两个不同的地方：  
1.驱动类：org.apache.hadoop.hive.jdbc.HiveDriver –> org.apache.hive.jdbc.HiveDriver  
2.URL：jdbc:hive://localhost:10000/default –> jdbc:hive2://localhost:10000/default

支持(0) 反对(0)

[\#5楼][5]  2015-11-06 08:52 | [ 张平a][_a] [  ][Link 9]

[@][4]shishanyuan  
老师，您好：  
按照您的思路一路做下来都很正常，现在唯独卡有一个问题上研究一天多也没解决掉：jdbc连接ThriftServer。我的环境跟您略有不同，1、我是单台服务器；2、我用的是cdh530版本（spark重新编译，hadoop和hive直接下得gz包）；  
前提：1、spark/conf/hive-site.xml已经设置；2、metastore已经启动；3、通过日志查看thriftserver启动一切正常；问题是卡在beeline>!connect jdbc:hive2://hostname:10000时一直在报一个错误：Error: Could not establish connection to jdbc:hive2://hostname:10000: Internal error processing OpenSession (state=08S01,code=0)上；以为是mysql 的驱动包没有引入，引入 到spark/lib下问题依旧，而且我发现在此之前就有了异常 ：执行./beeline后找不到hive版本号（一直是三个问号）：Beeline version ??? by Apache Hive；我现在怀疑是不是版本问题，但是我都是下得cdh同一版本，按理说不应该是版本问题；

支持(0) 反对(0)

[\#6楼][6] \[楼主\] 2015-11-19 16:02 | [ shishanyuan][Link 1] [  ][Link 8]

[@][5]张平a  
不好意思，由于最近比较忙，不能及时回复  
对于你遇到的问题个人觉得，一方面是spark与hive之间的版本支持，另一方面是spark现在还处于完善时期，可能出现一些按照文档无法实现的问题，建议还是多试，多找一些资料参考

支持(0) 反对(0)

[\#7楼][7]  2015-12-09 19:38 | [ appledx520][appledx520] [  ][Link 10]

老师您好：我在运行sparksql时，一直卡在这个地方，没法解决，希望得到您的解答  
15/12/09 19:30:44 INFO BlockManagerMasterActor: Registering block manager slaver6:38936 with 530.3 MB RAM  
15/12/09 19:30:44 INFO BlockManagerMasterActor: Registering block manager slaver5:47349 with 530.3 MB RAM  
15/12/09 19:30:44 INFO BlockManagerMasterActor: Registering block manager slaver1:47859 with 530.3 MB RAM  
15/12/09 19:30:44 INFO BlockManagerMasterActor: Registering block manager slaver7:48437 with 530.3 MB RAM  
15/12/09 19:30:44 INFO BlockManagerMasterActor: Registering block manager slaver3:49835 with 530.3 MB RAM  
15/12/09 19:30:44 INFO BlockManagerMasterActor: Registering block manager slaver2:36605 with 530.3 MB RAM  
15/12/09 19:30:44 INFO BlockManagerMasterActor: Registering block manager slaver4:36255 with 530.3 MB RAM

支持(0) 反对(0)

[\#8楼][8] \[楼主\] 2015-12-10 12:14 | [ shishanyuan][Link 1] [  ][Link 8]

[@][7]appledx520  
提供的信息是正常运行的日志，并没有异常的信息  
按照你说的情况来看，是在注册Executor的BlockManager时卡住了，可以看一下是不是Master与Executor无法建立通讯（配置问题），还是存储空间不足等原因

支持(0) 反对(0)

[\#9楼][9]  2015-12-10 12:18 | [ appledx520][appledx520] [  ][Link 10]

谢谢您的回答，我的测试集群每台都是8g内存，应该不是内存不足。mysql和hive都配在主节点，master是可以ssh到各个slaver的（slaver不能到master）

支持(0) 反对(0)

[\#10楼][10] \[楼主\] 2015-12-10 14:49 | [ shishanyuan][Link 1] [  ][Link 8]

[@][9]appledx520  
（slaver不能到master）--尽可能保证master与slaver之间互相ssh，确认几个问题：  
0、hive是否安装成功，通过验证进行确认  
1、在Spark的监控UI上，能不能看到Slave节点；  
2、能不能看到启动的spark-sql应用程序，还没有启动成功，应该看不了:(  
3、提供你的场景和其他日志信息

支持(0) 反对(0)

[\#11楼][11]  2015-12-18 19:49 | [ zookeepers][zookeepers] [  ][Link 11]

老师，你好，我在eclipse里运行ide里的程序的时候出错了，不知道为什么，求解答 ![857799-20151218194855271-1437967699.png][]

支持(0) 反对(0)

[\#12楼][12] \[楼主\] 2015-12-18 21:15 | [ shishanyuan][Link 1] [  ][Link 8]

[@][11]zookeepers  
通过你的截图可以看到"Required field 'client\_protocol' is unset" ，应该是某个需要的字段没有初始化  
检查一下Hive中的数据库是否正确初始化  
另外你运行eclipse，可以通过提示的错误进行问题解决

支持(0) 反对(0)

[\#13楼][13]  2016-04-13 09:33 | [ 唐予之][Link 12] [  ][Link 13]

学习了，感谢！

支持(0) 反对(0)

[\#14楼][14]  2016-07-13 14:47 | [ crazy\_orange][crazy_orange] [  ][Link 14]

写的太好了，感谢楼主！

支持(0) 反对(0)

[\#15楼][15] \[楼主\] 2016-07-15 14:23 | [ shishanyuan][Link 1] [  ][Link 8]

[@][14]crazy\_orange  
谢谢！

支持(0) 反对(0)

[\#16楼][16]  2016-07-22 09:29 | [ 飞飞\_yang][_yang] [  ][Link 15]

博主老师，你好！我在SparkSQL操作的时候，比如我输入的指令是select count(\*) from sogouq2;就会出现这样的问题；  
16/07/22 09:25:14 WARN util.AkkaUtils: Error sending message in 1 attempts  
akka.pattern.AskTimeoutException: Recipient\[Actor\[akka://sparkDriver/user/BlockManagerMaster\#1874126186\]\] had already been terminated.  
at akka.pattern.AskableActorRef$.ask$extension(AskSupport.scala:134)  
at org.apache.spark.util.AkkaUtils$.askWithReply(AkkaUtils.scala:175)  
at org.apache.spark.storage.BlockManagerMaster.askDriverWithReply(BlockManagerMaster.scala:218)  
请问博主老师这是怎么问题导致的？谢谢你

支

[Spark_--6.SparkSQL_--SparkSQL]: http://www.cnblogs.com/shishanyuan/p/4723604.html
[--Spark]: http://www.cnblogs.com/shishanyuan/p/4699644.html
[Link 1]: http://www.cnblogs.com/shishanyuan/
[clip_image002]: http://images0.cnblogs.com/blog/107289/201508/121050147707105.gif
[clip_image002_clip_image002]: /images/20220609/fd016da7f3dc4b93b46904a0c42666fb.png
[clip_image004]: http://images0.cnblogs.com/blog/107289/201508/121050185673946.gif
[clip_image004_clip_image004]: /images/20220609/b641a6ab3e63471eafe82681f939d11c.png
[clip_image006]: http://images0.cnblogs.com/blog/107289/201508/121050194891031.gif
[clip_image006_clip_image006]: /images/20220609/6243d49e07ea463bb10a19bc0bc05261.png
[clip_image008]: http://images0.cnblogs.com/blog/107289/201508/121050218326115.gif
[clip_image008_clip_image008]: /images/20220609/4290d91381d74b4c852386950ce17689.png
[clip_image010]: http://images0.cnblogs.com/blog/107289/201508/121050238017312.gif
[clip_image010_clip_image010]: /images/20220609/6af569dea01b486582e048aae1931b7f.png
[clip_image012]: http://images0.cnblogs.com/blog/107289/201508/121050248012140.gif
[clip_image012_clip_image012]: /images/20220609/8226c574298540349c982c5b50c66ef4.png
[clip_image014]: http://images0.cnblogs.com/blog/107289/201508/121050309424065.gif
[clip_image014_clip_image014]: /images/20220609/2aad6276eef14981ab532a18043fb62b.png
[clip_image016]: http://images0.cnblogs.com/blog/107289/201508/121050327549776.gif
[clip_image016_clip_image016]: /images/20220609/645f883173ba404485eed57b481bc659.png
[clip_image018]: http://images0.cnblogs.com/blog/107289/201508/121050345359433.gif
[clip_image018_clip_image018]: /images/20220609/da5868341b57485eb326b0c1c684b812.png
[clip_image020]: http://images0.cnblogs.com/blog/107289/201508/121050363486146.gif
[clip_image020_clip_image020]: /images/20220609/4b86b36bd9b34f17af605d21f65d308c.png
[clip_image022]: http://images0.cnblogs.com/blog/107289/201508/121050396451073.jpg
[clip_image022_clip_image022]: /images/20220609/989336b788604c5ca3167dd3ae1524bb.png
[clip_image024]: http://images0.cnblogs.com/blog/107289/201508/121050406143144.jpg
[clip_image024_clip_image024]: /images/20220609/968c5bb55fef4491961f89232c2f04b5.png
[clip_image026]: http://images0.cnblogs.com/blog/107289/201508/121050443792526.gif
[clip_image026_clip_image026]: /images/20220609/3f3c38886e944930aaff939d33bf5eec.png
[clip_image028]: http://images0.cnblogs.com/blog/107289/201508/121050468644567.jpg
[clip_image028_clip_image028]: /images/20220609/57631ccb83104590a3fbeef258d47175.png
[clip_image030]: http://images0.cnblogs.com/blog/107289/201508/121050500355765.jpg
[clip_image030_clip_image030]: /images/20220609/1f5d89931cc94d7faae742d7a31c1826.png
[clip_image032]: http://images0.cnblogs.com/blog/107289/201508/121050514733292.jpg
[clip_image032_clip_image032]: /images/20220609/1372a3770f0848fcac29bc47b41c0052.png
[clip_image034]: http://images0.cnblogs.com/blog/107289/201508/121050531923734.gif
[clip_image034_clip_image034]: /images/20220609/26f8d1333efb405a948e4e753118cef0.png
[clip_image036]: http://images0.cnblogs.com/blog/107289/201508/121050547851448.jpg
[clip_image036_clip_image036]: /images/20220609/8e082b30ea1b4ae58196166450110033.png
[clip_image038]: http://images0.cnblogs.com/blog/107289/201508/121051017073500.jpg
[clip_image038_clip_image038]: /images/20220609/a9ce7a92e1e44eb4a8dcb58b60b4a8e3.png
[clip_image040]: http://images0.cnblogs.com/blog/107289/201508/121051026602342.jpg
[clip_image040_clip_image040]: /images/20220609/475eb0c5a8bd4e27ab835250143fb43f.png
[clip_image042]: http://images0.cnblogs.com/blog/107289/201508/121051082858123.jpg
[clip_image042_clip_image042]: /images/20220609/bb31ff25102b4094a54bf76c0e7660cd.png
[clip_image044]: http://images0.cnblogs.com/blog/107289/201508/121051162075003.jpg
[clip_image044_clip_image044]: /images/20220609/82768eef42464c7ab97e3a18ced7ecf6.png
[clip_image046]: http://images0.cnblogs.com/blog/107289/201508/121051203325043.jpg
[clip_image046_clip_image046]: /images/20220609/04e70f4ba66d401c91da3e4265ecf9d5.png
[clip_image048]: http://images0.cnblogs.com/blog/107289/201508/121051271927880.jpg
[clip_image048_clip_image048]: /images/20220609/55154059e19f409bb342bd0fbf54cf0f.png
[clip_image050]: http://images0.cnblogs.com/blog/107289/201508/121051297859421.jpg
[clip_image050_clip_image050]: /images/20220609/8856d57c10c447f1b9dad3a14f9e9022.png
[clip_image052]: http://images0.cnblogs.com/blog/107289/201508/121051320676291.jpg
[clip_image052_clip_image052]: /images/20220609/ad65cc5ee5f84fd6ae6e063280d25097.png
[clip_image054]: http://images0.cnblogs.com/blog/107289/201508/121051344269902.jpg
[clip_image054_clip_image054]: /images/20220609/7a25ba31ef1d4fd39f58c1db10c46460.png
[clip_image056]: http://images0.cnblogs.com/blog/107289/201508/121051400041699.jpg
[clip_image056_clip_image056]: /images/20220609/52dfffcfd9224b9088bafe8699bb3175.png
[clip_image058]: http://images0.cnblogs.com/blog/107289/201508/121051416142641.jpg
[clip_image058_clip_image058]: /images/20220609/8cae03b9fc0141988c81898528a06653.png
[clip_image060]: http://images0.cnblogs.com/blog/107289/201508/121051465677794.jpg
[clip_image060_clip_image060]: /images/20220609/f023e949890c447e976ef6f74e93e8d6.png
[clip_image062]: http://images0.cnblogs.com/blog/107289/201508/121051487543692.jpg
[clip_image062_clip_image062]: /images/20220609/eb7a20b4493a40868dd2362085e40317.png
[clip_image064]: http://images0.cnblogs.com/blog/107289/201508/121051541294016.jpg
[clip_image064_clip_image064]: /images/20220609/d5c6828e73c84c45b3a665308800fd7c.png
[clip_image066]: http://images0.cnblogs.com/blog/107289/201508/121052005989140.jpg
[clip_image066_clip_image066]: /images/20220609/8a65241d3fe245eb9d2eb23ad8673f35.png
[clip_image068]: http://images0.cnblogs.com/blog/107289/201508/121052027706510.jpg
[clip_image068_clip_image068]: /images/20220609/5a1649e29ada4cc08fc6247aef8ed71e.png
[clip_image070]: http://images0.cnblogs.com/blog/107289/201508/121052049735637.jpg
[clip_image070_clip_image070]: /images/20220609/d68a37e9fa3443d7b9d29c5c0fbe325b.png
[clip_image072]: http://images0.cnblogs.com/blog/107289/201508/121052140045844.jpg
[clip_image072_clip_image072]: /images/20220609/07e73690bd7d41f580f3c58d378980de.png
[clip_image074]: http://images0.cnblogs.com/blog/107289/201508/121052161148701.jpg
[clip_image074_clip_image074]: /images/20220609/625aa950d09a4ecd95a508c0ac314473.png
[clip_image076]: http://images0.cnblogs.com/blog/107289/201508/121052182078328.jpg
[clip_image076_clip_image076]: /images/20220609/64984b11485246788ddb3fd08e5dc310.png
[clip_image078]: http://images0.cnblogs.com/blog/107289/201508/121052195203127.jpg
[clip_image078_clip_image078]: /images/20220609/d704d6d7487d4b25a4d33cf5e161da85.png
[clip_image080]: http://images0.cnblogs.com/blog/107289/201508/121052217073726.jpg
[clip_image080_clip_image080]: /images/20220609/b85eb8243e4a495199785c042f81765b.png
[clip_image082]: http://images0.cnblogs.com/blog/107289/201508/121052228488809.jpg
[clip_image082_clip_image082]: /images/20220609/680904c1635c4e8d9f9111ecf6de7772.png
[clip_image084]: http://images0.cnblogs.com/blog/107289/201508/121052280208663.jpg
[clip_image084_clip_image084]: /images/20220609/1080cbe9d8394a3a99d3c2f66ee45870.png
[clip_image086]: http://images0.cnblogs.com/blog/107289/201508/121052303322991.jpg
[clip_image086_clip_image086]: /images/20220609/8930a7040f464935b29d2c439eb1f7e2.png
[clip_image088]: http://images0.cnblogs.com/blog/107289/201508/121052353645887.jpg
[clip_image088_clip_image088]: /images/20220609/ed53b1514fcb4edc87f13f85b83760eb.png
[clip_image090]: http://images0.cnblogs.com/blog/107289/201508/121052363649714.jpg
[clip_image090_clip_image090]: /images/20220609/b60424dcc13443aa8a866005fb0a33e8.png
[clip_image092]: http://images0.cnblogs.com/blog/107289/201508/121052385203856.jpg
[clip_image092_clip_image092]: /images/20220609/de7f240d2f704714a9bdfa9d43d17ec1.png
[clip_image094]: http://images0.cnblogs.com/blog/107289/201508/121052402542825.jpg
[clip_image094_clip_image094]: /images/20220609/1beb8868d12a4d6499e75e52db8b29ad.png
[clip_image096]: http://images0.cnblogs.com/blog/107289/201508/121102475823218.jpg
[clip_image096_clip_image096]: /images/20220609/96b87d0ceb814e73b3e7ee8acf7b23c3.png
[clip_image098]: http://images0.cnblogs.com/blog/107289/201508/121102487079773.jpg
[clip_image098_clip_image098]: /images/20220609/1cb6f1b790804e72881cbbcb02c27319.png
[clip_image100]: http://images0.cnblogs.com/blog/107289/201508/121102498327330.jpg
[clip_image100_clip_image100]: /images/20220609/57b54677ce5a41d38a63ad0fe76edffd.png
[clip_image102]: http://images0.cnblogs.com/blog/107289/201508/121102506295985.jpg
[clip_image102_clip_image102]: /images/20220609/642e575f67644207b066cfc87fe9b688.png
[clip_image104]: http://images0.cnblogs.com/blog/107289/201508/121102516142286.jpg
[clip_image104_clip_image104]: /images/20220609/c0653a3f7018476c95a53e837b84de21.png
[clip_image106]: http://images0.cnblogs.com/blog/107289/201508/121102527854828.jpg
[clip_image106_clip_image106]: /images/20220609/328283554e5044b99312407f3e586300.png
[clip_image108]: http://images0.cnblogs.com/blog/107289/201508/121102535986712.jpg
[clip_image108_clip_image108]: /images/20220609/110456fca7244a9bb1495205398d4069.png
[clip_image110]: http://images0.cnblogs.com/blog/107289/201508/121102551924426.jpg
[clip_image110_clip_image110]: /images/20220609/9cae7eb06ced42b3b1565dd5e07757a5.png
[clip_image112]: http://images0.cnblogs.com/blog/107289/201508/121102580827410.jpg
[clip_image112_clip_image112]: /images/20220609/bdea752ec1394710b7cb0c5d2380bcf0.png
[clip_image114]: http://images0.cnblogs.com/blog/107289/201508/121102596923651.jpg
[clip_image114_clip_image114]: /images/20220609/0a3a09596f654d9197260f03eb64c52c.png
[clip_image116]: http://images0.cnblogs.com/blog/107289/201508/121103024107920.jpg
[clip_image116_clip_image116]: /images/20220609/102af8dd55f44c47a0fcd42da1009a25.png
[clip_image118]: http://images0.cnblogs.com/blog/107289/201508/121103073322317.jpg
[clip_image118_clip_image118]: /images/20220609/c6212a0ab98546c6ad7f70c556b6bab3.png
[20.Spark]: http://www.cnblogs.com/shishanyuan/category/719232.html
[icon_weibo_24.png]: http://common.cnblogs.com/images/icon_weibo_24.png
[wechat.png]: /images/20220609/b765a52da446416f8073f948b1fbffb3.png
[sample_face.gif]: /images/20220609/d78d4809adc14905931ab185626ff96f.png
[sample_face.gif 1]: http://home.cnblogs.com/u/shishanyuan/
[- 16]: http://home.cnblogs.com/u/shishanyuan/followees
[- 558]: http://home.cnblogs.com/u/shishanyuan/followers
[Link 2]: http://www.cnblogs.com/expert/
[Link 3]: http://www.cnblogs.com/shishanyuan/p/4721439.html
[Link 4]: http://www.cnblogs.com/shishanyuan/p/4723641.html
[Link 5]: https://i.cnblogs.com/EditPosts.aspx?postid=4723604
[Link 6]: http://www.cnblogs.com/shishanyuan/p/4723604.html#
[1]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3292955
[tzou]: http://home.cnblogs.com/u/828316/
[Link 7]: http://msg.cnblogs.com/send/tzou
[2]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3294296
[Link 8]: http://msg.cnblogs.com/send/shishanyuan
[http_code.csdn.net_news_2824958]: http://code.csdn.net/news/2824958
[3]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3297428
[_a]: http://www.cnblogs.com/pingzhanga/
[Link 9]: http://msg.cnblogs.com/send/%E5%BC%A0%E5%B9%B3a
[4]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3299537
[5]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3300113
[6]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3310108
[7]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3323934
[appledx520]: http://home.cnblogs.com/u/854658/
[Link 10]: http://msg.cnblogs.com/send/appledx520
[8]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3324361
[9]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3324369
[10]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3324473
[11]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3329985
[zookeepers]: http://www.cnblogs.com/zookeepers/
[Link 11]: http://msg.cnblogs.com/send/zookeepers
[857799-20151218194855271-1437967699.png]: /images/20220609/ed36d28d00944c588b1addf841e6ea05.png
[12]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3330016
[13]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3406702
[Link 12]: http://www.cnblogs.com/luoxuehuan/
[Link 13]: http://msg.cnblogs.com/send/%E5%94%90%E4%BA%88%E4%B9%8B
[14]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3469289
[crazy_orange]: http://www.cnblogs.com/liufei-yes/
[Link 14]: http://msg.cnblogs.com/send/crazy_orange
[15]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3470690
[16]: http://www.cnblogs.com/shishanyuan/p/4723604.html#3474627
[_yang]: http://home.cnblogs.com/u/995740/
[Link 15]: http://msg.cnblogs.com/send/%E9%A3%9E%E9%A3%9E_yang