大数据学习之sparkstreaming

SparkStreaming

idea中初步实现

Spark core: SparkContext 核心数据结构：RDD

Spark sql: SparkSession 核心数据结构：DataFrame

Spark streaming: StreamingContext 核心数据结构：DStream(底层封装了RDD)，遍历出其中的RDD即可进行sparkCore处理

Spark Streaming程序理论上是一旦启动，就不会停止，除非报错，人为停止，停电等其他突然场景导致程序终止

监控一个端口号中的数据，手动向端口号中打数据

master虚拟机上启动命令：nc -lk 12345，

ps aux | grep ‘nc -lk 10086’ ， 找出该进程的端口号，kill -9 xxxx 来终止进程

若使用指令开启端口，**退出时应选择 ctrl+c（退出并终止进程），**使用ctrl+z只能退出界面，不能关闭该端口

1、案例一：
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Duration, Durations, StreamingContext}object Demo1WordCount {def main(args: Array[String]): Unit = {val conf = new SparkConf()conf.setMaster("local[2]") // 给定核数conf.setAppName("spark Streaming 单词统计")val sparkContext = new SparkContext(conf)/*** 创建Spark Streaming的运行环境，和前两个模块是不一样的* Spark Streaming是依赖于Spark core的环境的* this(sparkContext: SparkContext, batchDuration: Duration)* Spark Streaming处理之前，是有一个接收数据的过程* batchDuration，表示接收多少时间段内的数据*/val streamingContext = new StreamingContext(sparkContext, Durations.seconds(5))/*** Spark Streaming程序理论上是一旦启动，就不会停止，除非报错，人为停止，停电等其他突然场景导致程序终止* 监控一个端口号中的数据，手动向端口号中打数据* master虚拟机上启动命令：nc -lk 12345*/val rids: ReceiverInputDStream[String] = streamingContext.socketTextStream("master", 12345)//hello worldval wordsDS: DStream[String] = rids.flatMap(_.split(" "))val kvDS: DStream[(String, Int)] = wordsDS.map((_, 1))val resDS: DStream[(String, Int)] = kvDS.reduceByKey(_ + _)//    val resDS: DStream[(String, Int)] = rids.flatMap(_.split(" "))
//      .map((_, 1))
//      .reduceByKey(_ + _)println("--------------------------------------")resDS.print()println("--------------------------------------")/*** sparkStreaming启动的方式和前两个模块启动方式不一样*/streamingContext.start()// 等待，根据上面设置的等待5秒钟（接收数据的时间）streamingContext.awaitTermination()// TODO：代表每个批次的开始和结束，并不是真的结束了streamingContext.stop()}
}

案例一的执行结果：

无法对依次输入的所有相同单词进行汇总

在这里插入图片描述
在这里插入图片描述

2、案例二：

实现对依次输入的所有相同单词进行汇总

需要使用有状态的算子来处理当前批次数据与历史数据的关系

updateStateByKey[S: ClassTag](updateFunc: (Seq[V], Option[S]) => Option[S]): DStream[(K, S)]

Seq: 序列，表示历史键对应的值组成的序列 (hello, seq:[1,1,1])

Option: 当前批次输入键对应的value值，如果历史中没有该键，这个值就是None, 如果历史中出现了这个键，这个值就是Some(值)

有状态算子使用注意事项：

1、有状态算子ByKey算子只适用于k-v类型的DStream

2、有状态算子使用的时候，需要提前设置checkpoint的路径，因为需要将历史批次的结果存储下来

import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Durations, StreamingContext}object Demo2WordCount2 {def main(args: Array[String]): Unit = {/*** Spark core: SparkContext 核心数据结构：RDD* Spark sql: SparkSession 核心数据结构：DataFrame* Spark streaming: StreamingContext  核心数据结构：DStream(底层封装了RDD)*/val conf = new SparkConf()conf.setMaster("local[2]") // 给定核数conf.setAppName("spark Streaming 单词统计")val sparkContext = new SparkContext(conf)/*** 创建Spark Streaming的运行环境，和前两个模块是不一样的* Spark Streaming是依赖于Spark core的环境的* this(sparkContext: SparkContext, batchDuration: Duration)* Spark Streaming处理之前，是有一个接收数据的过程* batchDuration，表示接收多少时间段内的数据*/val streamingContext = new StreamingContext(sparkContext, Durations.seconds(5))//TODO :设置缓存，设置的是一个文件夹，用来存储缓存的数据streamingContext.checkpoint("spark/data/checkpoint2")/*** Spark Streaming程序理论上是一旦启动，就不会停止，除非报错，人为停止，停电等其他突然场景导致程序终止* 监控一个端口号中的数据，手动向端口号中打数据* master虚拟机上启动命令：nc -lk 12345*/val rids: ReceiverInputDStream[String] = streamingContext.socketTextStream("master", 12345)//hello worldval wordsDS: DStream[String] = rids.flatMap(_.split(" "))val kvDS: DStream[(String, Int)] = wordsDS.map((_, 1)) // (hello,1) (hello,1)  (hello,1)/*** 每5秒中resDS中的数据，是当前5s内的数据* reduceByKey，只会对当前5s批次中的数据求和*///    val resDS: DStream[(String, Int)] = kvDS.reduceByKey(_ + _)/*** 需要使用有状态的算子来处理当前批次数据与历史数据的关系** updateStateByKey[S: ClassTag](updateFunc: (Seq[V], Option[S]) => Option[S]): DStream[(K, S)]* Seq:  序列，表示历史键对应的值组成的序列 (hello, seq:[1,1,1])* Option: 当前批次输入键对应的value值，如果历史中没有该键，这个值就是None, 如果历史中出现了这个键，这个值就是Some(值)* 有状态算子使用注意事项：* 1、有状态算子ByKey算子只适用于k-v类型的DStream* 2、有状态算子使用的时候，需要提前设置checkpoint的路径，因为需要将历史批次的结果存储下来*/val resDS: DStream[(String, Int)] = kvDS.updateStateByKey((seq1: Seq[Int], opt1: Option[Int]) => {val sumValue: Int = seq1.sum/*** .getOrElse(0) 方法的作用是：如果Option容器包含的是Some（即值存在），则返回Some中包装的值；* 如果Option容器是None（即值不存在），则返回括号中指定的默认值，在这个例子中是0。*/val num: Int = opt1.getOrElse(0)Option(sumValue + num)})println("--------------------------------------")resDS.print()println("--------------------------------------")/*** sparkStreaming启动的方式和前两个模块启动方式不一样*/streamingContext.start()streamingContext.awaitTermination()streamingContext.stop()}
}

案例二执行结果：历史输入的相同的单词都会被统计

在这里插入图片描述
在这里插入图片描述

窗口类算子

1、如果只是为了计算当前批次接收的数据，直接调用reduceByKey

2、如果要将最新批次的数据与历史数据结合处理的话，需要调用有状态算子 updateStateByKey

3、如果要实现滑动窗口或者滚动窗口的话，需要使用窗口类算子reduceByKeyAndWindow

import org.apache.spark.sql.SparkSession
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Durations, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}object Demo3Window {def main(args: Array[String]): Unit = {/*** 创建spark streaming的环境* 旧版本创建的方式*///    val conf: SparkConf = new SparkConf().setMaster("local[2]").setAppName("窗口案例")//    val context = new SparkContext(conf)//    val sc = new StreamingContext(context, Durations.seconds(5))/*** 新版本的创建方式*/val context: SparkContext = SparkSession.builder().master("local[2]").appName("窗口案例").config("spark.sql.shuffle.partitions", "1").getOrCreate().sparkContext/*** 正常每次接收3s内的数据* 注：这个时间为数据接收时间，目的是让时间与数据挂钩。* 因为无法对监控端的数据进行定量，所以通过对时间定量的方式来对数据定量。* 在逻辑上将数据想象为，一个个3s的时间间隔块，数据就存储在时间间隔块中。* 这样以来就可以使用窗口所设置的参数（时间），窗口大小、滑动大小来进行任务的处理与执行。*/val sc = new StreamingContext(context, Durations.seconds(5))//1000 ~ 65535(这些端口可用，但是有些特殊端口不可用，8088、8080、9870...)val infoDS: ReceiverInputDStream[String] = sc.socketTextStream("master", 10086)val wordsDS: DStream[String] = infoDS.flatMap(_.split(" "))val kvDS: DStream[(String, Int)] = wordsDS.map((_, 1))/*** 1、如果只是为了计算当前批次接收的数据，直接调用reduceByKey* 2、如果要将最新批次的数据与历史数据结合处理的话，需要调用有状态算子 updateStateByKey* 3、如果要实现滑动窗口或者滚动窗口的话，需要使用窗口类算子reduceByKeyAndWindow*//*** def reduceByKeyAndWindow(reduceFunc: (V, V) => V,windowDuration: Duration,slideDuration: Duration): DStream[(K, V)]* reduceFunc 编写处理相同的键对应的value值做处理* windowDuration  设置窗口的大小* slideDuration  设置滑动的大小* 每间隔slideDuration大小的时间计算一次数据，计算数据的范围是最近windowDuration大小时间的数据*/val resDS: DStream[(String, Int)] = kvDS.reduceByKeyAndWindow((v1: Int, v2: Int) => v1 + v2, Durations.seconds(10), Durations.seconds(5))/*** 当窗口大小与滑动大小一致的时候，那么就会从滑动窗口转变成滚动窗口的效果*/
//    val resDS: DStream[(String, Int)] = kvDS.reduceByKeyAndWindow((v1: Int, v2: Int) => v1 + v2, Durations.seconds(10), Durations.seconds(10))resDS.print()sc.start()sc.awaitTermination()sc.stop()}
}

DStreamToRDD

方式一：

foreachRDD：在DS中使用rdd的语法操作数据

缺点：该函数是没有返回值的，无法返回一个新的DStream

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SparkSession}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Durations, StreamingContext}object Demo4DStream2RDD {def main(args: Array[String]): Unit = {//使用DataFrame的语法val sparkSession: SparkSession = SparkSession.builder().master("local[2]").appName("rdd与DStream的关系").config("spark.sql.shuffle.partitions", "1").getOrCreate()import org.apache.spark.sql.functions._import sparkSession.implicits._//使用RDD的语法val sparkContext: SparkContext = sparkSession.sparkContext//使用DStream的语法val streamingContext = new StreamingContext(sparkContext, Durations.seconds(5))val infoDS: ReceiverInputDStream[String] = streamingContext.socketTextStream("master", 10086)//如果DS不是键值形式的话，可以单独调用window函数进行设置窗口的形式val new_infoDS: DStream[String] = infoDS.window(Durations.seconds(10), Durations.seconds(5))// hello world java hello java/*** foreachRDD：在DS中使用rdd的语法操作数据* 缺点：该函数是没有返回值的* 需求：我们在想使用DS中的RDD的同时，想要使用结束后，会得到一个新的DS*/new_infoDS.foreachRDD((rdd:RDD[String])=>{println("------------------------------")// sparkCore处理数据val resRDD: RDD[(String, Int)] = rdd.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _)resRDD.foreach(println)// rdd和df之间可以转换
//       sparkSql处理数据val df1: DataFrame = rdd.toDF.select($"value" as "info")df1.createOrReplaceTempView("words")val resDF: DataFrame = sparkSession.sql("""|select|t1.wds as word,|count(1) as counts|from|(|select|explode(split(info,' ')) as  wds|from words) t1|group by t1.wds|""".stripMargin)resDF.show()})streamingContext.start()streamingContext.awaitTermination()streamingContext.stop()}
}
方式二：

面试题：foreachRDD与transform的区别

transform也可以循环遍历出DStream中封装的RDD，并且在计算后还会返回一个新的DStream对象

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Row, SparkSession}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Durations, StreamingContext}/*** 面试题：foreachRDD与transform的区别*/
object Demo5Transformat {def main(args: Array[String]): Unit = {//使用DataFrame的语法val sparkSession: SparkSession = SparkSession.builder().master("local[2]").appName("rdd与DStream的关系").config("spark.sql.shuffle.partitions", "1").getOrCreate()import org.apache.spark.sql.functions._import sparkSession.implicits._//使用RDD的语法val sparkContext: SparkContext = sparkSession.sparkContext//使用DStream的语法val streamingContext = new StreamingContext(sparkContext, Durations.seconds(5))val infoDS: ReceiverInputDStream[String] = streamingContext.socketTextStream("master", 10086)val resDS: DStream[(String, Int)] = infoDS.transform((rdd: RDD[String]) => {//直接对rdd进行处理，返回新的rdd//      val resRDD: RDD[(String, Int)] = rdd.flatMap(_.split(" "))//        .map((_, 1))//        .reduceByKey(_ + _)//      resRDD//将rdd转df，使用sql做分析//rdd和df之间可以转换val df1: DataFrame = rdd.toDF.select($"value" as "info")df1.createOrReplaceTempView("words")val resDF: DataFrame = sparkSession.sql("""|select|t1.wds as word,|count(1) as counts|from|(|select|explode(split(info,' ')) as  wds|from words) t1|group by t1.wds|""".stripMargin)val resRDD: RDD[(String, Int)] = resDF.rdd.map((row: Row) => (row.getAs[String](0), row.getAs[Int](1)))resRDD})resDS.print()streamingContext.start()streamingContext.awaitTermination()streamingContext.stop()}
}

将代码提交到yarn集群上运行

指令：spark-submit --master yarn --deploy-mode client --class com.shujia.streaming.Demo6YarnSubmit spark-1.0.jar

可以使用ctrl+c，退出并终止进程

杀死yarn上运行的进程（有时候直接退出不会终止进程）：yarn application -kill application_1721466291251_0002

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Row, SparkSession}
import org.apache.spark.streaming.{Durations, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}object Demo6YarnSubmit {def main(args: Array[String]): Unit = {//使用DataFrame的语法val sparkSession: SparkSession = SparkSession.builder()
//      .master("local[2]").appName("rdd与DStream的关系").config("spark.sql.shuffle.partitions", "1").getOrCreate()import org.apache.spark.sql.functions._import sparkSession.implicits._//使用RDD的语法val sparkContext: SparkContext = sparkSession.sparkContext//使用DStream的语法val streamingContext = new StreamingContext(sparkContext, Durations.seconds(5))val infoDS: ReceiverInputDStream[String] = streamingContext.socketTextStream("master", 10086)val resDS: DStream[(String, Int)] = infoDS.transform((rdd: RDD[String]) => {//直接对rdd进行处理，返回新的rdd//      val resRDD: RDD[(String, Int)] = rdd.flatMap(_.split(" "))//        .map((_, 1))//        .reduceByKey(_ + _)//      resRDD//将rdd转df，使用sql做分析//rdd和df之间可以转换val df1: DataFrame = rdd.toDF.select($"value" as "info")df1.createOrReplaceTempView("words")val resDF: DataFrame = sparkSession.sql("""|select|t1.wds as word,|count(1) as counts|from|(|select|explode(split(info,' ')) as  wds|from words) t1|group by t1.wds|""".stripMargin)val resRDD: RDD[(String, Int)] = resDF.rdd.map((row: Row) => (row.getAs[String](0), row.getAs[Int](1)))resRDD})resDS.print()streamingContext.start()streamingContext.awaitTermination()streamingContext.stop()}
}

读取一个端口中数据写入到本地

saveAsTextFiles

  • 将结果存储到磁盘中
  • 只能设置文件夹的名字和文件的后缀
  • 每一批次运行，都会产生新的小文件夹，文件夹中有结果数据文件
import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Row, SparkSession}
import org.apache.spark.streaming.{Durations, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}object Demo7SaveFile {def main(args: Array[String]): Unit = {//使用DataFrame的语法val sparkSession: SparkSession = SparkSession.builder().master("local[2]").appName("rdd与DStream的关系").config("spark.sql.shuffle.partitions", "1").getOrCreate()import org.apache.spark.sql.functions._import sparkSession.implicits._//使用RDD的语法val sparkContext: SparkContext = sparkSession.sparkContext//使用DStream的语法val streamingContext = new StreamingContext(sparkContext, Durations.seconds(5))val infoDS: ReceiverInputDStream[String] = streamingContext.socketTextStream("master", 10086)val resDS: DStream[(String, Int)] = infoDS.transform((rdd: RDD[String]) => {//直接对rdd进行处理，返回新的rdd//      val resRDD: RDD[(String, Int)] = rdd.flatMap(_.split(" "))//        .map((_, 1))//        .reduceByKey(_ + _)//      resRDD//将rdd转df，使用sql做分析//rdd和df之间可以转换val df1: DataFrame = rdd.toDF.select($"value" as "info")df1.createOrReplaceTempView("words")val resDF: DataFrame = sparkSession.sql("""|select|t1.wds as word,|count(1) as counts|from|(|select|explode(split(info,' ')) as  wds|from words) t1|group by t1.wds|""".stripMargin)val resRDD: RDD[(String, Int)] = resDF.rdd.map((row: Row) => (row.getAs[String](0), row.getAs[Int](1)))resRDD})//    resDS.print()/*** 将结果存储到磁盘中* 只能设置文件夹的名字和文件的后缀* 每一批次运行，都会产生新的小文件夹，文件夹中有结果数据文件*/resDS.saveAsTextFiles("spark/data/streamout/stream","txt")streamingContext.start()streamingContext.awaitTermination()streamingContext.stop()}
}

在这里插入图片描述

读取一个端口中的数据写入到MySQL中

在写入数据时，会涉及到数据库连接对象、预编译对象连续创建的问题

方案一：

数据库连接对象、预编译对象会连续创建

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession
import org.apache.spark.streaming.{Durations, StreamingContext}
import org.apache.spark.streaming.dstream.ReceiverInputDStreamimport java.sql.{Connection, DriverManager, PreparedStatement}
object Demo8DS2Mysql {def main(args: Array[String]): Unit = {//使用DataFrame的语法val sparkSession: SparkSession = SparkSession.builder().master("local[2]").appName("rdd与DStream的关系")/*** 这个配置是全局的，并且专门用于Spark SQL中的shuffle操作。它设置了在进行shuffle操作时，默认使用的分区数。* Shuffle操作通常发生在需要跨多个节点重新分发数据的场景中，比如join、groupBy等操作。*/.config("spark.sql.shuffle.partitions", "1").getOrCreate()import org.apache.spark.sql.functions._import sparkSession.implicits._//使用RDD的语法val sparkContext: SparkContext = sparkSession.sparkContext//使用DStream的语法val streamingContext = new StreamingContext(sparkContext, Durations.seconds(5))val infoDS: ReceiverInputDStream[String] = streamingContext.socketTextStream("master", 10086)infoDS.foreachRDD((rdd:RDD[String])=>{println("======================= 正在处理一批数据 ==========================")//处理rdd中每一条数据rdd.foreach((line:String)=>{//如果将创建连接的代码写在这里，这样的话，每条数据都会创建一次连接/*** 创建与数据库连接对象*///注册驱动Class.forName("com.mysql.jdbc.Driver")//创建数据库连接对象val conn: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/bigdata30?useUnicode=true&characterEncoding=UTF-8&useSSL=false","root","123456")//创建预编译对象val statement: PreparedStatement = conn.prepareStatement("insert into students values(?,?,?,?,?)")val info: Array[String] = line.split(",")statement.setInt(1,info(0).toInt)statement.setString(2,info(1))statement.setInt(3,info(2).toInt)statement.setString(4,info(3))statement.setString(5,info(4))//执行sql语句statement.executeUpdate()//释放资源statement.close()conn.close()})})streamingContext.start()streamingContext.awaitTermination()streamingContext.stop()}
}

方案二：

设想中的改造

  • 我们将原本在rdd中创建连接的代码放到了ds遍历RDD中，发现PreparedStatement不能与task任务一起序列化到executor中的
  • 这样的写法是不可以的！！！
   infoDS.foreachRDD((rdd: RDD[String]) => {println("======================= 正在处理一批数据 ==========================")//如果将创建连接的代码写在这里，这样的话，每条数据都会创建一次连接/*** 创建与数据库连接对象*///注册驱动Class.forName("com.mysql.jdbc.Driver")//创建数据库连接对象val conn: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/bigdata30?useUnicode=true&characterEncoding=UTF-8&useSSL=false","root","123456")//创建预编译对象val statement: PreparedStatement = conn.prepareStatement("insert into students values(?,?,?,?,?)")//处理rdd中每一条数据rdd.foreach((line: String) => {val info: Array[String] = line.split(",")statement.setInt(1, info(0).toInt)statement.setString(2, info(1))statement.setInt(3, info(2).toInt)statement.setString(4, info(3))statement.setString(5, info(4))//执行sql语句statement.executeUpdate()})//释放资源statement.close()conn.close()})

方案三：

rdd中有一个算子foreachPartition

  • rdd本质是由一系列分区构成的，如果我们可以将分区数设置为1，每个分区只创建一个连接即可
  • RDD中只有一个分区，只需在遍历该分区时创建一次数据库连接对象、预编译对象
infoDS.foreachRDD((rdd: RDD[String]) => {println("======================= 接收到 5s 一批次数据 ==========================")/*** 这个操作是针对特定的RDD（弹性分布式数据集）的，用于重新划分RDD的分区。* 它强制Spark对RDD中的元素进行重新分配，以符合指定的分区数。*/rdd.repartition(1)println(s" DS封装的RDD中的分区数为:${rdd.getNumPartitions} ")/*** foreachPartition，处理一个分区的数据* 将一个分区的数据，封装成了一个迭代器*/rdd.foreachPartition((itr: Iterator[String]) => {println("======================= 正在处理一个分区的数据 ==========================")//如果将创建连接的代码写在这里，这样的话，每条数据都会创建一次连接/*** 创建与数据库连接对象*///注册驱动Class.forName("com.mysql.jdbc.Driver")//创建数据库连接对象val conn: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/bigdata_30?useUnicode=true&characterEncoding=UTF-8&useSSL=false","root","123456")//创建预编译对象val statement: PreparedStatement = conn.prepareStatement("insert into students2 values(?,?,?,?,?)")println("========================= 创建了一次连接 =========================")itr.foreach((line: String) => {val info: Array[String] = line.split(",")statement.setInt(1, info(0).toInt)statement.setString(2, info(1))statement.setInt(3, info(2).toInt)statement.setString(4, info(3))statement.setString(5, info(4))//执行sql语句statement.executeUpdate()})statement.close()conn.close()})
})

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

Inconsistent Query Results Based on Output Fields Selection in Milvus Dashboard

Inconsistent Query Results Based on Output Fields Selection in Milvus Dashboard

题意：在Milvus仪表盘中基于输出字段选择的不一致查询结果 问题背景： Im experiencing an issue with the Milvus dashboard where the search results change based on the selected output fields. Im working on a RAG project using text data conv…
阅读更多...
智慧隧道可视化：安全与效率的智能保障

智慧隧道可视化：安全与效率的智能保障

运用图扑可视化技术，实时监测隧道内的环境和交通状况，提升维保效率和应急响应能力，确保隧道运营的安全和畅通。
阅读更多...
系统架构设计师教程 第4章 信息安全技术基础知识-4.1 信息安全基础知识-解读

系统架构设计师教程 第4章 信息安全技术基础知识-4.1 信息安全基础知识-解读

系统架构设计师教程 第4章 信息安全技术基础知识-4.1 信息安全基础知识 4.1.1 信息安全的概念4.1.1.1 信息安全的范围4.1.1.1.1 设备安全4.1.1.1.2 数据安全4.1.1.1.3 内容安全4.1.1.1.4 行为安全 4.1.2 信息存储安全4.1.2.1 信息使用的安全4.1.2.1.1 用户的标识与验证4.1.2.1.…
阅读更多...
Redis+Lua脚本+AOP+反射+自定义注解，打造我司内部基础架构限流组件

Redis+Lua脚本+AOP+反射+自定义注解，打造我司内部基础架构限流组件

定义注解 Retention(RetentionPolicy.RUNTIME) Target({ElementType.METHOD}) Documented public interface RedisLimitAnnotation {/*** 资源的key,唯一* 作用：不同的接口，不同的流量控制*/String key() default "";/*** 最多的访问限制次数…
阅读更多...
JAVA毕业设计152—基于Java+Springboot+vue+小程序的个人健康管理系统小程序(源代码+数据库+15000字论文)

JAVA毕业设计152—基于Java+Springboot+vue+小程序的个人健康管理系统小程序(源代码+数据库+15000字论文)

毕设所有选题： https://blog.csdn.net/2303_76227485/article/details/131104075 基于JavaSpringbootvue小程序的个人健康管理系统小程序(源代码数据库15000字论文)152 一、系统介绍 本项目前后端分离带小程序(可以改为ssm版本)，分为用户、管理员两种…
阅读更多...
ARM功耗管理之功耗和安全

ARM功耗管理之功耗和安全

安全之安全(security)博客目录导读 思考：功耗与安全？超频攻击？欠压攻击？低功耗流程中的安全？ 睡眠唤醒流程中，安全相关寄存器的备份恢复 举例：比如某DMA通道，芯片逻辑默认为安全通…
阅读更多...
深入了解jdbc-02-CRUD

深入了解jdbc-02-CRUD

文章目录 操作和访问数据库Statement操作数据表的弊端sql注入问题PreparedStatement类ResultSet类与ResultSetMetaData类资源的释放批量插入 操作和访问数据库 数据库的调用的不同方式: Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。PreparedStatem…
阅读更多...
《0基础》学习Python——第二十四讲__爬虫/＜7＞深度爬取

《0基础》学习Python——第二十四讲__爬虫/＜7＞深度爬取

一、深度爬取 深度爬取是指在网络爬虫中，获取网页上的所有链接并递归地访问这些链接，以获取更深层次的页面数据。 通常，一个简单的爬虫只会获取到初始页面上的链接，并不会进一步访问这些链接上的其他页面。而深度爬取则会不断地获…
阅读更多...
Java：115-Spring Boot的底层原理（下篇）

Java：115-Spring Boot的底层原理（下篇）

这里续写上一章博客（115章博客） SpringBoot视图技术： 支持的视图技术 ： 前端模板引擎技术的出现（jsp也是），使前端开发人员无需关注后端业务的具体实现（jsp中，具体的…
阅读更多...
IPython魔法命令的深入应用

IPython魔法命令的深入应用

目录 IPython魔法命令的深入应用 一、魔法命令基础 1. 魔法命令的分类 2. 基本使用 二、高级应用技巧 1. 数据交互与处理 2. 交互式编程与调试 三、魔法命令的进阶操作 1. 自定义魔法命令 2. 利用魔法命令优化工作流程 四、总结与展望 IPython魔法命令的深入应用 IP…
阅读更多...
ICP配准两个obj三维物体+关键点处形成立体小球球 +TRF算法（含有在ICP配准情境下的算法对应代码）

ICP配准两个obj三维物体+关键点处形成立体小球球 +TRF算法（含有在ICP配准情境下的算法对应代码）

import os import shutil import numpy as np import cv2 import face_alignment import vtk from scipy.spatial import cKDTree from scipy.optimize import least_squaresdef load_obj(file_path):vertices = []faces = []with open
阅读更多...
[米联客-安路飞龙DR1-FPSOC] FPGA基础篇连载-24 基于FPGA简易示波器显示驱动设计

[米联客-安路飞龙DR1-FPSOC] FPGA基础篇连载-24 基于FPGA简易示波器显示驱动设计

软件版本：Anlogic -TD5.9.1-DR1_ES1.1 操作系统：WIN10 64bit 硬件平台：适用安路(Anlogic)FPGA 实验平台：米联客-MLK-L1-CZ06-DR1M90G开发板 板卡获取平台：https://milianke.tmall.com/ 登录“米联客”FPGA社区 ht…
阅读更多...
解析Type-C母座与Type-C公头：特点与区别

解析Type-C母座与Type-C公头：特点与区别

解析Type-C母座与Type-C公头：特点与区别 在数字连接领域，Type-C接口因其高速、多功能等特点备受瞩目。然而，在Type-C连接器中，母座和公头作为两个重要组成部分，却有着各自独特的特点和用途。本文将深入探讨Type-C母座…
阅读更多...
编程中的智慧四：设计模式总览

编程中的智慧四：设计模式总览

前面三篇我们通过从一些零散的例子，和简单应用来模糊的感受了下设计模式在编程中的智慧，从现在开始正式进入设计模式介绍，本篇将从设计模式的7大原则、设计模式的三大类型、与23种设计模式的进行总结，和描述具体意义。 设计模式体…
阅读更多...
新形势下职业教育人工智能人才培养策略

新形势下职业教育人工智能人才培养策略

一、引言 随着人工智能技术的飞速发展，社会对人工智能人才的需求日益增长。职业教育作为培养实用型人才的重要基地，应积极响应市场需求，加强人工智能人才的培养。然而，当前职业教育在人工智能人才培养方面仍存在一些问题&#xf…
阅读更多...
C++树形结构(总）

C++树形结构(总）

目录 一.基础： 1.概念： 2.定义： Ⅰ.树的相关基础术语： Ⅱ.树的层次： 3.树的性质： 二.存储思路： 1.结构体存储： 2.数组存储： 三.树的遍历模板： 四.…
阅读更多...
App用户从哪来？Xinstall全渠道数据统计告诉你答案！

App用户从哪来？Xinstall全渠道数据统计告诉你答案！

在移动互联网时代，App已经成为了我们日常生活中不可或缺的一部分。然而，对于App运营者来说，如何了解用户的来源，从而优化推广策略，一直是一个难题。今天，我们就来科普一下App用户来源分析的重要性&#xff…
阅读更多...
使用idea创建Javaweb项目（步骤）

使用idea创建Javaweb项目（步骤）

第一步创建Javaweb项目 File>New>Project 第二步 勾选Web Application >Next 然后就是进行起名，完成。 完成创建项目，检查是否文件齐全 配置tomcat 配置好，就能启动tomcat，显示首页 导入jar包。导入进项目&#xf…
阅读更多...
博客建站4 - ssh远程连接服务器

博客建站4 - ssh远程连接服务器

1. 什么是SSH?2. 下载shh客户端3. 配置ssh密钥4. 连接服务器5. 常见问题 5.1. IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY! 1. 什么是SSH? SSH（Secure Shell）是一种加密的网络协议，用于在不安全的网络中安全地远程登录到其他…
阅读更多...
LC617-合并二叉树

LC617-合并二叉树

文章目录 1 题目描述2 思路优化代码完整输入输出 参考 1 题目描述 https://leetcode.cn/problems/merge-two-binary-trees/description/ 给你两棵二叉树： root1 和 root2 。 将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另…
阅读更多...
最新文章

Copyright @ 2022~2023