<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[reddy_Hu的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/reddy_Hu</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; reddy_Hu]]></copyright><item><title><![CDATA[数据仓库笔记]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/120158007</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/120158007</guid><author>reddy_Hu</author><pubDate>Tue, 07 Sep 2021 17:25:28 +0800</pubDate><description><![CDATA[1.1数据获取与数据分析的区别

操作型数据库保存数据，对操作性系统进行优化的目的是使其能够更快地处理事务，不必维护历史数据，只需修改数据反映最新状态比如签订新客户的原因，了解客户在抱怨什么等
DW/BI系统使用数据，维护批次数据，通过各批次的数据对比，去分析比如签订新客户的原因，了解客户在抱怨什么等

1.2数仓的目标

数仓要方便的存取信息：数据需要有直观性，数据结构与标识需要针对开发人员和业务人员都能理解，并能尽快查询出结果
一致形式展现信息：数仓中的公共标识和定义，可以再不同数据源公用，两个关于性.]]></description><category></category></item><item><title><![CDATA[日常用到的spark调优]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/110632125</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/110632125</guid><author>reddy_Hu</author><pubDate>Fri, 04 Dec 2020 11:45:38 +0800</pubDate><description><![CDATA[日常用到的spark调优

1.如果使用spark读取mysql中的表格写进数仓中，可以先将限制条件或者整个sql先写进jdbc连接参数中。如果是将mysql整个表读入内存中再建立临时表，如果mysql的表过大，反而会占用更多内存，所以可以提前先将结果的数据读进来直接write进数仓中。


val callmysql = s" select '会议' as module,'正常通话率' as metrics_type,'ads_voip_sample' as original_table,avg(metr]]></description><category></category></item><item><title><![CDATA[spark-Action算子]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107922710</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107922710</guid><author>reddy_Hu</author><pubDate>Mon, 10 Aug 2020 22:39:35 +0800</pubDate><description><![CDATA[count


Return the number of elements in the RDD.

这个算子就是来算一下所有分区有多少条数据,因为底层调用了runJob方法,所以是一个Action方法


package com.doit.spark.day05

import org.apache.spark.{SparkConf, SparkContext}

object Count {
  def main(args: Array[String]): Unit = {
    val conf =]]></description><category></category></item><item><title><![CDATA[Spark-算子之shuffle类]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107898668</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107898668</guid><author>reddy_Hu</author><pubDate>Sun, 09 Aug 2020 21:24:51 +0800</pubDate><description><![CDATA[groupByKey

这个方法生成新的stage,并且源代码是写在PairRDDFunctions中,不是调用新建一个MapPartitionsRDD了,这个方法是map端和reduce端得交互,map端处理完数据会先将数据ShuffleWrite溢写到map端得磁盘,然后reduce端通过网络进行拉取ShuffleRead过来

之于为什么OutPut会变少,是因为输出的文件 key都合并了 没有之前那么多key了 但是value还是之前那么多

还有一个问题值得讨论,就是怎么定的分区规则,其实如...]]></description><category></category></item><item><title><![CDATA[Spark之算子及解析]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107885756</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107885756</guid><author>reddy_Hu</author><pubDate>Sun, 09 Aug 2020 16:36:24 +0800</pubDate><description><![CDATA[两个创建RDD的方法是完全一样的


val conf = new SparkConf().setAppName("MapPartitionsDemo").setMaster("local[*]")

    val sc = new SparkContext(conf)
    //创建RDD
    val rdd1 = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), 3)
    //makeRDD的源码
    /** Distribute a loc]]></description><category></category></item><item><title><![CDATA[spark--RDD]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107837856</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107837856</guid><author>reddy_Hu</author><pubDate>Thu, 06 Aug 2020 14:31:22 +0800</pubDate><description><![CDATA[RDD是一个弹性、可复原的分布式的数据集

RDD中装的数据是数据的描述信息,描述了从哪读数据,调用什么方法,传入什么函数,一级依赖关系等

RDD特点:

1.有一些连续的分区:分区编号从0开始,分区数量决定了Task的并行度(每一个分区中都有一个task,一个executor中可以有很多个tsak同时运行)

2.有一个函数作用在每个输入切片上(每一个要处理的文件从hdfs中传输过来足够大的时候是会出现很多物理切片的,都遵循同一个RDD或一系列依赖的RDD中储存的逻辑来进行分析)

3.RDD和RDD.]]></description><category></category></item><item><title><![CDATA[spark-WordCount案例]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107825663</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107825663</guid><author>reddy_Hu</author><pubDate>Wed, 05 Aug 2020 21:44:54 +0800</pubDate><description><![CDATA[Scala程序


package com.doit.spark.day01

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object WordCount {
  def main(args: Array[String]): Unit = {
    //创建SparkContext
    val conf = new SparkConf().setAppName("WordCoun]]></description><category></category></item><item><title><![CDATA[scala之逆变、协变]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107739253</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107739253</guid><author>reddy_Hu</author><pubDate>Sun, 02 Aug 2020 00:24:04 +0800</pubDate><description><![CDATA[//负号:逆变.方法的输入,用-修饰,是scala中的一种泛型,

//正号:协变.方法的输出,用+修饰

是scala中的一种泛型

在trait中定义的方法,参数列表为逆变,方法返回的数据类型为协变


package com.doit.scala.yinshizhuanhuan
//负号:逆变.方法的输入
//正号:协变.方法的输出
trait Function1[-A,+B] {
 def test(a:A):B
}
object Func1Test{
  def main(args: Array.]]></description><category></category></item><item><title><![CDATA[scala之泛型]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107736253</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107736253</guid><author>reddy_Hu</author><pubDate>Sun, 02 Aug 2020 00:16:01 +0800</pubDate><description><![CDATA[视图界定 &lt;%

&lt;% 有隐式转换


package com.doit.scala.yinshizhuanhuan
/* [T &lt;: Comparable[T]] 上界  upper bound     java: &lt;T extends Comparable&gt;
* [T &gt;: Comparable[T]] 下界  lower bound     java: &lt;T super Comparable&gt;
* [T &lt;% Comparable] 视...]]></description><category></category></item><item><title><![CDATA[scala之隐式转换]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107728636</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107728636</guid><author>reddy_Hu</author><pubDate>Sat, 01 Aug 2020 11:52:59 +0800</pubDate><description><![CDATA[科里化函数


package com.doit.scala.day05

object KeliDemo {
  def k(x: Int)(y:Int): Int ={
   println("aaa")
    x+y
  }
  def k2(x: Int)(implicit  y: Int = 10) = {x+y}
  def k3(x: Int = 10)(y: Int) = {x+y}
  def main(args: Array[String]): Unit = {
    val f  ]]></description><category></category></item><item><title><![CDATA[akka 代码实现]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107719208</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107719208</guid><author>reddy_Hu</author><pubDate>Fri, 31 Jul 2020 18:27:22 +0800</pubDate><description><![CDATA[整体的代码逻辑

1.Worker开机之后会连接并向Master注册信息(也就是发送自己的信息)

2.Master接收到信息之后,会将worker的信息存到专门存储workers信息的hashmap中,再返回给worker一个连接成功的信息

3.worker接受到注册成功的信息之后开始向master定时输出心跳信息,但是又不能直接定时给master发送心跳,只能定时给自己发送信息,

每次接受到这个信息之后,自己就会给master发送心跳信息(带有worker的id信息)

4.master会就收到带.]]></description><category></category></item><item><title><![CDATA[akka简介]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107686831</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107686831</guid><author>reddy_Hu</author><pubDate>Thu, 30 Jul 2020 11:43:57 +0800</pubDate><description><![CDATA[akka可以比作学生和老师

1,学生和老师都是Actor,Actor是用来收发消息,处理逻辑

2.教学总监和班主任:ActorSystem,它是用来创建Actor的,并且监控和管理他创建的Actor

3.ActorSystem是单例的,一个进程中只要有一个即可

4.Actor是多例的,可以创建多个实例

5.Actor编程模式就通过发送消息来并发实现的



Akka就是基于Actor编程迷行实现的,可以是单机,也可以是分布式的
...]]></description><category></category></item><item><title><![CDATA[scala之模式匹配]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107677174</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107677174</guid><author>reddy_Hu</author><pubDate>Wed, 29 Jul 2020 22:55:07 +0800</pubDate><description><![CDATA[匹配字符串


import scala.util.Random


object CaseDemo1 {
  val arr = Array("YoshizawaAkiho", "YuiHatano", "AoiSola")
  val name: String = arr(Random.nextInt(arr.length))
  println(s"name is:$name")
  name match {
    case "YoshizawaAkiho" =&gt; println("吉泽")
]]></description><category></category></item><item><title><![CDATA[scala之面向对象]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107673643</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107673643</guid><author>reddy_Hu</author><pubDate>Wed, 29 Jul 2020 21:46:00 +0800</pubDate><description><![CDATA[package com.doit.scala.day03

class User {
  val id = 100010
  val name = "tom"
  //如果是var修饰的,就相当于自带了gettersetter方法
  var age = 18
  //被private修饰的 只能在此文件夹中使用
  private var money: Double = 1000
  //被private[this]修饰的只能在此class中使用
  private[this] var password.]]></description><category></category></item><item><title><![CDATA[scala基础语法(三)]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107640724</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107640724</guid><author>reddy_Hu</author><pubDate>Tue, 28 Jul 2020 17:16:31 +0800</pubDate><description><![CDATA[几种集合:

Array,ArrayBuffer\List,ListBuffer\Set,HashSet\Map,HashMap

Array


package com.doit.scala.Break01

object ArrayDemo1 {
  def main(args: Array[String]): Unit = {
    //定义一个通用数组 没有执行数据类型,可以存储任意类型
    val arr1 = Array("Jim", 12, 12.22, true)
    //指定泛型]]></description><category></category></item><item><title><![CDATA[scala-WordCount 简单项目练习]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107617593</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107617593</guid><author>reddy_Hu</author><pubDate>Mon, 27 Jul 2020 17:59:30 +0800</pubDate><description><![CDATA[package com.doit.scala.day02
import scala.collection.immutable

object WordCount {
  def main(args: Array[String]): Unit = {
    val lines: immutable.Seq[String] = List("spark hadoop flink spark", "hadoop flink spark hadoop", "spark hadoop flink spark")
 .]]></description><category></category></item><item><title><![CDATA[scala基础语法(二)]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107607335</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107607335</guid><author>reddy_Hu</author><pubDate>Mon, 27 Jul 2020 11:06:16 +0800</pubDate><description><![CDATA[九.数组操作


 val arr = Array(Array(1, 2, 5, 4), Array(3, 6, 7, 8), Array(9, 10))
    //flatten只能一次压一层
    val flatten = arr.flatten
    println(flatten.toBuffer)
    val lines = Array("spark hadoop flink spark", "spark spark flink", "spark flink")
    val lin]]></description><category></category></item><item><title><![CDATA[scala基础语法]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107596936</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107596936</guid><author>reddy_Hu</author><pubDate>Sun, 26 Jul 2020 18:06:22 +0800</pubDate><description><![CDATA[一.声明变量


object VaDemo {
  def main(args: Array[String]): Unit = {
    val a = 1
    println(a)
    val b = "hello"
    println(b)
    val str:String = "world"
    println(str)
  }
}


二.常用类型

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型]]></description><category></category></item><item><title><![CDATA[Hive的DDL语言(一)]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107474836</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107474836</guid><author>reddy_Hu</author><pubDate>Mon, 20 Jul 2020 22:10:56 +0800</pubDate><description><![CDATA[显示系统所有数据库


show databases;
+----------------+
| database_name  |
+----------------+
| db_doit        |
| default        |
| uu             |
+----------------+
3 rows selected (0.108 seconds)

模糊显示数据库


hive&gt; show databases like "db*";
OK
db_doit
T...]]></description><category></category></item><item><title><![CDATA[Hive入门]]></title><link>https://blog.youkuaiyun.com/reddy_Hu/article/details/107471937</link><guid>https://blog.youkuaiyun.com/reddy_Hu/article/details/107471937</guid><author>reddy_Hu</author><pubDate>Mon, 20 Jul 2020 21:25:57 +0800</pubDate><description><![CDATA[1.什么是hive?

  要明确的一点是,Hive并不是数据库,而是用于解决海量结构化日志的数据统计(海量的结构化数据的运算分析)的工具。

 

1）Hive处理的数据存储在HDFS

2）Hive分析数据底层的实现是MapReduce / spark(分布式运算框架)

3）执行程序运行在Yarn上

2.Hive的优缺点

  1)优点

操作接口采用类SQL语法，提供快速开发的能力（简单、容易上手）。
	避免了去写MapReduce，减少开发人员的学习成本。
	Hive的执行延迟比较...]]></description><category></category></item></channel></rss>