Hive 相关5-1）
hive是怎样保存元数据的保存元数据的方式有：内存数据库rerdy，本地mysql数据库，远程mysql数据库，但是本地的mysql数据用的比较多，因为本地读写速度都比较快
5-2）外部表与内部表的区别
先来说下Hive中内部表与外部表的区别： Hive 创建内部表时，会将数据移动到数据仓库指向的路径；若创建外部表，仅记录数据所在的路径，不对数据的位置做任何改变。在删除表的时候，内部表的元数据和数据会被一起删除，而外部表只删除元数据，不删除数据。这样外部表相对来说更加安全些，数据组织也更加灵活，方便共享源数据。
5-3）对于 hive，你写过哪些 UDF 函数，作用是什么UDF: user defined function 的缩写，编写hive udf的两种方式extends UDF 重写evaluate第二种extends GenericUDF重写initialize、getDisplayString、evaluate方法
5-4)Hive 的 sort by 和 order by 的区别 order by 会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序）只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。 sort by不是全局排序，其在数据进入reducer前完成排序. 因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1， 则sort by只保证每个reducer的输出有序，不保证全局有序。
5-5）hive保存元数据的方式以及各有什么特点？1、Hive有内存数据库derby数据库，特点是保存数据小，不稳定 2、mysql数据库，储存方式可以自己设定，持久化好，一般企业开发都用mysql做支撑 5-6）在开发中问什么建议使用外部表？1、外部表不会加载到hive中只会有一个引用加入到元数据中 2、在删除时不会删除表，只会删除元数据，所以不必担心数据的
5-7）hive partition 分区分区表，动态分区
5-8）insert into 和 override write 区别？insert into：将某一张表中的数据写到另一张表中 override write：覆盖之前的内容。
Hbase 相关6-1）Hbase 的 rowkey 怎么创建比较好？列族怎么创建比较好？
Rowkey是一个二进制码流，Rowkey的长度被很多开发者建议说设计在10~100个字节，不过建议是越短越好，不要超过16个字节。在查找时有索引会加快速度。
Rowkey散列原则 、 Rowkey唯一原则 、 针对事务数据Rowkey设计 、 针对统计数据的Rowkey设计 、 针对通用数据的Rowkey设计、 支持多条件查询的RowKey设计。
总结设计列族： 1、一般不建议设计多个列族 2、数据块的缓存的设计 3、激进缓存设计 4、布隆过滤器的设计(可以提高随机读取的速度) 5、生产日期的设计 6、列族压缩 7、单元时间版本
6-2）Hbase 的实现原理Hbase 的实现原理是rpc Protocol
6-3) hbase 过滤器实现原则感觉这个问题有问题，过滤器多的是啦，说的是哪一个不知道!!!! Hbase的过滤器有：RowFilter、PrefixFilter、KeyOnlyFilter、RandomRowFilter、InclusiveStopFilter、FirstKeyOnlyFilter、ColumnPrefixFilter、ValueFilter、ColumnCountGetFilter、SingleColumnValueFilter、SingleColumnValueExcludeFilter、WhileMatchFilter、FilterList 你看这么多过滤波器呢，谁知道你问的那个啊！！ 比较常用的过滤器有：RowFilter 一看就知道是行的过滤器，来过滤行的信息。PrefixFilter前缀的过滤器，就是把前缀作为参数来查找数据呗！剩下的不解释了看过滤器的直接意思就OK了很简单。
6-4）描述 HBase, zookeeper 搭建过程Zookeeper 的问题楼上爬爬有步骤，hbase 主要的配置文件有hbase.env.sh 主要配置的是JDK的路径以及是否使用外部的ZK，hbase-site.xml 主要配置的是与HDFS的链接的路径以及zk的信息，修改regionservers的链接其他机器的配置。
6-5）hive 如何调优？在优化时要注意数据的问题，尽量减少数据倾斜的问题，减少job的数量，同事对小的文件进行成大的文件，如果优化的设计那就更好了，因为hive的运算就是mapReduce所以调节mapreduce的参数也会使性能提高，如调节task的数目。
6-6）hive的权限的设置Hive的权限需要在hive-site.xml文件中设置才会起作用，配置默认的是false，需要把hive.security.authorization.enabled设置为true，并对不同的用户设置不同的权限，例如select ,drop等的操作。
6-7 ) hbase 写数据的原理
1. 首先，Client通过访问ZK来请求目标数据的地址。 2. ZK中保存了-ROOT-表的地址，所以ZK通过访问-ROOT-表来请求数据地址。 3. 同样，-ROOT-表中保存的是.META.的信息，通过访问.META.表来获取具体的RS。 4. .META.表查询到具体RS信息后返回具体RS地址给Client。 5. Client端获取到目标地址后，然后直接向该地址发送数据请求。
6-8）hbase宕机了如何处理？HBase的RegionServer宕机超过一定时间后，HMaster会将其所管理的region重新分布到其他活动的RegionServer上，由于数据和日志都持久在HDFS中，
该操作不会导致数据丢失。所以数据的一致性和安全性是有保障的。
但是重新分配的region需要根据日志恢复原RegionServer中的内存MemoryStore表，这会导致宕机的region在这段时间内无法对外提供服务。
而一旦重分布，宕机的节点重新启动后就相当于一个新的RegionServer加入集群，为了平衡，需要再次将某些region分布到该server。
因此，Region Server的内存表memstore如何在节点间做到更高的可用，是HBase的一个较大的挑战。
6-9）Hbase 中的 metastore 用来做什么的？Hbase的metastore是用来保存数据的，其中保存数据的方式有有三种第一种于第二种是本地储存，第二种是远程储存这一种企业用的比较多
6-10)hbase客户端在客户端怎样优化？Hbase使用JAVA来运算的，索引Java的优化也适用于hbase，在使用过滤器事记得开启bloomfilter可以是性能提高3-4倍，设置HBASE_HEAPSIZE设置大一些
6-11）hbase是怎样预分区的？如何去进行预分区，可以采用下面三步：
1.取样，先随机生成一定数量的rowkey,将取样数据按升序排序放到一个集合里
2.根据预分区的region个数，对整个集合平均分割，即是相关的splitKeys.
3.HBaseAdmin.createTable(HTableDescriptor tableDescriptor,byte[][] splitkeys)可以指定预分区的splitKey，即是指定region间的rowkey临界值 6-12）怎样将 mysql 的数据导入到 hbase 中？不能使用 sqoop，速度太慢了，提示如下： A、一种可以加快批量写入速度的方法是通过预先创建一些空的 regions，这样当 数据写入 HBase 时，会按照 region 分区情况，在集群内做数据的负载均衡。 B、hbase 里面有这样一个 hfileoutputformat 类，他的实现可以将数据转换成 hfile 格式，通过 new 一个这个类，进行相关配置,这样会在 hdfs 下面产生一个文件，这个 时候利用 hbase 提供的 jruby 的 loadtable.rb 脚本就可以进行批量导入。
6-13）谈谈 HBase 集群安装注意事项？ 需要注意的地方是 ZooKeeper 的配置。这与 hbase-env.sh 文件相关，文件中 HBASE_MANAGES_ZK 环境变量用来设置是使用 hbase 默认自带的 Zookeeper 还 是使用独立的 ZooKeeper。HBASE_MANAGES_ZK=false 时使用独立的，为 true 时 使用默认自带的。 某个节点的 HRegionServer 启动失败，这是由于这 3 个节点的系统时间不一致相 差超过集群的检查时间 30s。 6-14)简述 HBase 的瓶颈Hbase主要的瓶颈就是传输问题，在操作时大部分的操作都是需要对磁盘操作的
6-15）Redis, 传统数据库,hbase,hive 每个之间的区别Redis 是基于内存的数据库，注重实用内存的计算，hbase是列式数据库，无法创建主键，地从是基于HDFS的，每一行可以保存很多的列，hive是数据的仓库，是为了减轻mapreduce而设计的，不是数据库是用来与红薯做交互的。
6-16）Hbase 的特性,以及你怎么去设计 rowkey 和 columnFamily ,怎么去建一个 table因为hbase是列式数据库，列非表schema的一部分，所以只需要考虑rowkey和columnFamily 即可，rowkey有为的相关性，最好数据库添加一个前缀，文件越小，查询速度越快，再设计列是有一个列簇，但是列簇不宜过多。
6-17）Hhase与hive的区别 Apache HBase是一种Key/Value系统，它运行在HDFS之上。和Hive不一样，Hbase的能够在它的数据库上实时运行，而不是运行MapReduce任务。Hive被分区为表格，表格又被进一步分割为列簇。列簇必须使用schema定义，列簇将某一类型列集合起来（列不要求schema定义）。例如，“message”列簇可能包含：“to”, ”from” “date”, “subject”, 和”body”. 每一个 key/value对在Hbase中被定义为一个cell，每一个key由row-key，列簇、列和时间戳。在Hbase中，行是key/value映射的集合，这个映射通过row-key来唯一标识。Hbase利用Hadoop的基础设施，可以利用通用的设备进行水平的扩展。
6-18）描述hbase的scan和get功能以及实现的异同
HBase的查询实现只提供两种方式： 1、按指定RowKey获取唯一一条记录，get方法（org.apache.hadoop.hbase.client.Get） 2、按指定的条件获取一批记录，scan方法（org.apache.hadoop.hbase.client.Scan） 实现条件查询功能使用的就是scan方式
6-19）HBase scan setBatch和setCaching的区别 can可以通过setCaching与setBatch方法提高速度（以空间换时间）， setCaching设置的值为每次rpc的请求记录数，默认是1；cache大可以优化性能，但是太大了会花费很长的时间进行一次传输。 setBatch设置每次取的column size；有些row特别大，所以需要分开传给client，就是一次传一个row的几个column。 6-20）hbase 中cell的结构cell中的数据是没有类型的，全部是字节码形式存贮。
6-21）hbase 中region太多和region太大带来的冲突Hbase的region会自动split，当region太时，regio太大时分布会不均衡，同时对于大批量的代入数据建议如下： 1、还是必须让业务方对rowkey进行预分片，对业务数据rowkey进行md5或者其他的hash策略，让数据尽量随机分布而不是顺序写入。 2、随时观察region的大小，是否出现大region的情况。 Flume相关7-1）flume 不采集 Nginx 日志，通过 Logger4j 采集日志，优缺点是什么？在nginx采集日志时无法获取session的信息，然而logger4j则可以获取session的信息，logger4j的方式比较稳定，不会宕机。缺点：不够灵活，logger4j的方式和项目结合过滤紧密，二flume的方式就比较灵活，便于插拔式比较好，不会影响项目的性能。
7-2）flume 和 kafka 采集日志区别，采集日志时中间停了，怎么记录之前的日志。Flume 采集日志是通过流的方式直接将日志收集到存储层，而 kafka 试讲日志缓存在 kafka 集群，待后期可以采集到存储层。Flume 采集中间停了，可以采用文件的方式记录之前的日志，而 kafka 是采用offset(偏移量) 的方式记录之前的日志。
Kafka 相关8-1）kafka 中怎样储存数据，哟及结构的，data.....目录下有多少个分区，每个分区的存储格式是什么样的？1、topic 是按照“主题名-分区”存储的 2、分区个数由配置文件决定 3、每个分区下最重要的两个文件是 0000000000.log 和 000000.index，0000000.log 以默认 1G 大小回滚。
Spark 相关9-1）mr 和 spark 区别，怎么理解 spark-rdd Mr 是文件方式的分布式计算框架，是将中间结果和最终结果记录在文件中，map 和 reduce的数据分发也是在文件中。
spark 是内存迭代式的计算框架，计算的中间结果可以缓存内存，也可以缓存硬盘，但是不是每一步计算都需要缓存的。
Spark-rdd 是一个数据的分区记录集合，是利用内存来计算的，spark之所以快是因为有内存的模式
9-2）简单描述spark的wordCount的执行过程scala> sc.textFile("/usr/local/words.txt") res0: org.apache.spark.rdd.RDD[String] = /usr/local/words.txt MapPartitionsRDD[1] at textFile at <console>:22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")) res2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at flatMap at <console>:22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)) res3: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[8] at map at <console>:22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_) res5: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[17] at reduceByKey at <console>:22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect res6: Array[(String, Int)] = Array((dageda,1), (xiaoli,1), (hellow,4), (xisdsd,1), (xiaozhang,1))
9-3）按照需求使用spark编写一下程序A、当前文件a.text的格式为，请统计每个单词出现的个数 A,b,c,d B,b,f,e A,a,c,f
sc.textFile(“/user/local/a.text”).flatMap(_.split(“,”)).map((_,1)).ReduceByKey(_+_).collect() 或： package cn.bigdata
import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD
object Demo {
/* a,b,c,d b,b,f,e a,a,c,f c,c,a,d * 计算第四列每个元素出现的个数 */ def main(args: Array[String]): Unit = { val conf: SparkConf = new SparkConf().setAppName("demo").setMaster("local") val sc: SparkContext = new SparkContext(conf) val data: RDD[String] = sc.textFile("f://demo.txt") //数据切分 val fourthData: RDD[(String, Int)] = data.map { x => val arr: Array[String] = x.split(",") val fourth: String = arr(3) (fourth, 1) } val result: RDD[(String, Int)] = fourthData.reduceByKey(_ + _); println(result.collect().toBuffer) } }
B、HDFS中有两个文件a.text与b.text,文件的格式为(ip,username),如：a.text,b.text a.text 127.0.0.1 xiaozhang 127.0.0.1 xiaoli 127.0.0.2 wangwu 127.0.0.3 lisi
B.text 127.0.0.4 lixiaolu 127.0.0.5 lisi
每个文件至少有1000万行，请用程序完成一下工作， 1）每个文件的个子的IP 2)出现在b.text而没有出现在a.text的IP 3)每个user出现的次数以及每个user对应的IP的个数
代码如下： 1）各个文件的ip数 package cn.bigdata
import java.util.concurrent.Executors
import org.apache.hadoop.conf.Configuration import org.apache.hadoop.fs.FileSystem import org.apache.hadoop.fs.LocatedFileStatus import org.apache.hadoop.fs.Path import org.apache.hadoop.fs.RemoteIterator import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD import org.apache.spark.rdd.RDD.rddToPairRDDFunctions
//各个文件的ip数 object Demo2 {
val cachedThreadPool = Executors.newCachedThreadPool()
def main(args: Array[String]): Unit = { val conf: SparkConf = new SparkConf().setAppName("demo2").setMaster("local") val sc: SparkContext = new SparkContext(conf) val hdpConf: Configuration = new Configuration val fs: FileSystem = FileSystem.get(hdpConf) val listFiles: RemoteIterator[LocatedFileStatus] = fs.listFiles(new Path("f://txt/2/"), true) while (listFiles.hasNext) { val fileStatus = listFiles.next val pathName = fileStatus.getPath.getName cachedThreadPool.execute(new Runnable() { override def run(): Unit = { println("=======================" + pathName) analyseData(pathName, sc) } }) } }
def analyseData(pathName: String, sc: SparkContext): Unit = { val data: RDD[String] = sc.textFile("f://txt/2/" + pathName) val dataArr: RDD[Array[String]] = data.map(_.split(" ")) val ipAndOne: RDD[(String, Int)] = dataArr.map(x => { val ip = x(0) (ip, 1) }) val counts: RDD[(String, Int)] = ipAndOne.reduceByKey(_ + _) val sortedSort: RDD[(String, Int)] = counts.sortBy(_._2, false) sortedSort.saveAsTextFile("f://txt/3/" + pathName) } }
2）出现在b.txt而没有出现在a.txt的ip package cn.bigdata
import java.util.concurrent.Executors
import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD
/* * 出现在b.txt而没有出现在a.txt的ip */ object Demo3 {
val cachedThreadPool = Executors.newCachedThreadPool()
def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("Demo3").setMaster("local") val sc = new SparkContext(conf) val data_a = sc.textFile("f://txt/2/a.txt") val data_b = sc.textFile("f://txt/2/b.txt") val splitArr_a = data_a.map(_.split(" ")) val ip_a: RDD[String] = splitArr_a.map(x => x(0)) val splitArr_b = data_b.map(_.split(" ")) val ip_b: RDD[String] = splitArr_b.map(x => x(0)) val subRdd: RDD[String] = ip_b.subtract(ip_a) subRdd.saveAsTextFile("f://txt/4/") } }
3） package cn.bigdata
import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD import scala.collection.mutable.Set
/* * 每个user出现的次数以及每个user对应的ip数 */ object Demo4 { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("Demo4").setMaster("local") val sc = new SparkContext(conf) val data: RDD[String] = sc.textFile("f://txt/5/") val lines = data.map(_.split(" ")) val userIpOne = lines.map(x => { val ip = x(0) val user = x(1) (user, (ip, 1)) })
val userListIpCount: RDD[(String, (Set[String], Int))] = userIpOne.combineByKey( x => (Set(x._1), x._2), (a: (Set[String], Int), b: (String, Int)) => { (a._1 + b._1, a._2 + b._2) }, (m: (Set[String], Int), n: (Set[String], Int)) => { (m._1 ++ n._1, m._2 + n._2) })
val result: RDD[String] = userListIpCount.map(x => { x._1 + ":userCount:" + x._2._2 + ",ipCount:" + x._2._1.size })
println(result.collect().toBuffer)
} }
Sqoop 相关10-1）sqoop在导入到MySql数据库是怎样保证数据重复，如果重复了该怎么办？？ 在导入时在语句的后面加上一下命令作为节点： --incremental append \ --check-column id \ --last-value 1208
Redis 相关10-1）redis保存磁盘的时间# Note: you can disable saving at all commenting all the "save" lines. # # It is also possible to remove all the previously configured save # points by adding a save directive with a single empty string argument # like in the following example: # # save ""
save 900 1 save 300 10 save 60 10000
| 
/2 
京ICP备2020039040号
简书网举报电话：021-34700000
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
显身卡
