spark学习一-------------------Spark算子最详细介绍

Spark学习–spark算子介绍

1.基本概念

	spark算子：为了提供方便的数据处理和计算，spark提供了一系列的算子来进行数据处理。一般算子分为action（执行算子）算子Transformation（懒执行）算子。

2.Transformation算子基本介绍

简介：transformation被称为懒执行算子，如果没有action算子，则代码是不会执行的，一般分为：

  1. map算子：map算子是将rdd中的数据一条一条传递给后面的函数，将函数的返回值构建成一个新的rdd。map算子是不会生成shuffle。后面的分区数等于map算子的分区数。
object Demo2Map {def main(args: Array[String]): Unit = {//saprk代码的入口val conf = new SparkConf()conf.setMaster("local").setAppName("map")val sc = new SparkContext(conf)/*** 构建rdd的方法* 1.读取文件* 2.基于scala的集合构建rdd ---- 用于测试**/val listRDD: RDD[Int]=  sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9),2)/*** map算子* 将rdd中的数据一条一条传递给后面的函数，将函数的返回值构建成一个新的rdd* map 不会产生shuffle，map之后的分区数等于map之前rdd的分区数**如果一个算子是一个新的rdd，那么这个算子就是转换算子。*/val mapRDD: RDD[Int] = listRDD.map{i => i * 2}//一次遍历整个分区的数据,将每一个分区的数据传递给后面的函数，函数需要返回一个迭代器，再构建一个新的rdd。val mapPartitionRDD: RDD[Int] = listRDD.mapPartitions {case iter: Iterator[Int] =>iter}val mapPartitionRDD2: RDD[Int] = listRDD.mapPartitions {case iter: Iterator[Int] =>val iterator: Iterator[Int] = iter.map(i => i * 2)//最后一行作为返回值iterator}mapPartitionRDD2.foreach(println)mapPartitionRDD.foreach(println)val mapPartitionsWithIndexRDD: RDD[Int] = listRDD.mapPartitionsWithIndex((index: Int, iter: Iterator[Int]) => {println(s"mapPartitionsWithIndexRDD的分区为:$index")iter})mapPartitionsWithIndexRDD.foreach(println)}
}
  1. flat算子:对RDD中的数据进行过滤，通过返回true保留数据，函数返回false过滤数据。转换算子，懒执行
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo4Filter {def main(args: Array[String]): Unit = {val conf = new SparkConf()conf.setMaster("local").setAppName("filter")val sc = new SparkContext(conf)val ListRDD: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 0), 2)/*** filter: 对RDD中的数据进行过滤，通过返回true保留数据，函数返回false过滤数据** filter: 转换算子，懒执行*/val filterRDD: RDD[Int] = ListRDD.filter(i => {i % 2 == 1})filterRDD.foreach(println)}
}
  1. flatmap算子：将rdd的数据一条一条传递给后面的函数，函数的返回值是一个集合，最后将这个集合拆分出来，构建成新的rdd
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDDobject Demo5Flatmap {def main(args: Array[String]): Unit = {val conf = new SparkConf()conf.setMaster("local").setAppName("filter")val sc = new SparkContext(conf)val listRDD: RDD[String] = sc.parallelize(List("java,spark,java","spark,scala,hadoop"))/*** 将rdd的数据一条一条传递给后面的函数，函数的返回值是一个集合，* 最后将这个集合拆分出来，构建成新的rdd*/val wordsRDD: RDD[String]  = listRDD.flatMap(line => {val arr: Array[String] = line.split(",")//返回值可以是一个数组，list，set map，必须是scala中的集合arr.toList})wordsRDD.foreach(println)}
}
  1. Sample算子:抽样,withReplacement:是否放回。fraction：抽样比例。
package com.zjlimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo6Sample {def main(args: Array[String]): Unit = {val conf = new SparkConf()conf.setMaster("local").setAppName("Demo6Sample")val sc = new SparkContext(conf)val listRDD: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 45, 6, 7, 8, 9, 0))val studentRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\data\\students.txt")/*** sample:抽样。* withReplacement:是否放回。* fraction：抽样比例。*/val sampleRDD: RDD[String] = {studentRDD.sample(false, 0.1)}}
}
  1. groupByKey算子:按照key进行分组，必须是kv格式的才能用，将同一个key的value放在迭代器中。相对比groupBy，指定一个分组的罗列，返回的RDD的value包含所有的列。shuffle过程中需要传输的数据量groupByKey要多，性能差一点
package com.zjlimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo8GroupByKey {def main(args: Array[String]): Unit = {val conf: SparkConf = {new SparkConf()}conf.setMaster("local").setAppName("groupByKey")val sc: SparkContext = new SparkContext(conf)val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")val wordsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))val mapWordRDD: RDD[(String, Int)] = wordsRDD.map(word => (word, 1))/*** 按照key进行分组，必须是kv格式的才能用，将同一个key的value放在迭代器中*/val groupByKeyRDD: RDD[(String, Iterable[Int])] = mapWordRDD.groupByKey()groupByKeyRDD.map({case(words:String, ints:Iterable[Int]) =>ints.sum})groupByKeyRDD.foreach(println)/*** groupBy:指定一个分组的罗列，返回的RDD的value包含所有的列* shuffle过程中需要传输的数据量groupByKey要多，性能差一点*/val groupByRDD: RDD[(String, Iterable[(String, Int)])] = mapWordRDD.groupBy(kv => kv._1)groupByRDD.foreach(println)}}
  1. reduceByKey算子：按照key进行聚合计算，会在map端进行预聚合，只能做简单的聚合计算。
package com.zjlimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo9ReduceByKey {def main(args: Array[String]): Unit = {val conf = new SparkConf().setAppName("reduceByKey").setMaster("local")val sc: SparkContext = new SparkContext(conf)val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")val wordsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))val mapRDD: RDD[(String, Int)] = wordsRDD.map(i => (i, 1))/*** reduceByKey：按照key进行聚合计算，会在map端进行预聚合* 只能做简单的聚合计算*///统计单词数量val reducrByKeyRDD: RDD[(String, Int)] = mapRDD.reduceByKey((x: Int, y: Int) => x + y)reducrByKeyRDD.foreach(println)}}
  1. union算子:合并两个rdd，两个rdd的数据类型要一致，但是只是代码层面的合并，底层没有合并。这个属于并集，如果取交集可以使用intersection算子。
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo10Union {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("union")val sc: SparkContext = new SparkContext(conf)val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9))val rdd2: RDD[Int] = sc.parallelize(List( 4, 5, 6, 7, 8, 9,10))/*** union:合并两个rdd，两个rdd的数据类型要一致* union只是代码层面的合并，底层没有合并* union不会产生shuffle*/val unionRDD: RDD[Int] = rdd1.union(rdd2)unionRDD.foreach(println)/*** distinctRDD去重，会产生shuffle* distinct:会先在map端局部去重，再到reduce端全局去重*/val distinctRDD: RDD[Int] = unionRDD.distinct()distinctRDD.foreach(println)/*** 所有会产生shuffle的算子都可以指定分区数。反过来也成立。*//*** intersection:取两个rdd的交集*/val interRDD: RDD[Int] = rdd1.intersection(rdd2)interRDD.foreach(println)}
}
  1. join算子:inner join:通过rdd的key进行关联，必须是kv格式的rdd；left join:以左表为主，如果右表没有数据，就会补一个null；right join和left join相反；full join:两边都可能没有关联上，如果是没关联上，补null
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo11Join {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("join")val sc: SparkContext = new SparkContext(conf)val nameRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "张三"), ("002", "李四"), ("003", "王五")))val ageRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "23"), ("002", "35"), ("004", "19")))/*** inner join:通过rdd的key进行关联，必须是kv格式的rdd*/
//      //关联之后处理数据方法1--下划线方法val innerJoinRDD: RDD[(String, (String, String))] = nameRDD.join(ageRDD)
//    innerJoinRDD.map(i=>{
//      val id: String = i._1
//      val name: String = i._2._1
//      val age: String = i._2._1
//    })//关联之后处理数据2--模式匹配val rdd1: RDD[(String, String, Int)] = innerJoinRDD.map(i => {case (id: String, (name: String, age: String)) =>(id, name, age)})rdd1.foreach(println)/*** left join:以左表为主，如果右表没有数据，就会补一个null* 数据中右表没有003，所有会补一个null* Option[String]:没有值就是None* right join:和left join相反*/val leftRDD: RDD[(String, (String, Option[Int]))] = nameRDD.leftOuterJoin(ageRDD)leftRDD.foreach(println)//整理数据val rdd2: RDD[(String, String, Int)] = leftRDD.map({//匹配关联成功的数据case (id: String, (name: String, Some(age))) =>(id, name, age)//匹配未关联成功的数据case (id: String, (name: String, None)) =>(id, name, 0)})rdd2.foreach(println)/*** full join:两边都可能没有关联上，如果是没关联上，补null*/val fullRDD: RDD[(String, (Option[String], Option[Int]))] = nameRDD.fullOuterJoin(ageRDD)//整理数据val rdd3: RDD[(String, String, Int)] = fullRDD.map {case (id: String, (Some(name), Some(age))) =>(id, name, age)case (id: String, (None, Some(age))) =>(id, 0, age)case (id: String, (Some(name), None)) =>(id, name, 0)case (id: String, (None, None)) =>(id, 0, 0)}}}
  1. mapValue算子:只对value进行处理，key不变
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo12MapValues {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("mapValues")val sc: SparkContext = new SparkContext()//使用mapval ageRDD: RDD[(String, Int)] = sc.makeRDD(List(("001", 23), ("002", 35), ("004", 19)))val linesRDD: RDD[(String, Int)] = ageRDD.map {case (id: String, age: Int) =>(id, age + 1)}/***mapValue:只对value进行处理，key不变*///使用mapValueval mapValuesRDD: RDD[(String, Int)] = ageRDD.mapValues(v => v + 1)}}
  1. sort算子:指定一个排序的列，默认是升序,ascending是控制排序方式。
package com.zjlimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo13Sort {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("sort")val sc: SparkContext = new SparkContext(conf)val studentsRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\data\\students.txt")/*** sortBy:指定一个排序的列，默认是升序* ascending：控制排序方式*/val sortByRDD: RDD[String] = studentsRDD.sortBy(student => {val age: Int = student.split(",")(2).toIntage},false)val ageRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "23"), ("002", "35"), ("004", "19")))val dataRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6))val kvRDD: RDD[(Int, Int)] = dataRDD.map(i => (i, 1))kvRDD.foreach(println)/*** 通过key排序，默认升序*/val sortByKeyRDD: RDD[(Int, Int)] = kvRDD.sortByKey()sortByKeyRDD.foreach(println)}}
  1. .AGG算子
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo14Agg {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("Agg")val sc: SparkContext = new SparkContext(conf)val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")val wordsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))val mapRDD: RDD[(String, Int)] = wordsRDD.map(i => (i, 1))/*** reduceByKey:在map端进行预聚合，聚合函数会应用在map端和reduce端（聚合函数会应用在分区内的聚合和分区间的聚合）*/val reduceByKeyRDD: RDD[(String, Int)] = mapRDD.reduceByKey((x, y) => x + y)val aggRDD: RDD[(String, Int)] = mapRDD.aggregateByKey(0)( //初始值(u: Int, i: Int) => u + i, //分区键的聚合函数（map端的聚合函数）(u1: Int, u2: Int) => u1 + u2 //分区间的聚合（reduce的聚合函数）)aggRDD.foreach(println)}}
  1. 求平均年龄案例：使用aggregateByKey
package com.zjlimport org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDDobject Demo15AggAvgAge {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("Agg")val sc: SparkContext = new SparkContext(conf)val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\students.txt")/*** 计算班级的平均年龄*///val studentsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))val classAndAge: RDD[(String,Double)] = linesRDD.map(student => {val split: Array[String] = student.split(",")( split(4),split(2).toDouble)})classAndAge.foreach(println)/*** 使用groupbykey*/val groupByKeyRDD: RDD[(String, Iterable[Double])] = classAndAge.groupByKey()val avgAgeRDD: RDD[(String,Double)] = groupByKeyRDD.map({case (clazz: String, age: Iterable[Double]) =>val avgAge: Double = age.sum / age.size(clazz, avgAge)})/*** 大数据计算中，最耗时间的就是shuffle，shuffle过程中数据是落地到磁盘中的。* aggregateByKey:会在map端做预聚合，性能高* 1.初始值可以有多个* 2.map端的聚合函数* 3.reduce端的聚合函数*/val avgAge: RDD[(String, (Double, Int))] = classAndAge.aggregateByKey((0.0, 0))((u:(Double,Int), age:Double) => (u._1 + age, u._2 + 1),//map端的聚合函数(u1:(Double,Int), u2:(Double,Int)) => (u1._1 + u2._1, u1._2 + u2._2)//reduce端的聚合函数)avgAge.foreach(println)//计算平均年龄val avgAgeMapRDD: RDD[(String, Double)] = avgAge.map({case (clazz: String, (totalAge: Double, sumPerpon: Int)) =>(clazz, totalAge / sumPerpon)})avgAgeMapRDD.foreach(println)while(true){}}
}
  1. cartesian算子：笛卡尔积，很少使用。
package com.zjlimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo16Cartesian {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("Agg")val sc: SparkContext = new SparkContext(conf)val nameRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "张三"), ("002", "李四"), ("003", "王五")))val ageRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "23"), ("002", "35"), ("004", "19")))/*** 笛卡尔积*/val cartesianRDD: RDD[((String, String), (String, String))] = nameRDD.cartesian(ageRDD)}}
  1. reduce算子：全局聚合是个action算子。
package com.zjlimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Demo17Reduce {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("Agg")val sc: SparkContext = new SparkContext(conf)val LinesRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 0))/*** sum:求和，只能用于int或者double或者null类型的求和，action算子*/val sumRDD: Double = LinesRDD.sum()/*** reduce:全局聚合，action算子* reduceByKey:通过key进行聚合*/val reducrRDD: Int = LinesRDD.reduce((x, y) => (x + y))}}
  1. take算子：取top值，是一个action算子。如果是取第一条数据，使用first。
package com.zjlimport org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDDobject Demo18Take {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("Agg")val sc: SparkContext = new SparkContext(conf)val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")/*** take:取top，是一个action算子*/val top100: Array[String] = linesRDD.take(100)//获取第一条数据val first: String = linesRDD.first()}}

17.案例 ：统计总分大于年级平均分的学生

package com.zjlimport org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDDobject Demo19Student1 {def main(args: Array[String]): Unit = {val conf: SparkConf = new SparkConf()conf.setMaster("local").setAppName("Agg")val sc: SparkContext = new SparkContext(conf)val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\score.txt")/*** 统计总分大于年级平均分的学生*///1、计算学生的总分val total: RDD[(String, Double)] = linesRDD.map(student => {val splitRDD: Array[String] = student.split(",")(splitRDD(0), splitRDD(2).toDouble)})total.foreach(println)val totalScore: RDD[(String, Double)] = total.reduceByKey((x, y) => (x + y))totalScore.foreach(println)val totalAllRDD: RDD[Double] = totalScore.map(kv => kv._2)val avgScore: Double = totalAllRDD.sum() / totalAllRDD.count()//取出总分大于平均分val endRDD: RDD[(String, Double)] = totalScore.filter {case (id: String, score: Double) =>score > avgScore}}}

3.action算子基本介绍

	action算子：在Spark中，action 算子是一类触发 Spark 作业执行的操作。action 算子会导致计算结果被返回到驱动程序，或者将计算结果保存到外部存储系统。与 transformation 算子不同，action 算子会触发 Spark 作业的执行，而不仅仅是定义计算逻辑。
  1. foreach：遍历rdd
  2. count：统计rdd的行数
  3. sum：求和
  4. collect：将rdd转换成scala的集合
object Demo7Action {
//spark代码的入口def main(args: Array[String]): Unit = {/*** spark任务的层级关系：* application ---> job ---> stages --->task*/val conf: SparkConf = {new SparkConf()}conf.setMaster("local").setAppName("action")val sc: SparkContext = new SparkContext(conf)/*** action 算子  --触发任务执行，每一个action算子都会触发一个job任务* 1、foreach：遍历rdd* 2、saveAsTextFile：保存数据* 3、count：统计rdd的行数* 4、sum：求和* 5、collect：将rdd转换成scala的集合*/val studentRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\students.txt")//一次遍历一个数据studentRDD.foreach(println)//一次遍历一个分区studentRDD.foreachPartition((iter:Iterator[String]) => println(iter.toList))//保存数据/*** saveAsTextFile：将数据保存到hdfs中* 1、输出的目录不能存在* 2、rdd一个分区对应一个文件*/studentRDD.saveAsTextFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data")//统计行数val count: Long = studentRDD.count()println(s"studentRDD的行数：$count")//将rdd的数据拉取到内存中，如果数据量很大会出现内存溢出val studentArr: Array[String] = studentRDD.collect()}}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/175806.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

鞋厂ERP怎么样?工厂要如何选项契合的ERP

鞋厂ERP怎么样?工厂要如何选项契合的ERP

鞋帽这类商品是我们的生活必需品，存在款式多、尺码多、用料复杂、营销渠道多、销售策略和价格策略灵活等情况，伴随电商等行业的发展，鞋帽行业的管理模式也在发生变化。 鞋厂规模的不同，遇到的管理问题各异，而如何解决…
阅读更多...
十分钟搭建VScode C/C++运行环境

十分钟搭建VScode C/C++运行环境

一、下载配置vscode 1.下载安装VScode 地址：https://code.visualstudio.com/download 下载后，运行安装程序 (VSCodeUserSetup-{version}.exe)。这只需要一分钟。安装程序会将 Visual Studio Code 添加到环境变量中%，可以使用CMD键入“code”…
阅读更多...
Dockerfile语法和指令

Dockerfile语法和指令

简介 Dockerfile是由一系列指令和参数构成的脚本，一个Dockerfile里面包含了构建整个镜像的完整命令。通过docker build执行Dockerfile中一系列指令自动构建镜像。 常用指令 FROM：基础镜像，FROM领了必须是Dockerfile的首个命令。 LABEL&…
阅读更多...
2023-2024-1-高级语言程序设计-字符数组

2023-2024-1-高级语言程序设计-字符数组

7-1 凯撒密码 为了防止信息被别人轻易窃取，需要把电码明文通过加密方式变换成为密文。输入一个以回车符为结束标志的字符串（少于80个字符），再输入一个整数offset，用凯撒密码将其加密后输出。恺撒密码是一种简单的替换…
阅读更多...
性价比高的照明品牌，考研考公必备护眼台灯推荐

性价比高的照明品牌，考研考公必备护眼台灯推荐

据国家卫生健康委员会发布的调查数据显示,我国青少年儿童总体近视率为52.7%、高度近视人口超3000万。儿童是民族的未来和希望,青少年儿童眼健康问题更是牵动着每一个人的神经。遗传、双眼视功能不正常、用眼负荷过重等因素都是造成青少年近视的原因,其中,大量的电子产品侵入以及…
阅读更多...
Flask Session 登录认证模块

Flask Session 登录认证模块

Flask 框架提供了强大的 Session 模块组件，为 Web 应用实现用户注册与登录系统提供了方便的机制。结合 Flask-WTF 表单组件，我们能够轻松地设计出用户友好且具备美观界面的注册和登录页面，使这一功能能够直接应用到我们的项目中。本文将深入探…
阅读更多...
动态网页从数据库取信息，然后展示。

动态网页从数据库取信息，然后展示。

把数据库的驱动放在bin目录下。 通过servlet 读取数据库的内容，生成session,然后跨页面传给展示页。 package src;import java.io.IOException; import java.io.PrintWriter; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSe…
阅读更多...
大数据-之LibrA数据库系统告警处理（ALM-37008 MPPDB服务不可用）

大数据-之LibrA数据库系统告警处理（ALM-37008 MPPDB服务不可用）

告警解释 告警模块每30秒周期性检测MPPDB服务健康状态，当检测到MPPDB健康状态为“故障”时产生告警。 当检测到MPPDB健康状态为“良好”时告警恢复。 告警属性 告警ID 告警级别 可自动清除 37008 致命 是 告警参数 参数名称 参数含义 ServiceName 产生…
阅读更多...
HJ92 在字符串中找出连续最长的数字串

HJ92 在字符串中找出连续最长的数字串

题目： HJ92 在字符串中找出连续最长的数字串 题解： 找到第一个数字从第一个数字开始往后遍历，每走一步判断当前是否为数字，是数字就累加cnt如果当前位置不是数字，证明连续数字串已经断开，此时需要记录最…
阅读更多...
ROC及曲线面积汇总学习

ROC及曲线面积汇总学习

目录 ROC基础 生成模拟数据 率的计算 R语言计算测试 ROCR： pROC ROC绘制 单个ROC 两个ROC Logistic回归的ROC曲线 timeROC ROC基础 ROC曲线的横坐标是假阳性率，纵坐标是真阳性率，需要的结果是这个率表示疾病阳性的率（…
阅读更多...
QT基础开发笔记

QT基础开发笔记

用VS 写QT ，设置exe图标的方法： 选定工程--》右键--》添加---》资源--》 QString 字符串用法总结说明 Qt QString 增、删、改、查、格式化等常用方法总结_qstring 格式化-CSDN博客 总结来说： QString 的 remove有两种用法，&am…
阅读更多...
如何成为一名前端组长？

如何成为一名前端组长？

我认为要管理好前端团队： 本质上：让团队少走弯路，并引领团队走在正确的道路上。 理念上：让团队高效工作、快乐工作。 实施上：要想尽办法给团队、给成员赋能。 个人角度： 角色转变，开发人员 -&g…
阅读更多...
【JavaSE】:接口（一）

【JavaSE】:接口（一）

接口 一.什么是接口二.语法规则三.接口的使用四.实现多个接口五.接口的继承 final关键字 inal修饰的变量，这个变量是不可修改的。final修饰后的方法，禁止子类继承的时候重写方法。final修饰后的类，是禁止被继承的。 super关键字 如果父类(超类…
阅读更多...
Spring Boot 实现 PDF 水印，实战来了！

Spring Boot 实现 PDF 水印，实战来了！

简介 PDF（Portable Document Format，便携式文档格式）是一种流行的文件格式，它可以在多个操作系统和应用程序中进行查看和打印。在某些情况下，我们需要对 PDF 文件添加水印，以使其更具有辨识度或者保护其版…
阅读更多...
JAVA 整合 AWS S3(Amazon Simple Storage Service)文件上传,分片上传,删除,下载

JAVA 整合 AWS S3(Amazon Simple Storage Service)文件上传,分片上传,删除,下载

依赖 因为aws需要发送请求上传、下载等api&#xff0c;所以需要加上httpclient相关的依赖 <dependency><groupId>com.amazonaws</groupId><artifactId>aws-java-sdk-s3</artifactId><version>1.11.628</version> </dependency&…
阅读更多...
Docker Nginx容器部署vue项目

Docker Nginx容器部署vue项目

Docker Nginx容器部署vue项目 文章目录 Docker Nginx容器部署vue项目1. 前提2. 下载nginx镜像3. 编写nginx.conf配置文件4. 编写构建命令5. vue项目上传 1. 前提 Docker服务已部署 2. 下载nginx镜像 首先查看有没有nginx镜像 docker images没有的情况下再进行下载 docker …
阅读更多...
Proto3语法详解02

Proto3语法详解02

目录 1.默认值 2.更新消息 2.1更新规则 2.2保留字段reserved 2.2.1创建通讯录3.0版本---验证错误删除字段造成的数据损坏 2.3未知字段 2.3.1未知字段从哪获取 3.3.2升级通讯录3.1版本--验证未知字段 2.4前后兼容性 3.选项option 3.1选项分类 3.2常用选项列举 1.默认值…
阅读更多...
Python之基础语法和六大数据类型

Python之基础语法和六大数据类型

学习的最大理由是想摆脱平庸&#xff0c;早一天就多一份人生的精彩&#xff1b;迟一天就多一天平庸的困扰。各位小伙伴&#xff0c;如果您&#xff1a; 想系统/深入学习某技术知识点… 一个人摸索学习很难坚持&#xff0c;想组团高效学习… 想写博客但无从下手&#xff0c;急需…
阅读更多...
907. 子数组的最小值之和 --力扣 --JAVA

907. 子数组的最小值之和 --力扣 --JAVA

题目 给定一个整数数组 arr&#xff0c;找到 min(b) 的总和&#xff0c;其中 b 的范围为 arr 的每个&#xff08;连续&#xff09;子数组。 由于答案可能很大&#xff0c;因此 返回答案模 10^9 7 。 解题思路 找到以当前值为最小值所能组成的子数组&#xff1b;若存在两个相同…
阅读更多...
app分发平台的费用详细过程

app分发平台的费用详细过程

在APP分发平台上进行应用商店收费时&#xff0c;通常包括以下费用&#xff1a; 应用审核费用&#xff1a;为了确保应用的质量和用户体验&#xff0c;应用商店会对上传的应用进行审核&#xff0c;审核费用通常是一次性的。应用推广费用&#xff1a;应用商店为了帮助开发者和发布…
阅读更多...
最新文章

Copyright @ 2022~2023