大数据 - Spark系列《三》- 加载各种数据源创建RDD

Spark系列文章：

大数据 - Spark系列《一》- 从Hadoop到Spark：大数据计算引擎的演进-CSDN博客

大数据 - Spark系列《二》- 关于Spark在Idea中的一些常用配置-CSDN博客

目录

3.1🧀加载文件(本地)

1. 加载本地文件路径

🌮使用textFile加载本地txt文件

🌮使用textFile加载本地json文件

🌮使用sequenceFile加载本地二进制文件

🌮HDFS也可以 （hdfs://doe01:8020/data/wds/）

3.2 🧀本地集合(测试)

3.3 🧀加载mysql

1. 🌮环境准备

2. 🌮创建Spark应用程序

3.1🧀加载文件(本地)

1. 加载本地文件路径

  • 🌮使用textFile加载本地txt文件
  • 🌮使用textFile加载本地json文件
  • 🌮使用sequenceFile加载本地二进制文件

二进制文件加载后的RDD中每个元素都是一个键值对，其中键和值的类型由用户指定。

/**
 * 加载文本文件 创建RDD
 * 参数1  文件路径
 * 参数2   最小分区数 默认2
 * RDD =  迭代器+分区信息  一行一行的迭代数据
 */
// 从本地文件系统加载（只适用于开发测试）
val rdd: RDD[String] = sc.textFile("local/path/to/text/file", 2)
val rdd: RDD[String] = sc.textFile("local/path/to/json/file", 2)


//-------------------------------------------------
//   User.class   asInstanceOf
val res = sc.sequenceFile("local/path/to/binary/file", classOf[String], classOf[Int])
// 其中第一个参数是文件路径，第二个参数是键的类型，第三个参数是值的类型。
  • 🌮HDFS也可以 （hdfs://doe01:8020/data/wds/）
// 从HDFS文件系统加载（对应绝大多数生产应用场景）
val data: RDD[String] = sc.textFile("hdfs://hadoop01:8020/data/words/", 2)
data.foreach(println)

 🥙练习1：使用textFile加载本地txt文件 - 统计每个城市下订单总额

//数据：orders.txt
oid01,100,bj
oid02,100,bj
oid03,100,bj
oid04,100,nj
oid05,100,nj
package com.doit.day0130

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

/**
 * @日期: 2024/1/31
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description: Spark应用程序入口，用于计算订单数据中各个城市的订单总金额
 */

object StartGetting {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象，并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式

    // 创建SparkContext对象，并传入SparkConf对象
    val sc = new SparkContext(conf)

    // 加载订单数据
    val rdd1 = sc.textFile("data/orders.txt")

    // 将订单数据转换为键值对(city, amount)，其中city为键，amount为值
    val rdd2 = rdd1.map(line => {
      val arr = line.split(",")
      (arr(2), arr(1))
    })

    // 根据城市对订单数据进行分组
    val rdd3 = rdd2.groupBy(_._1)

    // 计算每个城市的订单总金额
    val rdd4 = rdd3.map(tp => {
      val city = tp._1
      val sum = tp._2.map(_._2.toInt).sum
      (city, sum)
    })

    // 将结果保存到输出文件中
    rdd4.saveAsTextFile("data/citysum_output")
    
   // 将结果保存并保存为sequenceFile文件
    rdd4.saveAsTextFile("data/citysum_output_seq")

    // 关闭SparkContext对象，释放资源
    sc.stop()
  }
}

结果：

🥙练习2：使用textFile加载本地json文件 - 去获取每部电影的平均分

Spark-关于Json数据格式的数据的处理与练习

🥙练习3：使用sequenceFile加载本地二进制文件(练习1出来的结果data/citysum_output_seq) - 将seq文件的数据转换为Object对象，并打印出所有的城市

// 城市对象类
case class CityObj(
                    // 城市名称
                    city: String,
                    // 数量
                    num: Int
                  )
package com.doit.day0201

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.log4j.{Level, Logger}
import org.apache.hadoop.io.Text
import org.apache.hadoop.io.IntWritable

/**
 * @日期: 2024/2/1
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description:
 */


object Test01 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象，并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式

    // 创建SparkContext对象，并传入SparkConf对象
    val sc = new SparkContext(conf)
    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)

    //sequenceFile 就是序列化文件 K-V K-V K1-V1 【序列化】
    // 加载 Sequence 文件并创建 RDD
    val rdd1 = sc.sequenceFile("data/citysum_output_seq/", classOf[Text], classOf[IntWritable])
    val newrdd = sc.sequenceFile[String, Int]("data/citysum_output_seq/", 2)

    newrdd.foreach(println)
    // 转换为对象并提取城市数据
    val cities = rdd1.map { case (textKey, intValue) =>
      // 将 Hadoop 的 Text 对象和 IntWritable 对象转换为 Scala 字符串和整数
      val city = textKey.toString
      val count = intValue.get()

      // 创建 CityObj 对象
      CityObj(city, count)
    }


    // 提取并打印所有城市
    val uniqueCities = cities.map(_.city).foreach(println)

    sc.stop()
  }
}

结果：

注意点：

  1. 类型匹配：sequenceFile 方法需要指定键和值的类型参数，这些类型应该与文件中实际的数据类型匹配。通常情况下，键和值的类型会使用 Hadoop 库中的数据类型，如 Text、IntWritable 等。

  2. 类型转换：在处理文件数据时，需要将 Hadoop 的 Text 类型转换为 Scala 的 String 类型，将 IntWritable 类型转换为 Scala 的 Int 类型。

🥙练习4：使用textFile加载hdfs txt文件 - 每个字母代表一个人 , 统计任意一个人和其他人的共同好友 

//数据:f.txt
A:B,C,D,F,E,O
B:A,C,E,K
C:F,A,D,I
D:A,E,F,L
E:B,C,D,M,L
F:A,B,C,D,E,O,M
G:A,C,D,E,F
H:A,C,D,E,O
I:A,O
J:B,O
K:A,C,D
L:D,E,F
M:E,F,G
O:A,H,I,J
package com.doit.day0201

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.log4j.{Level, Logger}
import org.apache.hadoop.io.Text
import org.apache.hadoop.io.IntWritable

/**
 * @日期: 2024/2/2
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description: 实现统计每个人与其他人的共同好友
 */

object Test02 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象，并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式

    // 创建SparkContext对象，并传入SparkConf对象
    val sc = new SparkContext(conf)

    // 从HDFS读取数据创建RDD
    val rdd1 = sc.textFile("hdfs://hadoop01:8020/spark/data/f.txt", 2)

    // 对每行数据进行处理，生成以每个人为key，其好友为value的RDD
    val rdd2: RDD[(String, String)] = rdd1.flatMap(line => {
      val arr1 = line.split(":")
      val name = arr1(0)
      val arr2 = arr1(1).split(",")
      arr2.map(tp => (name, tp))
    })

    // 将数据按照每个人分组，形成键值对的RDD，键为人名，值为其好友列表
    val rdd3 = rdd2.groupBy(_._1)

    // 转换RDD结构，将Iterable转换为List
    val rdd4 = rdd3.map(tp => {
      val name = tp._1
      val fr: Iterable[String] = tp._2.map(_._2)
      (name, fr)
    })

    // 将RDD转换为List
    val list: List[(String, Iterable[String])] = rdd4.collect().toList

    // 遍历List中的每个元素，计算交集
    for (i <- 0 to list.size; j <- i + 1 to list.size) {
      val tuple: (String, Iterable[String]) = list(i)
      val tuple1 = list(j)

      // 计算两人好友列表的交集
      val v3 = tuple._2.toList.intersect(tuple1._2.toList)
      println(s"${tuple._1}与${tuple1._1}的交集为" + v3)
    }

    // 关闭SparkContext
    sc.stop()
  }
}

结果：

3.2 🧀本地集合(测试)

在Spark中，makeRDD方法用于将本地集合或序列转换为RDD。它接受一个Seq类型的集合作为参数，并可选地接受一个表示分区数量的整数参数。

  • 默认分区 环境的所有可用核数

  • 创建的时候可以通过参数设置分区

package com.doit.day0201

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.log4j.{Level, Logger}
import org.apache.hadoop.io.Text
import org.apache.hadoop.io.IntWritable

import scala.collection.mutable

/**
 * @日期: 2024/2/4
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description: 示例RDD的创建和并行度设置
 */

// 定义一个城市对象，包含城市名和人口数量
case class CityObj(name: String, population: Int)

object Test04 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象，并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式

    // 创建SparkContext对象，并传入SparkConf对象
    val sc = new SparkContext(conf)

    // 创建一个List集合，包含城市对象
    val city = List(
      CityObj("shanghai", 5000000),
      CityObj("beijing", 9800000),
      CityObj("nanjing", 5500000)
    )

    // 将List集合直接转换为RDD，默认并行度为所有可用核数
    val rdd1 = sc.makeRDD(city)
    // 将List集合转换为RDD，并指定并行度为2
    val rdd2 = sc.makeRDD(city, 2)

    // 打印RDD的分区数
    println(rdd1.getNumPartitions) // 16
    println(rdd2.getNumPartitions) // 2

    // 创建一个可变的HashMap，包含姓名和年龄
    val map = mutable.HashMap[String, Int](("zss", 23), "lss" -> 33)

    // HashMap不可以直接传入makeRDD，需要先转换为List再传入
    val rdd3 = sc.makeRDD(map.toList)
    // 打印RDD的分区数
    println(rdd3.getNumPartitions) // 16

    // 关闭SparkContext
    sc.stop()
  }
}

HashMap不可直接使用makeRDD方法

对于HashMap类型的集合，由于其不是Seq的子类，因此无法直接使用makeRDD方法进行转换。通常情况下，可以先将HashMap转换为List，再使用makeRDD方法，示例如下：

val map = mutable.HashMap[String, Int](("zss", 23), "lss" -> 33) 
// HashMap不可以直接传入makeRDD，需要先转换为List再传入 
val rdd3 = sc.makeRDD(map.toList)

 

3.3 🧀加载mysql

1. 🌮环境准备

在开始之前，需要确保以下环境已经准备好：

  • Spark环境：确保已经安装和配置了Spark，并且可以正常运行Spark应用程序。

  • MySQL数据库：确保MySQL数据库已经安装并且可以访问。需要提供数据库连接地址、用户名和密码。

//创建表和插入数据
CREATE TABLE `salary` (
  `empid` int NOT NULL,
  `basesalary` double DEFAULT NULL,
  `titlesalary` double DEFAULT NULL,
  `deduction` double DEFAULT NULL,
  PRIMARY KEY (`empid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

INSERT INTO `salary` (`empid`, `basesalary`, `titlesalary`, `deduction`) VALUES
(1001, 2200, 1100, 200),
(1002, 1200, 200, NULL),
(1003, 2900, 700, 200),
(1004, 1950, 700, 150);

  • 在pom.xml里面添加mysql依赖

<!-- https://mvnrepository.com/artifact/com.mysql/mysql-connector-j -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.2.0</version>
</dependency>

2. 🌮创建Spark应用程序

使用JdbcRDD从MySQL数据库读取数据，需要注意以下几个关键参数：

1）SparkContext 对象 (sc)： 这是 Spark 应用程序的主要入口点，需要传递给 JdbcRDD 构造函数。

2）数据库连接函数 (conn)： 这是一个无参数的函数，用于获取数据库连接。在函数体内，应该使用 DriverManager.getConnection 方法来获取数据库连接，并指定数据库的连接地址、用户名和密码。

3）查询 SQL 语句 (sql)： 这是用于执行数据库查询的 SQL 语句。你可以在 SQL 语句中使用占位符（?）来表示查询参数，后续会通过 JdbcRDD 的其他参数来提供具体的查询范围。

4）查询参数范围： 通过指定起始和结束的查询参数值来定义查询范围。这些参数值会传递给 SQL 语句中的占位符，以便在查询时动态指定查询条件。

5）并行度 (numPartitions)： 这指定了创建的 RDD 的分区数，也就是并行度。它决定了查询在 Spark 集群中并行执行的程度。通常情况下，可以根据数据量和集群资源情况来设置并行度，以提高查询性能。

6）结果集处理函数 (resultSetHandler)： 这是一个函数，用于处理从数据库返回的查询结果。你需要实现这个函数来定义对查询结果的处理逻辑，例如提取需要的字段、转换数据类型等。

package com.doit.day0201

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

import java.sql.{DriverManager, ResultSet}

/**
 * @日期: 2024/2/4
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description: 使用JdbcRDD从MySQL数据库读取数据的示例
 */

object Tes05 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象，并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式

    // 创建SparkContext对象，并传入SparkConf对象
    val sc = new SparkContext(conf)

    /**
     * 参数一 sc
     * 参数二 函数  获取连接对象
     * 参数三 查询sql  要求  必须指定查询范围
     * 参数4 5 数据范围
     * 参数6 并行个数
     * 参数7 处理返回结果的函数
     */

    // 定义一个函数来获取数据库连接
    val conn = () => {
      DriverManager.getConnection("jdbc:mysql://localhost:3306/day02_test02_company", "root", "123456")
    };

    // 定义查询SQL语句
    val sql = "select empid,basesalary,titlesalary from salary where empid >= ? and empid <= ?"

    // 定义结果集处理函数
    val f2 = (rs: ResultSet) => {
      // 每条结果数据的处理逻辑
      val id = rs.getInt(1)
      val basesalary = rs.getDouble(2)
      val titlesalary = rs.getDouble(3)
      (id, basesalary, titlesalary)
    }

    // 创建JdbcRDD并执行查询
    val rdd1 = new JdbcRDD(sc, conn, sql, 1002, 1003, 1, f2)
    rdd1.foreach(println)


    // 停止SparkContext
    sc.stop()
  }
}

 

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

让IIS支持SSE (Server Sent Events)

让IIS支持SSE (Server Sent Events)

本文只探讨IISPython网站的情况&#xff0c;对于asp.net也应该不用这么麻烦。 先上结论&#xff1a;用反向代理&#xff1a; IIS URL Rewrite waitress Waitress是一个纯python编写独立的WSGI服务器&#xff0c;功能比Gunicorn弱一些&#xff0c;但可以运行在windows平台上&…
阅读更多...
基于springboot智慧养老平台源码和论文

基于springboot智慧养老平台源码和论文

首先,论文一开始便是清楚的论述了系统的研究内容。其次,剖析系统需求分析,弄明白“做什么”,分析包括业务分析和业务流程的分析以及用例分析,更进一步明确系统的需求。然后在明白了系统的需求基础上需要进一步地设计系统,主要包罗软件架构模式、整体功能模块、数据库设计。本项…
阅读更多...
牛客周赛 Round 31

牛客周赛 Round 31

D. 思路&#xff1a;使用map构造两个链表。 #include <bits/stdc.h> using namespace std;map<int,int> l,r; int main() {int q;cin>>q;int op-1e9-1;int ed1e91;r[op]ed;l[ed]op;while(q--){int a;cin>>a;if(a1){int x,y;cin>>x>>y;int…
阅读更多...
echarts使用之饼图（四）

echarts使用之饼图（四）

1 基本使用 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><meta http-equiv"X-UA-Compatible" cont…
阅读更多...
【Elasticsearch】从入门到精通

【Elasticsearch】从入门到精通

目前java常见的针对大数据存储的方案并不多&#xff0c;常见的就是mysql的分库分表、es存储 这里偏向es存储方案&#xff0c;es不同的版本之间其实差异还挺大的&#xff0c;本篇博文版本Elasticsearch 7.14.0 Springboot整合Easy-Es Easy-Es官方文档 Elasticsearch的初步认识 …
阅读更多...
【MATLAB源码-第135期】基于matlab的变色龙群优化算法CSA)机器人栅格路径规划，输出做短路径图和适应度曲线。

【MATLAB源码-第135期】基于matlab的变色龙群优化算法CSA)机器人栅格路径规划，输出做短路径图和适应度曲线。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 变色龙群优化算法&#xff08;Chameleon Swarm Algorithm&#xff0c;CSA&#xff09;是一种新颖的群体智能优化算法&#xff0c;受到自然界中变色龙捕食和社交行为的启发。变色龙以其独特的适应能力而著称&#xff0c;能够根…
阅读更多...
【vue3学习P5-P10】vue3语法；vue响应式实现

【vue3学习P5-P10】vue3语法；vue响应式实现

0、vue2和vue3对比 框架版本API方式双向绑定原理domFragmentsTree-Shakingvue2选项式API&#xff08;Options API&#xff09;基于Object.defineProperty&#xff08;监听&#xff09;实现&#xff0c;不能双向绑定对象类型的数据【通过Object.defineProperty里面的set和get做…
阅读更多...
【Linux网络编程三】Udp套接字编程网络应用场景

【Linux网络编程三】Udp套接字编程网络应用场景

【Linux网络编程三】Udp套接字编程网络应用场景 应用场景一&#xff1a;远程命令执行应用场景二&#xff1a;与Windos端相互通信应用场景三&#xff1a;简单聊天1.多线程化2.输入输出分开 应用场景一&#xff1a;远程命令执行 简单的服务器上一篇已经完成&#xff0c;接下来我…
阅读更多...
Java项目管理01-Maven基础

Java项目管理01-Maven基础

一、Maven的常用命令和生命周期 1.Maven的常用命令使用方式 complie&#xff1a;编译&#xff0c;将java文件编译为class字节码文件 clean&#xff1a;清理&#xff0c;删除字节码文件 test&#xff1a;测试&#xff0c;运行项目中的test类 package&#xff1a;打包&#x…
阅读更多...
高斯消去法 | LU分解 | PA=LU分解（MatLab）

高斯消去法 | LU分解 | PA=LU分解（MatLab）

一、问题描述 利用高斯消去法&#xff0c;LU 分解及PALU 分解求解非线性方程组。 二、实验目的 掌握高斯消去法、LU 分解、PALU 分解的算法原理&#xff1b;编写代码实现利用高斯消去法、LU 分解、PALU 分解来求解线性方程组。 三、实验内容及要求 1. 利用顺序高斯消去法求…
阅读更多...
计算机毕业设计社区居民服务管理系统SSM

计算机毕业设计社区居民服务管理系统SSM

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; vue mybatis Maven mysql5.7或8.0等等组成&#xff0c;B…
阅读更多...
Redis——SpringBoot整合Redis实战

Redis——SpringBoot整合Redis实战

1、基本配置 1.1、引入依赖 首先&#xff0c;建立Maven项目&#xff0c;在Maven项目中引入pom.xml文件&#xff1a; <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &l…
阅读更多...
HTML5和CSS3强化知识总结

HTML5和CSS3强化知识总结

HTML5的新特性 HTML5的新增特性主要是针对于以前的不足&#xff0c;增一些新的标签、新的表单和新的表单属性等。这些新特性都有兼容性问题&#xff0c;基本是IE9以上版本的浏览器才支持&#xff0c;如果不考虑兼容性问题&#xff0c;可以大量使用这些新特性。 HTML5新增的语义…
阅读更多...
linux实时调度

linux实时调度

面对陌生的知识体系&#xff0c;应该从什么角度来 简介 一、进程管理基本概念 在单处理器系统上&#xff0c;在给定时刻只有一个程序可以运行&#xff0c;在多处理器系统上&#xff0c;可以真正并行运行的进程数据&#xff0c;取决于物理CPU的数目&#xff1b; 进程优先级 …
阅读更多...
git 合并多条提交记录

git 合并多条提交记录

我要合并多条提交记录&#xff08;合并前7条为一条&#xff09;&#xff0c;实现如下效果&#xff1a; 使用git rebase // 查看前10个commit git log -10 // 将7个commit压缩成一个commit&#xff1b;注意&#xff1a;vim编辑器 git rebase -i HEAD~4 // add已经跟踪的文件 g…
阅读更多...
接口测试框架对比

接口测试框架对比

公司计划系统的开展接口自动化测试&#xff0c;需要我这边调研一下主流的接口测试框架给后端测试&#xff08;主要测试接口&#xff09;的同事介绍一下每个框架的特定和使用方式。后端同事根据他们接口的特点提出一下需求&#xff0c;看哪个框架更适合我们。 需求 1、接口编写…
阅读更多...
Linux 用户和权限

Linux 用户和权限

Linux 用户和权限 一、root 用户&#xff08;超级管理员&#xff09;1.su和exit命令2.sudo 命令3.为普通用户配置sudo认证 二、用户和用户组1.用户组管理2.用户管理3.getent 命令 三、查看权限控制信息1.认识权限控制信息 四、chmod命令五、chown命令 一、root 用户&#xff08…
阅读更多...
怎样理解Vue单向数据流

怎样理解Vue单向数据流

在前端开发中&#xff0c;数据流是一个非常重要的概念。Vue.js作为一种流行的前端框架&#xff0c;采用了单向数据流的架构&#xff0c;旨在简化开发过程并提高应用的可维护性。本文将探讨Vue单向数据流的含义以及它的使用方法。 什么是单向数据流&#xff1f; 在Vue中&#…
阅读更多...
天拓四方：边缘计算网关功能、特点与应用举例

天拓四方：边缘计算网关功能、特点与应用举例

传统的数据处理方式面临网络延迟、带宽限制和安全风险等问题。为了解决这些问题&#xff0c;边缘计算技术应运而生&#xff0c;而边缘计算网关作为其核心组件&#xff0c;正发挥着越来越重要的作用。边缘计算网关位于数据源和云数据中心之间。它具备数据采集、协议转换、数据处…
阅读更多...
flask+vue+python跨区通勤人员健康体检预约管理系统

flask+vue+python跨区通勤人员健康体检预约管理系统

跨区通勤人员健康管理系统设计的目的是为用户提供体检项目等功能。 与其它应用程序相比&#xff0c;跨区通勤人员健康的设计主要面向于跨区通勤人员&#xff0c;旨在为管理员和用户提供一个跨区通勤人员健康管理系统。用户可以通过系统及时查看体检预约等。 跨区通勤人员健康管…
阅读更多...
最新文章

Copyright @ 2022~2023