从0开始学人工智能测试节选：Spark -- 结构化数据领域中测试人员的万金油技术（四）

上一章节我们了解了 shuffle 相关的概念和原理后其实可以发现一个问题，那就是 shuffle 比较容易造成数据倾斜的情况。 例如上一节我们看到的图，在这批数据中，hello 这个单词的行占据了绝大部分，当我们执行 groupByKey 的时候触发了 shuffle。这时候大部分的数据 (Hello) 都汇集到了一个 partition 上。这种极端的情况就会造成著名的长尾现象，就是说由于大部分数据都汇集到了一个 partition 而造成了这个 partition 的 task 运行的十分慢。而其他的 task 早已完成，整个任务都在等这个大尾巴 task 的结束。 这种现象破坏了分布式计算的设计初衷，因为最终大部分的计算任务都在一个单点上执行了。所以极端的数据分布就成为了机器学习和大数据处理这类产品的劲敌，我跟我司的研发人员聊的时候，他们也觉得数据倾斜的情况比较难处理，当然我们可以做 repartition(重新分片) 来重新整合 parition 的数量和分布等操作，以及避免或者减少 shuffle 的成本，各家不同的业务有不同的做法。在做这类产品的性能测试的时候，也跟我们以往的互联网模式不同，产品的压力不在于并发量上，而在于数据量和数据分布上。

造数工具

一般我们需要模拟以下这些情况的数据：

  1. 数据拥有大量的分片
  2. 数据倾斜
  3. 宽表
  4. 空表
  5. 空行
  6. 空文件
  7. 中文行和中文列
  8. 超长列名
  9. 包含特殊字符的数据

下面是造数工具的架构图：

解释一下原理：

  1. 通过spark-submit把分布式计算任务提交到集群中， 可以是hadoop集群可以是spark自建的集群也可以是k8s集群， 其目的就是利用分布式计算的原理， 把造数任务分布在多个机器上进行处理。 最后汇总数据落盘到分布式存储设备中。 所以我们需要把造数逻辑编写到spark脚本中
  2. 在落盘的时候，面对不同的业务可以选择只输出到一个存储设备中， 但如果面对的是比较复杂的大数据或者机器学习系统， 那么有可能会需要把一份数据双写或者多写到不同的存储设备中， 而在spark中也是有这样的连接器帮助我们对接各种存储设备。
  3. 如果数据没有构造的特别庞大，也可以像上图那样把数据压缩导出到磁盘中，下一次换个环境使用的时候可以原封不动的再导入进去， 但是这样做的前提是数据不能非常庞大。

下面给一个使用pyspark构造数据的DEMO：

from pyspark import SparkContext, SparkConf, SQLContext

import random

from pyspark.sql.types import StructType, StructField, StringType, IntegerType





def choice_one_random(sequence):

return random.choice(sequence)





def choice_one_with_weights(sequence, weight):

return random.choices(sequence, weights=weight)[0]





def randomInt(start, end):

return random.randint(start, end)





conf = SparkConf().setMaster("local").setAppName("My App")

sc = SparkContext(conf=conf)

sqlContext = SQLContext(sc)



title = ['程序员', '教师', '测试人员', '产品经理']

gender = ['男性', '女性']

gender_weights = weights = [0.6, 0.4]



nums = sc.parallelize(range(10000))

rdd = nums.map(

lambda x: (

randomInt(1, 100),

choice_one_random(title),

choice_one_with_weights(gender, gender_weights)))



schema = StructType([

StructField("age", IntegerType(), True),

StructField("title", StringType(), True),

StructField("gender", StringType(), True),

])





data = sqlContext.createDataFrame(rdd, schema=schema)

data.show()

原理：

  1. 通过 range 在内存中生成足够数量元素的 list
  2. 通过 rdd.map 函数遍历每一个元素， 然后按照规则生成自己需要的数据
  3. 转成 dataframe 并保存到存储设备中

可以参考上面的DEMO来完成自己的造数任务， 可以看到python的库中有很多好用的功能， 比如上面我通过random库不仅可以生成随机的数据， 也可以给存储一个列表，让数据生成的时候从这个列表中选一个并且给不同的值不同的权重来控制数据的分布， 这就可以造出数据倾斜的场景。

下面给一个用java实现的例子(实际的项目中我是用java的，下面就是一个项目中的构造程序)：

package yuanhang;



import generator.field.random.RandomDateField;

import generator.field.random.RandomIntField;

import generator.field.random.RandomScopeField;

import generator.field.random.RandomStringField;

import generator.table.XRange;

import generator.utils.DateUtil;

import org.apache.spark.SparkConf;

import org.apache.spark.SparkContext;

import org.apache.spark.api.java.JavaRDD;

import org.apache.spark.api.java.JavaSparkContext;

import org.apache.spark.sql.*;

import org.apache.spark.sql.types.DataTypes;

import org.apache.spark.sql.types.StructField;

import org.apache.spark.sql.types.StructType;



import java.sql.Date;

import java.sql.Timestamp;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.time.ZoneId;

import java.util.ArrayList;

import java.util.List;

import java.util.Properties;

import org.apache.spark.util.LongAccumulator;

import java.time.LocalDate;

import java.util.Random;





/**

*/

public class event {



public static void main(String[] args) {

// SparkConf conf = new SparkConf().setAppName("data produce")

// .setMaster("local");

SparkConf conf = new SparkConf().setAppName("data produce");

JavaSparkContext sc = new JavaSparkContext(conf);



SparkSession spark = SparkSession

.builder()

.appName("Java Spark SQL basic example")

.getOrCreate();



// SparkContext sparkSC = spark.sparkContext();

List<StructField> fields = new ArrayList<>();

fields.add(DataTypes.createStructField("uin", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("app_key", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("event_time", DataTypes.DateType, true));

fields.add(DataTypes.createStructField("event_code", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("ds", DataTypes.IntegerType, true));





fields.add(DataTypes.createStructField("i001", DataTypes.IntegerType, true));

fields.add(DataTypes.createStructField("i002", DataTypes.IntegerType, true));

fields.add(DataTypes.createStructField("s001", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("s002", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("s003", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("s004", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("s005", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("s006", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("s007", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("s008", DataTypes.StringType, true));

fields.add(DataTypes.createStructField("d001", DataTypes.DoubleType, true));







StructType schema = DataTypes.createStructType(fields);



final LongAccumulator accumulator = sc.sc().longAccumulator();





// LocalDate startDate = LocalDate.of(2023, 5, 1);

LocalDate startDate = LocalDate.of(2022, 10, 30);

// LocalDate beginDate = LocalDate.of(2022, 5, 1);

LocalDate endDate = LocalDate.of(2023, 10, 30);

//default time zone

ZoneId defaultZoneId = ZoneId.systemDefault();



RandomScopeField event_codes = new RandomScopeField();

event_codes.getValues().add("app_jhapp_search_res");

event_codes.getValues().add("app_jhapp_tab_switch");

event_codes.getValues().add("app_jhapp_applnch");

event_codes.getValues().add("app_jhapp_search_ck");

event_codes.getValues().add("app_jhapp_search_page_imp");

event_codes.getValues().add("app_jhapp_search_page_ck");

event_codes.getValues().add("app_jhapp_explore_subtab_imp");

event_codes.getValues().add("app_jhapp_carousels_imp");

event_codes.getValues().add("app_jhapp_carousels_intrct");

event_codes.getValues().add("app_jhapp_first_open");

event_codes.getValues().add("app_jhapp_content_detail_imp");

event_codes.getValues().add("app_jhapp_content_detail_interact");

event_codes.getValues().add("app_jhapp_tab_imp");







while (!startDate.isAfter(endDate)) {

// System.out.println(startDate);



// List data1 = new XRange(1000);

List data1 = new XRange(274000);

JavaRDD distData = sc.parallelize(data1, 20);

DateFormat dateformat = new SimpleDateFormat("yyyyMMddhh");

Date date = new Date(java.util.Date.from(startDate.atStartOfDay(defaultZoneId).toInstant()).getTime());

// Date bDate = new Date(java.util.Date.from(beginDate.atStartOfDay(defaultZoneId).toInstant()).getTime());

// Date eDate = new Date(java.util.Date.from(endDate.atStartOfDay(defaultZoneId).toInstant()).getTime());

int ds = Integer.parseInt(dateformat.format(date));



JavaRDD rowRDD = distData.map( record ->{

RandomIntField userId = new RandomIntField();

userId.setMax(1000000);

userId.setMin(1);

// Date date = DateUtil.randomDate("2023-05-01", "2023-06-19");

RandomIntField r = new RandomIntField();

r.setMin(1);

r.setMax(100);

int i001 = Integer.parseInt(r.gen().toString());

int i002 = Integer.parseInt(r.gen().toString());



String s001 = "C"+ r.gen();

String s002 = "当前一级板" + r.gen();

String s003 = "去向一级板块" + r.gen();

String s004 = "去向一级板块" + r.gen();

String s005 = "去向一级板块" + r.gen();

String s006 = "去向一级板块" + r.gen();

String s007 = "2022090701";

String s008 = "2023090701";

double d001 = Double.parseDouble(r.gen().toString());







return RowFactory.create(userId.gen().toString(), "0WEB05LD02D5FL6K",date,event_codes.gen(),ds,i001,i002,s001,s002,s003,s004,s005,s006,s007,s008,d001);

});



Dataset dataset =spark.createDataFrame(rowRDD, schema);

dataset.show();

// DataFrameWriter writer = new DataFrameWriter(dataset);



String jdbcUrl = "jdbc:clickhouse://clickhouse-hs:8123/beacon_olap";

// String jdbcUrl = "jdbc:clickhouse://10.27.20.122:8123/beacon_olap";

Properties ckProperties = new Properties();

// ckProperties.setProperty("user", "beidou");

ckProperties.setProperty("user", "default");

ckProperties.setProperty("password", "QdFx@00700!*");

// ckProperties.setProperty("password", "Beidou@qidian");

ckProperties.setProperty("driver", "ru.yandex.clickhouse.ClickHouseDriver");

// ckProperties.setProperty("dbtable", "event_record_240");

// ckProperties.setProperty("batchsize", "50000");

// ckProperties.setProperty("isolationLevel", "NONE");

// ckProperties.setProperty("numPartitions", "12");

// ckProperties.setProperty("url", "jdbc:clickhouse://clickhouse-hs:8123/beacon_olap");



dataset.write().option("batchsize", "50000")

.option("isolationLevel", "NONE")

.option("numPartitions", "10")

.option("truncate", "true")

.option("compression", "snappy")

.mode(SaveMode.Append)

.jdbc(jdbcUrl, "event_record_273", ckProperties);



// dataset.write().mode(SaveMode.Append).jdbc(jdbcUrl, "event_record_240", ckProperties);

startDate = startDate.plusDays(1);

}





}

}

生成海量小文件

上一篇中也提到了海量的小文件是所有分布式存储设备的天敌， 我们之前在做一个车企的项目的时候， 也是要为客户搭建一个人工智能系统， 但是客户那边有20亿张图片的数据量需要做模型的训练推理（主要是计算机视觉方向，所以都是图片数据）。 所以专门引入了一个适合存储小文件的分布式存储设备（比如可以用ceph）， 这时候就需要测试在这样庞大的文件数量下，不仅仅是存储系统，还有我们的产品本身是否能符合客户的性能需要。

海量小文件的构建与之前所讲的构造方式完全不同， spark可以造大量的数据，但这些数据都是在少数文件中的， 它无法构建海量的小文件， 这是因为在spark中每个parition（这里可以理解为一个小文件， 因为如果一个比较大的数据被切分成了很多很小的文件， 那么即便这个文件只有1k，在它读取到内存的时候也会当成一个partition处理）都会生成一个独立的task来计算， 一个task可以理解为一个线程。 所以当文件数量过多时，spark就会启动非常多的线程争抢cpu资源。所以不仅仅是分布式存储系统， 在分布式计算本身，过多的文件数量都是噩梦，试想一下，当一个文件只有100w条数据，但是每条数据都单独保存在一个文件中。 这时候spark就要开启100w个线程来处理这个数据，这是多么可怕的事情。

所以以前的构造方式是无法满足我们的需要的。 就要引入另外一种机制 -- 异步IO，这是一种利用少量线程就可以支撑大并发量的技术。 因为我们常见的普通的同步IO是无法满足我们的需要的，它有如下的缺点：

  1. IO：不管是生成图片，还是把与数据库交互都会消耗网络和磁盘 io， 20 亿张图片对于 IO 的考验是比较大的
  2. CPU：如果按照传统的思路，为了提升造数性能， 会开很多个线程来并发生成图片，计算元数据和数据交互。 但线程开的太多 CPU 的上下文切换也很损耗性能。 尤其我们使用的是 ssd 磁盘，多线程的模式可能是无法最大化利用磁盘 IO 的。

后面经过讨论， 最后的方案是使用 golang 语言， 用协程 + 异步 IO 来进行造数：

  1. 首先 golang 语言的 IO 库都是使用 netpoll 进行优化过的，netpoll 底层用的就是 epoll。 这种异步 IO 技术能保证用更少的线程处理更多的文件。 关于 epoll 为什么性能好可以参考这篇文章：https://www.cnblogs.com/Hijack-you/p/13057792.html 也可以去查一下同步 IO 和异步 IO 的区别。 我大概总结一下就是， 传统的多线程 + 同步 IO 模型是开多个线程抗压力， 每个线程同一时间只处理一个 IO。 一旦 IO 触发开始读写文件线程就会处于阻塞状态， 这个线程就会从 CPU 队列中移除也就是切换线程。 等 IO 操作结束了再把线程放到 CPU 队列里让线程继续执行下面的操作，而异步 IO 是如果一个线程遇到了 IO 操作，它不会进入阻塞状态， 而是继续处理其他的事， 等到那个 IO 操作结束了再通知程序（通过系统中断），调用回调函数处理后面的事情。 这样就保证了异步 IO 的机制下可以用更少的线程处理更多的 IO 操作。 这是为什么异步 IO 性能更好的原因，也是为什么异步 IO 能最大化利用磁盘性能。 比如在这个造图片的场景里， 我在内存中造好图片后，开始写入文件系统， 如果是同步 IO 那这时候就要阻塞了，直到文件写入完毕线程才会继续处理， 但因为我用的异步 IO， 调用玩函数让内存中的数据写入到文件就不管了， 直接开始造下一张图片， 什么时候 IO 结束通知我我在回过头来处理。 所以是可以用更少的线程来完成更多的 IO 操作也就是异步 IO 能很容易的把磁盘性能打满。 我自己测试的时候再自己的笔记本上造 100k 的图片， 大概是 1s 就能造 1W 张图片
  2. 其次 golang 的 GMP 模型本身就很高效， 编写异步程序也非常简单。 我也就花了一上午就把脚本写完了。
  3. 最后利用 k8s 集群把造数任务调度到集群中， 充分利用分布式计算的优势， 在多台机器上启动多个造数任务共同完成。

代码实现：

package main



import (

"crypto/md5"

"encoding/hex"

"fmt"

"io/ioutil"

"math/rand"

"net/http"

"os"

"path"

"sync"

"time"

)



var (

fileQueue = make(chan FileInfo, 1000) // 缓冲队列，用来存储文件key, 方便后面的协程取出来插入数据库

sourceFiles = []string{"asfdf.png"} // 复制的源文件

sourceFileCache sync.Map // 缓存源文件内容， 避免每次copy都重新读取源文件

)



const (

destDir = "file" // 需要复制的目录路径

copyNumber = 10 // 每个协程需要copy的文件数量

)



// 文件 信息

type FileInfo struct {

key string

createdAt time.Time

}



// 生成随机字符串

func GetRandomString(n int) string {

str := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

bytes := []byte(str)

var result []byte

for i := 0; i < n; i++ {

result = append(result, bytes[rand.Intn(len(bytes))])

}

return string(result)

}



func copyFile(src, dst string) ([]byte, int64, error) {



var input []byte

if data, ok := sourceFileCache.Load(src); ok {

input = data.([]byte)

} else {

data, err := ioutil.ReadFile(src)

if err != nil {

return []byte{}, 0, err

}

input = data

sourceFileCache.Store(src, input)

}



err := ioutil.WriteFile(dst, input, 0644)

if err != nil {

return []byte{}, 0, err

}



fi, err := os.Stat(dst)

if err != nil {

return []byte{}, 0, err

}



return input, fi.Size(), nil

}



func copyFiles(wg *sync.WaitGroup) {

defer wg.Done()

for i := 0; i < copyNumber; i++ {

// 随机种子

rand.Seed(time.Now().UnixNano())



// 从源文件中选择一个文件进行copy

sourceFileCount := len(sourceFiles)

sourceFilePath := sourceFiles[rand.Intn(sourceFileCount)]



// 生成随机的文件名称

fileName := GetRandomString(30) + ".jpg"

destFilePath := path.Join(destDir, fileName)



data, size, err := copyFile(sourceFilePath, destFilePath)

if err != nil {

fmt.Printf("copyFile file from %s to %s err, the message is %s", sourceFilePath, destFilePath, err.Error())

}



key, err := NewUploadFileKey("superadmin", fileName, md5V(string(data)), size)

if err != nil {

fmt.Printf("gen file key error, the message is %s", err.Error())

}

fileQueue <- FileInfo{

key: key,

createdAt: time.Now(),

}

}

}



func parseBasenameFromURI(uri string) (string, error) {

r, _ := http.NewRequest("GET", uri, nil)

return path.Base(r.URL.Path), nil

}



func NewUploadFileKey(uin, filename, hash string, size int64) (string, error) {

str := fmt.Sprintf("uin:%s-hash:%s-size:%d", uin, hash, size)

basename, err := parseBasenameFromURI(filename)

if err != nil {

return "", err

}

partHash := md5V(str)

result := md5V(fmt.Sprintf("hash:%s-name:%s", partHash, filename))

content := md5V(fmt.Sprintf("%s-%s-%s", result[8:10], result[10:], basename))

u := fmt.Sprintf("%s%s/%s/%s-%s", "upload/", result[8:10], content[8:10], result[10:], basename)

return u, nil

}



func md5V(str string) string {

h := md5.New()

h.Write([]byte(str))

return hex.EncodeToString(h.Sum(nil))

}



func main() {

var wg1 sync.WaitGroup

wg1.Add(10)

for i := 0; i < 10; i++ {

go copyFiles(&wg1)

}



// 等待所有复制文件的协程结束

go func() {

wg1.Wait()

// 关闭chan, 通知插入数据的协程， 文件都已经复制完毕

close(fileQueue)

fmt.Println("关闭通道")

}()



// 使用10个线程来插入数据库

var wg2 sync.WaitGroup

wg2.Add(10)

for i := 0; i < 10; i++ {

go insert(&wg2)

}

wg2.Wait()

fmt.Println("数据生成完毕")

}



// 从chan中取出文件key插入数据库

func insert(wg *sync.WaitGroup) {

defer wg.Done()

var cache []FileInfo



for fileInfo := range fileQueue {

if len(cache) < 1000 {

cache = append(cache, fileInfo)

//fmt.Println("数据没到1000条， 继续缓存")

} else {

// todo 将1000条数据插入到数据库中

fmt.Println("积累了1k个文件， 开始插入数据库")

}

}

// todo for循环结束说明队列已经被关闭， 所有文件都copy完毕这时候需要缓存中剩余的记录一块插入到数据库中

fmt.Println("通道已经关闭， 现在开始把剩余的插入到数据库中")

//fmt.Println(cache)

for _, fileInfo := range cache{

fmt.Println(fileInfo.key)

}

}

因为golang原生就支持异步IO，实现起来最简单便选择了golang语言，对于go语言不熟悉的同学也可以查找一下python语言的异步io库

 更多内容欢迎来到我的知识星球：
 

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

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

相关文章

FL Studio21.2.8中文版水果音乐制作的革新之旅！

FL Studio21.2.8中文版水果音乐制作的革新之旅！

在数字化浪潮的推动下&#xff0c;音乐制作领域经历了翻天覆地的变化。从最初的模拟技术到如今的全数字化处理&#xff0c;音乐制作的门槛被大幅降低&#xff0c;越来越多的音乐爱好者和专业人士开始尝试自行创作和编辑音乐。在这个过程中&#xff0c;各种专业音乐制作软件成为…
阅读更多...
孵化器补贴政策提问模板

孵化器补贴政策提问模板

对于一些需要创业的人来说&#xff0c;找场地是非常非常难的&#xff0c;一个好的场地能够提高创业的成功率&#xff0c;下面这些内容对于孵化器产业园的政策有一个好的提问&#xff0c;可以帮助你们了解这个孵化器合不合适。需要创业的人可以收藏 某孵化器政策示例 提问模板 …
阅读更多...
Java进制转换

Java进制转换

进制介绍 二进制&#xff1a;0B开头&#xff0c;0-1 八进制&#xff1a;0开头&#xff0c;0-7 十进制&#xff1a;0-9 十六进制&#xff1a;0x开头&#xff0c;0-9和A-F public class Binary{public static void main(String[] args){//二进制 10int n10B1010//十进制 1010int…
阅读更多...
短视频动画脚本：成都鼎茂宏升文化传媒公司

短视频动画脚本：成都鼎茂宏升文化传媒公司

短视频动画脚本&#xff1a;创作与魅力的探索 在数字化时代的浪潮中&#xff0c;短视频动画以其独特的魅力迅速崛起&#xff0c;成为大众娱乐和信息传播的重要载体。成都鼎茂宏升文化传媒公司作为一名原创文章编辑&#xff0c;我深入探索了短视频动画脚本的创作过程&#xff0…
阅读更多...
揭秘GPU技术新趋势：从虚拟化到池化

揭秘GPU技术新趋势：从虚拟化到池化

从GPU虚拟化到池化 大模型兴起加剧GPU算力需求&#xff0c;企业面临GPU资源有限且利用率不高的挑战。为打破这一瓶颈&#xff0c;实现GPU算力资源均衡与国产化替代&#xff0c;GPU算力池化成为关键。本文深入探讨GPU设备虚拟化途径、共享方案及云原生实现&#xff0c;旨在优化资…
阅读更多...
大模型学习资料整理：如何从0到1学习大模型，搭建个人或企业RAG系统，如何评估与优化（更新中...）

大模型学习资料整理：如何从0到1学习大模型，搭建个人或企业RAG系统，如何评估与优化（更新中...）

通过本文您可以了解到&#xff1a; 学习&#xff1a;从小白如何入手&#xff0c;从0到1开始学习大模型。RAG系统&#xff1a;我想搭建属于自己或者企业的RAG系统&#xff0c;我该怎么去做&#xff1f;评估&#xff1a;微调后的模型或者RAG系统&#xff0c;如何评估自己的模型和…
阅读更多...
软件质量保障——三、四

软件质量保障——三、四

三、黑盒测试 1.黑盒测试概述 1.1 如何理解黑盒测试&#xff1f; 1.2 黑盒测试有什么特点&#xff1f; 1.3 如何实施黑盒测试&#xff1f; 2. 黑盒测试用例设计和生成方法&#xff08;这里还是要自己找题做&#xff09; 2.1 等价类划分法 步骤&#xff1a; 1.选择划分准…
阅读更多...
设置电脑定时关机

设置电脑定时关机

1.使用快捷键winR 打开运行界面 2.输入cmd &#xff0c;点击确认&#xff0c;打开命令行窗口&#xff0c;输入 shutdown -s -t 100&#xff0c;回车执行命令&#xff0c;自动关机设置成功 shutdown: 这是主命令&#xff0c;用于执行关闭或重启操作。-s: 这个参数用于指定执行关…
阅读更多...
flask音乐交流平台-计算机毕业设计源码57105

flask音乐交流平台-计算机毕业设计源码57105

摘要 科技进步的飞速发展引起人们日常生活的巨大变化&#xff0c;电子信息技术的飞速发展使得电子信息技术的各个领域的应用水平得到普及和应用。信息时代的到来已成为不可阻挡的时尚潮流&#xff0c;人类发展的历史正进入一个新时代。在现实运用中&#xff0c;应用软件的工作规…
阅读更多...
kafka-生产者监听器（SpringBoot整合Kafka）

kafka-生产者监听器（SpringBoot整合Kafka）

文章目录 1、生产者监听器1.1、创建生产者监听器1.2、发送消息测试1.3、使用Java代码创建主题分区副本1.4、application.yml配置----v1版1.5、屏蔽 kafka debug 日志 logback.xml1.6、引入spring-kafka依赖1.7、控制台日志 1、生产者监听器 1.1、创建生产者监听器 package co…
阅读更多...
鸿蒙开发接口安全：【@ohos.abilityAccessCtrl (访问控制管理)】

鸿蒙开发接口安全：【@ohos.abilityAccessCtrl (访问控制管理)】

访问控制管理 说明&#xff1a; 本模块首批接口从API version 8开始支持。后续版本的新增接口&#xff0c;采用上角标单独标记接口的起始版本。 导入模块 import abilityAccessCtrl from ohos.abilityAccessCtrlabilityAccessCtrl.createAtManager createAtManager(): AtMan…
阅读更多...
用户管理的小demo --登录：

用户管理的小demo --登录：

目录 1、建库、建表 1.1 连接数据库后&#xff0c;在idea中 通过快捷方式 自动导入实体类 1.2 实体类代码 2、idea中的准备工作 2.1 在父工程下 新建子工程 2.2 在子工程下 添加webapp、pom.xml设置为 war的打包方式 2.3 在父工程下的pom.xml中 添加依赖 2.3.1 mysql的…
阅读更多...
基于STC12C5A60S2系列1T 8051单片机实现一主单片机与一从单片机相互发送数据的RS485通信功能

基于STC12C5A60S2系列1T 8051单片机实现一主单片机与一从单片机相互发送数据的RS485通信功能

基于STC12C5A60S2系列1T 8051单片机实现一主单片机与一从单片机相互发送数据的RS485通信功能的RS485通信功能 STC12C5A60S2系列1T 8051单片机管脚图STC12C5A60S2系列1T 8051单片机串口通信介绍STC12C5A60S2系列1T 8051单片机串口通信的结构基于STC12C5A60S2系列1T 8051单片机串…
阅读更多...
力扣hot100学习记录(十一)

力扣hot100学习记录(十一)

24. 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 题意 两两交换链表中的相邻节点 思路 先创建一个…
阅读更多...
机器学习知识点总结

机器学习知识点总结

简介&#xff1a;随着人工智能&#xff08;AI&#xff09;蓬勃发展&#xff0c;也有越来越多的人涌入到这一行业。下面简单介绍一下机器学习的各大领域&#xff0c;机器学习包含深度学习以及强化学习&#xff0c;在本节的机器学习中主要阐述一下机器学习的线性回归逻辑回归&…
阅读更多...
嘉之音：十年磨一剑 敢为天下先

嘉之音：十年磨一剑 敢为天下先

一个产品创新 一个行业成长 一段人生价值 不断积累、沉淀、创新&#xff0c;终将实现其价值。 前十年&#xff0c;嘉之音经历了传统建材行业的变迁&#xff1b;声学聚酯自2010年初诞生&#xff0c;现在正在从第一个十年萌芽期进入高速成长黄金期。近年来&#xff0c;市场的不…
阅读更多...
A6370超速保护监控器

A6370超速保护监控器

A6370监控器是AMS 6300 SIS超速保护系统的一部分&#xff0c;并且 与A6371一起安装在19英寸机架中(84HP宽&#xff0c;3RU高) 系统底板。一个AMS 6300 SIS由三个保护监视器(A6370)组成 和一个背板(A6371)。 该系统设计用于涡流传感器、霍尔元件传感器和 磁性(VR)传感器。 传感器…
阅读更多...
鸿蒙Ability Kit（程序框架服务）【UIExtensionAbility】

鸿蒙Ability Kit（程序框架服务）【UIExtensionAbility】

UIExtensionAbility 概述 [UIExtensionAbility]是UI类型的ExtensionAbility组件&#xff0c;需要与[UIExtensionComponent]一起配合使用&#xff0c;开发者可以在UIAbility的页面中通过UIExtensionComponent嵌入提供方应用的UIExtensionAbility提供的UI。UIExtensionAbility会…
阅读更多...
strcpy、strncpy、strcat、strncat、strcmp、strstr字符串函数的使用和模拟

strcpy、strncpy、strcat、strncat、strcmp、strstr字符串函数的使用和模拟

strcpy的使用和模拟&#xff08;作用&#xff09; 将一个字符串的内容复制到另外一个字符串中代替掉。 strcpy的使用效果 #include <stdio.h> #include <string.h>int main () {char str1[]"Sample string";char str2[40];char str3[40];strcpy (str2…
阅读更多...
【学习笔记】Windows GDI绘图(十一)Graphics详解(下)

【学习笔记】Windows GDI绘图(十一)Graphics详解(下)

文章目录 Graphics的方法Graphics.FromImageSetClip设置裁切区域IntersectClip更新为相交裁切区域TranslateClip平移裁切区域IsVisible判断点或矩形是否在裁切区域内MeasureCharacterRanges测量字符区域MeasureString测量文本大小MultiplyTransform矩阵变换 Graphics的方法 Gr…
阅读更多...
最新文章

Copyright @ 2022~2023