[在线报销流程自动化解决方案 ]的搜索结果

...应用场景愈发广泛，如在线协作工具、实时交易系统、游戏开发、物联网设备数据同步等领域。 2021年，Mozilla发布了一篇关于WebSocket性能优化的文章，其中详细介绍了如何针对现代浏览器进行WebSocket连接的性能调优，包括握手过程、数据帧压缩以及多路复用等高级特性。同时，随着HTTP/3的推进，WebSocket在QUIC协议上的实验性支持也在逐步展开，未来有望实现更快速、更稳定的长连接通信。 另外，各大云服务商如AWS、阿里云等也纷纷推出了对WebSocket服务的支持，通过Serverless架构和WebSocket API，开发者可以更加便捷地构建基于WebSocket的应用程序，并能有效解决WebSocket服务器的运维与扩展问题。 此外，对于安全性方面，最新的WebSocket安全实践指南强调了加密传输、防篡改机制以及权限验证等方面的重要性，确保在提供实时通信能力的同时，保障用户数据的安全。 总之，在WebSocket技术不断发展的今天，掌握其原理并关注相关领域的前沿动态，将有助于开发者更好地应对实际项目中的挑战，提升用户体验和系统性能。

...挺机灵的！它能帮咱们解决一个大难题——就是那些疯了似的并发请求，就像一群蚂蚁围攻面包，瞬间就把服务器给淹没了。这样不仅能让我们的服务器喘口气，不至于被这些请求给累趴下，还能给那些没权没份的家伙们上上锁，别让他们乱用咱们的API，搞得咱们这边乱七八糟的。这招儿，既保护了服务器，又守住了规矩，真是一举两得啊！ gin-contrib/ratelimit 提供了一种简单且灵活的方式来配置和应用速率限制规则。它支持多种存储后端，包括内存、Redis 和数据库等，以适应不同的应用场景需求。 三、安装与初始化 首先，确保你的 Go 环境已经配置好，并且安装了 gin-contrib/ratelimit 库。可以通过以下命令进行安装： bash go get github.com/gin-contrib/ratelimit 接下来，在你的 Gin 应用中引入并初始化 ratelimit 包： go import ( "github.com/gin-contrib/ratelimit" "github.com/gin-gonic/gin" ) func main() { r := gin.Default() // 配置限流器 limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, // 允许每分钟最多5次请求 Duration: time.Minute, }) // 将限流器应用于路由 r.Use(limiter) // 定义路由 r.GET("/api", func(c gin.Context) { c.JSON(200, gin.H{"message": "Hello, World!"}) }) r.Run(":8080") } 四、高级功能与自定义 除了基本的速率限制配置外，gin-contrib/ratelimit 还提供了丰富的高级功能，允许开发者根据具体需求进行定制化设置。 - 基于 IP 地址的限制： go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, Duration: time.Minute, PermitsBy: ratelimit.PermitByIP, }) - 基于 HTTP 请求头的限制： go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, Duration: time.Minute, PermitsBy: ratelimit.PermitByHeader("X-User-ID"), }) - 基于用户会话的限制： go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, Duration: time.Minute, PermitsBy: ratelimit.PermitBySessionID, }) 这些高级功能允许你更精细地控制哪些请求会被限制，从而提供更精确的访问控制策略。 五、实践案例 基于 IP 地址的限流 假设我们需要限制某个特定 IP 地址的访问频率： go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 10, // 每小时最多10次请求 Duration: time.Hour, PermitsBy: ratelimit.PermitByIP, }) // 在路由上应用限流器 r.Use(limiter) 六、性能考量与优化 在实际部署时，考虑到速率限制的性能影响，合理配置限流参数至关重要。哎呀，你得注意了，设定安全防护的时候，这事儿得拿捏好度才行。要是设得太严，就像在门口挂了个大锁，那些坏人进不来，可合法的访客也被挡在外头了，这就有点儿不地道了。反过来，如果设置的门槛太松，那可就相当于给小偷开了个后门，让各种风险有机可乘。所以啊，找那个平衡点，既不让真正的朋友感到不便，又能守住自家的安全，才是王道！因此，建议结合业务场景和流量预测进行参数调整。 同时，选择合适的存储后端也是性能优化的关键。哎呀，你知道的，在处理那些超级多人同时在线的情况时，咱们用 Redis 来当存储小能手，那效果简直不要太好！它就像个神奇的魔法箱，能飞快地帮我们处理各种数据，让系统运行得又顺溜又高效，简直是高并发环境里的大救星呢！ 七、结论 通过集成 gin-contrib/ratelimit，我们不仅能够有效地管理 API 访问频率，还能够在保障系统稳定运行的同时，为用户提供更好的服务体验。嘿，兄弟！业务这玩意儿，那可是风云变幻，快如闪电。就像你开车，路况不一，得随时调整方向，对吧？API安全性和可用性这事儿，就跟你的车一样重要。所以，咱们得像老司机一样，灵活应对各种情况，时不时地调整和优化限流策略。这样，不管是高峰还是低谷，都能稳稳地掌控全局，让你的业务顺畅无阻，安全又高效。别忘了，这可是保护咱们业务不受攻击，保证用户体验的关键！希望本文能够帮助你更好地理解和应用 gin-contrib/ratelimit，在构建强大、安全的 API 时提供有力的支持。

...秘，不光是告诉你怎么解决，还会给你分享一些超级实用的小秘诀和实战经验。就像老朋友在你耳边悄悄告诉你那些能让你事半功倍的小窍门，让你在面对挑战时更有底气！ 二、深入浅出 理解Golang中的内存管理机制 在Golang中，内存管理是一个自动且复杂的系统。它通过垃圾回收（Garbage Collection, GC）机制来释放不再使用的内存，从而避免了传统的手动内存管理带来的种种问题。嘿，你知道吗？这个系统啊，虽然挺厉害的，但是也不是无敌的！特别是当我们用它来处理超多数据或者同时进行好多操作的时候，如果程序设计不当，就可能会遇到内存不够的问题。就像是你家的冰箱，容量有限，放太多东西就会爆满一样。所以，咱们在使用的时候可得小心点，别让程序“吃”掉所有内存！ 三、案例分析 内存泄漏的陷阱 示例代码1： go package main import "fmt" func main() { var largeArray [1000000]int // 创建一个大数组 for i := 0; i < 1000000; i++ { largeArray[i] = i i // 每个元素都是i的平方 } fmt.Println("Memory usage:", memoryUsage()) // 打印内存使用情况 } // 计算当前进程的内存使用量 func memoryUsage() int64 { // 实际的内存计算函数，这里简化为返回固定值 return 1024 1024 10 // 单位为字节 } 这段代码看似简单，却隐藏着内存泄漏的陷阱。哎呀，你瞧这大数组largeArray在循环里头转悠，占了满满一屋子的空间呢！可别小看了这事儿，要是循环一结束，咱们不赶紧把用过的资源还回去，那这些宝贵的空间就白白浪费了，慢慢地，咱们手里的内存就像水龙头的水一样，越用越少，到最后可能连最基本的运行都成问题啦！所以啊，记得干完活儿就收工，别让资源闲置！ 四、应对策略 识别并解决内存问题 策略1：合理使用内存池（Memory Pool） 内存池是一种预先分配并管理内存块的方法，可以减少频繁的内存分配和释放带来的性能损耗。在Golang中，可以通过sync.Pool来实现内存池的功能。 go package main import ( "sync" ) var pool = sync.Pool{ New: func() interface{} { return make([]int, 1000) }, } func main() { for i := 0; i < 1000; i++ { data := pool.Get().([]int) // 从内存池获取数据 defer pool.Put(data) // 使用完毕后归还到内存池 // 对数据进行操作... } } 策略2：优化数据结构和算法 在处理大量数据时，选择合适的数据结构和算法对于降低内存消耗至关重要。例如，使用链表而非数组，可以避免一次性分配大量内存。 策略3：使用Go的内置工具检查内存使用情况 利用pprof工具可以深入了解程序的内存使用情况，帮助定位内存泄漏点。 sh go tool pprof ./your_binary 五、实战演练 构建一个安全的并发处理程序 在并发场景下，内存管理变得更加复杂。错误的并发控制策略可能导致死锁或内存泄露。 示例代码2： go package main import ( "sync" "time" ) var wg sync.WaitGroup var mutex sync.Mutex func worker(id int) { defer wg.Done() time.Sleep(5 time.Second) mutex.Lock() defer mutex.Unlock() fmt.Printf("Worker %d finished\n", id) } func main() { for i := 0; i < 10; i++ { wg.Add(1) go worker(i) } wg.Wait() } 通过合理使用sync.WaitGroup和sync.Mutex，我们可以确保所有工作线程安全地执行，并最终正确地关闭所有资源。 六、结语 从错误中学习，不断进步 面对“内存不足错误”，关键在于理解其背后的原因，而不是简单的错误提示。通过实践、分析和优化，我们不仅能解决眼前的问题，还能提升代码质量和效率。记住，每一次挑战都是成长的机会，让我们带着对技术的好奇心和探索精神，不断前进吧！ --- 本文旨在提供一个全面的视角，帮助开发者理解和解决Golang中的内存管理问题。嘿，无论你是编程界的菜鸟还是老司机，记得，内存管理这事儿，可得放在心上！就像开车得注意油表一样，编程时管理好内存，能让你的程序跑得又快又好，不卡顿，不崩盘。别怕，多练练手，多看看教程，慢慢你就成了那个内存管理的小能手。记住，学无止境，技术提升也是这样，一点一滴积累，你的编程技能肯定能上一个大台阶！

...新，将有助于优化业务流程，提升数据分析效率，进而驱动业务增长。 --- 通过这次“延伸阅读”，我们可以看到MongoDB作为一款广泛使用的NoSQL数据库，在持续优化其功能以满足日益增长的性能需求和安全性要求。这种不断迭代的技术进步不仅反映了MongoDB团队致力于提升用户体验和解决实际问题的决心，也为广大开发者和数据库管理员提供了更多创新的工具和策略，以应对复杂的数据管理和分析挑战。

...文件系统的问题排查与解决 一、引言 Hive与HDFS的亲密关系 大家好啊！今天咱们聊聊Hive和HDFS这对CP（组合）。Hive 这个东西呢，其实就是个搭在 Hadoop 身上的数据仓库工具，说白了嘛，它的工作方式特别直白——把你的 SQL 查询语句给翻译成 MapReduce 任务，然后甩给 Hadoop 去干活儿。而HDFS呢，就是存储这些数据的地方。它们就像一对老朋友，互相依赖，缺一不可。 但有时候，这俩家伙可能会闹别扭，尤其是当你发现Hive突然不能访问HDFS了。这可真是让人头疼，因为这意味着你的数据查询直接凉凉。所以今天我们就来聊聊，为什么会出现这种情况，以及该怎么解决。 二、可能的原因 为什么Hive访问不了HDFS？ 2.1 网络问题 首先，我们得想想是不是网络出了问题。嘿，你知道吗？我猜你们公司那位网络大神最近是不是偷偷调整了防火墙的设置？或者是服务器那边抽风了，直接断网了？反正不管咋回事儿，现在Hive跟HDFS就像是隔了一座大山，怎么也连不上，所以它想读数据都读不到啊！ 举个例子吧，假设你的Hive配置文件里写着HDFS的地址是hdfs://namenode:9000/，但是实际上NameNode所在的机器根本不在网络范围内，那Hive当然会报错啦。 解决方法：检查一下网络连接是否正常。你可以试着ping一下HDFS的NameNode地址，看看能不能通。如果不行的话，赶紧找网络管理员帮忙修一下。 2.2 权限问题 其次，权限问题也是常见的原因。HDFS对文件和目录是有严格权限控制的，如果你的用户没有足够的权限去读取某个文件，那么Hive自然也无能为力。 举个栗子，假如你有一个HDFS路径/user/hive/warehouse/my_table，但是这个目录的权限设置成了只有root用户才能访问，而你的Hive用户不是root，那肯定就悲剧了。 解决方法：检查HDFS上的文件和目录权限。如果你想看看某个文件的权限，可以用这个命令：hadoop fs -ls /path/to/file。看完之后，要是觉得权限不对劲，就动手改一下呗，比如说用hadoop fs -chmod 755 /path/to/file，给它整成合适的权限就行啦！ 2.3 HDFS服务未运行 还有一种可能是HDFS服务本身挂掉了。比如说，NameNode突然罢工了，DataNode也闹起了情绪，甚至整个集群都瘫痪了，啥都不干了。哎呀糟糕了，这情况有点悬啊！HDFS直接罢工了，完全不干活，任凭Hive使出浑身解数也无济于事。这下可好，整个系统像是瘫了一样，啥也跑不起来了。 解决方法：检查HDFS的服务状态。可以通过命令jps查看是否有NameNode和DataNode进程在运行。如果没有，那就得赶紧启动它们，或者重启整个HDFS服务。 三、实战演练 Hive访问HDFS的具体操作 接下来，我们通过一些实际的例子来看看如何用Hive操作HDFS。 3.1 创建表并加载数据到HDFS 假设我们现在要创建一个简单的表，并将数据加载到HDFS中。我们可以先创建一个本地文件data.txt，内容如下： id,name,age 1,Alice,25 2,Bob,30 3,Charlie,35 然后上传到HDFS： bash hadoop fs -put data.txt /user/hive/warehouse/my_table/ 接着在Hive中创建表： sql CREATE TABLE my_table ( id INT, name STRING, age INT ) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' STORED AS TEXTFILE; 最后加载数据： sql LOAD DATA INPATH '/user/hive/warehouse/my_table/data.txt' INTO TABLE my_table; 这样，我们的数据就成功存到了HDFS上，并且Hive也能读取到了。 3.2 查询数据 现在我们可以试试查询数据： sql SELECT FROM my_table; 如果一切正常，你应该能看到类似这样的结果： OK 1 Alice 25 2 Bob 30 3 Charlie 35 Time taken: 0.077 seconds, Fetched: 3 row(s) 但如果之前出现了访问不了HDFS的情况，这里就会报错。所以我们要确保每一步都正确无误。 四、总结与展望 总之，Hive无法访问HDFS的问题虽然看起来很复杂，但实际上只要找到根本原因，解决起来并不难。无论是网络问题、权限问题还是服务问题，都有相应的解决办法。嘿，大家听我说啊！以后要是再碰到这种事儿，别害怕，也别乱了阵脚。就当是玩个解谜游戏，一步一步慢慢来，肯定能找出办法搞定它！ 未来，随着大数据技术的发展，Hive和HDFS的功能也会越来越强大。说不定哪天它们还能像人类一样交流感情呢！（开玩笑啦） 好了，今天的分享就到这里啦。如果你还有什么疑问或者经验想要分享，欢迎随时留言讨论哦！让我们一起进步，一起探索大数据的奥秘吧！

...不被使用的内存空间，解决了管理内存空间的烦恼。 Java 语言是一种分布式的面向对象语言，具有面向对象、平台无关性、简单性、解释执行、多线程、安全性等很多特点，下面针对这些特点进行逐一介绍。 1. 面向对象 Java 是一种面向对象的语言，它对对象中的类、对象、继承、封装、多态、接口、包等均有很好的支持。为了简单起见，Java 只支持类之间的单继承，但是可以使用接口来实现多继承。使用 Java 语言开发程序，需要采用面向对象的思想设计程序和编写代码。 2. 平台无关性 平台无关性的具体表现在于，Java 是“一次编写，到处运行（Write Once，Run any Where）”的语言，因此采用 Java 语言编写的程序具有很好的可移植性，而保证这一点的正是 Java 的虚拟机机制。在引入虚拟机之后，Java 语言在不同的平台上运行不需要重新编译。 Java 语言使用 Java 虚拟机机制屏蔽了具体平台的相关信息，使得 Java 语言编译的程序只需生成虚拟机上的目标代码，就可以在多种平台上不加修改地运行。 3. 简单性 Java 语言的语法与 C 语言和 C++ 语言很相近，使得很多程序员学起来很容易。对 Java 来说，它舍弃了很多 C++ 中难以理解的特性，如操作符的重载和多继承等，而且 Java 语言不使用指针，加入了垃圾回收机制，解决了程序员需要管理内存的问题，使编程变得更加简单。 4. 解释执行 Java 程序在 Java 平台运行时会被编译成字节码文件，然后可以在有 Java 环境的操作系统上运行。在运行文件时，Java 的解释器对这些字节码进行解释执行，执行过程中需要加入的类在连接阶段被载入到运行环境中。 5. 多线程 Java 语言是多线程的，这也是 Java 语言的一大特性，它必须由 Thread 类和它的子类来创建。Java 支持多个线程同时执行，并提供多线程之间的同步机制。任何一个线程都有自己的 run() 方法，要执行的方法就写在 run() 方法体内。 6. 分布式 Java 语言支持 Internet 应用的开发，在 Java 的基本应用编程接口中就有一个网络应用编程接口，它提供了网络应用编程的类库，包括 URL、URLConnection、Socket 等。Java 的 RIM 机制也是开发分布式应用的重要手段。 7. 健壮性 Java 的强类型机制、异常处理、垃圾回收机制等都是 Java 健壮性的重要保证。对指针的丢弃是 Java 的一大进步。另外，Java 的异常机制也是健壮性的一大体现。 8. 高性能 Java 的高性能主要是相对其他高级脚本语言来说的，随着 JIT（Just in Time）的发展，Java 的运行速度也越来越高。 9. 安全性 Java 通常被用在网络环境中，为此，Java 提供了一个安全机制以防止恶意代码的攻击。除了 Java 语言具有许多的安全特性以外，Java 还对通过网络下载的类增加一个安全防范机制，分配不同的名字空间以防替代本地的同名类，并包含安全管理机制。 Java 语言的众多特性使其在众多的编程语言中占有较大的市场份额，Java 语言对对象的支持和强大的 API 使得编程工作变得更加容易和快捷，大大降低了程序的开发成本。Java 的“一次编写，到处执行”正是它吸引众多商家和编程人员的一大优势。 扩展知识： 按应用范围，Java 可分为 3 个体系，即 Java SE、Java EE 和 Java ME。下面简单介绍这 3 个体系。 1. Java SE Java SE（Java Platform Standard Edition，Java 平台标准版）以前称为 J2SE，它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java EE 提供基础，如 Java 语言基础、JDBC 操作、I/O 操作、网络通信以及多线程等技术。图 1 所示为 Java SE 的体系结构。 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_73892801/article/details/129181633。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...不上话！所以说啊，在解决Dubbo问题的时候，咱们得结合实际情况来分析，不能一概而论。就像穿衣服一样，得看天气、场合啥的，对吧？ --- 二、Dubbo报错信息的特点与常见原因 Dubbo的报错信息通常会包含一些关键信息，比如服务名称、接口版本、错误堆栈等。不过啊，这些东西通常不会直接告诉我们哪里出了岔子，得我们自己去刨根问底才行。 比如说，你可能会看到这样的报错： Failed to invoke remote method: sayHello, on 127.0.0.1:20880 看到这个错误，你是不是会觉得很懵？其实这可能是因为你的服务端没有正确启动，或者客户端的配置不对。又或者是网络不通畅，导致客户端无法连接到服务端。 再比如，你可能会遇到这种错误： No provider available for the service com.example.UserService on the consumer 192.168.1.100 use dubbo version 2.7.8 这表明你的消费者（也就是客户端）找不到提供者（也就是服务端）。哎呀，这问题八成是服务注册中心没整利索，要不就是服务提供方压根没成功注册上。 我的建议是，遇到这种问题时，先别急着改代码，而是要冷静下来分析一下，是不是配置文件出了问题。比如说，你是不是忘记在dubbo.properties里填对了服务地址？ --- 三、排查报错的具体步骤 接下来，咱们来聊聊怎么排查这些问题。首先，你需要确认服务端是否正常运行。你可以通过以下命令查看服务端的状态： bash netstat -tuln | grep 20880 如果看不到监听的端口，那肯定是服务端没启动成功。 然后，检查服务注册中心是否正常工作。Dubbo支持多种注册中心，比如Zookeeper、Nacos等。如果你用的是Zookeeper，可以试试进入Zookeeper的客户端，看看服务是否已经注册： bash zkCli.sh -server 127.0.0.1:2181 ls /dubbo/com.example.UserService 如果这里看不到服务，那就说明服务注册中心可能有问题。 最后，别忘了检查客户端的配置。客户端的配置文件通常是dubbo-consumer.xml，里面需要填写服务提供者的地址。例如： xml 如果地址写错了，当然就会报错了。 --- 四、代码示例与实际案例分析 下面我给大家举几个具体的例子，让大家更直观地了解Dubbo的报错排查过程。 示例1：服务启动失败 假设你在本地启动服务端时，发现服务一直无法启动，报错如下： Failed to bind URL: dubbo://192.168.1.100:20880/com.example.UserService?anyhost=true&application=demo-provider&dubbo=2.7.8&interface=com.example.UserService&methods=sayHello&pid=12345&side=provider×tamp=123456789 经过检查，你会发现是因为服务端的application.name配置错了。修改后，重新启动服务端，问题就解决了。 示例2：服务找不到 假设你在客户端调用服务时，发现服务找不到，报错如下： No provider available for the service com.example.UserService on the consumer 192.168.1.100 use dubbo version 2.7.8 经过排查，你发现服务注册中心的地址配置错了。正确的配置应该是： xml 示例3：网络不通 假设你在生产环境中，发现客户端和服务端之间的网络不通，报错如下： ConnectException: Connection refused 这时候，你需要检查防火墙设置，确保服务端的端口是开放的。同时，也要检查客户端的网络配置，确保能够访问服务端。 --- 五、总结与感悟 总的来说，Dubbo的报错信息确实有时候让人摸不着头脑，但它并不是不可战胜的。只要你细心排查，结合具体的环境和配置，总能找到问题的根源。 在这个过程中，我学到的东西太多了。比如说啊，别啥都相信默认设置，每一步最好自己动手试一遍，心里才踏实。再比如说，碰到问题的时候，先别忙着去找同事求助，自己多琢磨琢磨，说不定就能找到解决办法了呢！毕竟，编程的乐趣就在于不断解决问题的过程嘛！ 最后，我想说的是，Dubbo虽然复杂，但它真的很棒。希望大家都能掌握它，让它成为我们技术生涯中的一把利器！

...W3Cschool 在线教程(w3cschool.cn)</title> </head><body><textarea rows="10" cols="30">我是一个文本框。</textarea></body></html> 11、HTML <tt> 标签 - HTML5 不支持 <tt> 标签用来改变字体样式，使标签中的文本显示为打字机文本，请参考下述例子： <!DOCTYPE html><html><body><p>This text is normal.</p><p><tt>This text is teletype text.</tt></p></body></html> 12、HTML <u> 标签 <u> 标签可以用来对标签内的文本实现下划线样式，请参考下述示例： <!DOCTYPE html><html><body><p>This is a <u>parragraph</u>.</p></body></html> 13、HTML <ul> 标签 <ul> 标签表示HTML页面中项目的无序列表，一般会以项目符号列表呈现，请参考下述例子： <!DOCTYPE html><html><head><meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><h4>无序列表:</h4><ul><li>咖啡</li><li>茶</li><li>牛奶</li></ul></body></html> 14、HTML <video> 标签 <video> 标签可以将视频内容嵌入到HTML文档中，请参考下述示例： <!DOCTYPE html><html><body><video width="320" height="240" controls><source src="/statics/demosource/movie.mp4" type="video/mp4"><source src="/statics/demosource/movie.ogg" type="video/ogg">您的浏览器不支持 HTML5 video 标签。</video></body></html> 15、HTML <ol> 标签 <ol> 标签在 HTML 中表示有序列表，是 ordered lists 的缩写。您可以自定义有序列表的初始序号，请参考下面的实例： <!DOCTYPE html><html><head><meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body>​<ol><li>咖啡</li><li>茶</li><li>牛奶</li></ol>​<ol start="50"><li>咖啡</li><li>茶</li><li>牛奶</li></ol></body></html> 16、HTML <noframes> 标签HTML5不支持该标签 <noframes> 标签用于支持不支持 <frame> 元素的浏览器，请参考下面的示例： <html><head><meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><frameset cols="25%,50%,25%"><frame src="/statics/demosource/frame_a.htm"><frame src="/statics/demosource/frame_b.htm"><frame src="/statics/demosource/frame_c.htm"><noframes>抱歉，您的浏览器不支持 frame 属性！</noframes></frameset></html> 17、HTML <hr> 标签 <hr> 标签表示段落级元素之间的主题划分。例如，在下面的实例中我们对具有主题变化的内容使用了 <hr> 标签： <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><h1>HTML</h1><p>HTML 是用于描述 web 页面的一种语言。</p><hr><h1>CSS</h1><p>CSS 定义如何显示 HTML 元素。</p></body></html> 18、HTML <h1> - <h6> 标签 <h1> - <h6> 标签用来定义 HTML 标题，表示了 HTML 网页中六个级别的标题。您可以通过下面的这个实例来看看每个级别的标题有什么区别： <!DOCTYPE html><html><head><meta charset="utf-8"><title>W3Cschool(w3cschool.cn)</title></head><body><h1>这是标题1</h1><h2>这是标题2</h2><h3>这是标题 3</h3><h4>这是标题 4</h4><h5>这是标题 5</h5><h6>这是标题 6</h6></body></html> 19、HTML <center> 标签 - HTML 5 不支持 <center> 标签控制文本的居中显示，不能在 HTML5 中使用。 <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><p>这是一些文本。</p><center>这个文本居中对齐。</center><p>这是一些文本</p></body></html> 20、HTML <button> 标签 <button> 标签用来设置 HTML 中的按钮。 <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><button type="button" onclick="alert('Hello world!')">Click Me!</button></body></html> 21、HTML <br> 标签 <br> 标签是空标签，可插入一个简单的换行符。 <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><p>使用br元素<br>在文本中<br>换行。</p></body></html> 22、HTML <dt> 标签 <dt> 标签只能够作为 <dl> 标签的一个子元素出现，常常后跟一个 <dd> 标签。 <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><dl><dt>咖啡</dt><dd>黑色的热饮</dd><dt>牛奶</dt><dd>白色的冷饮</dd></dl></body></html> 23、HTML <fieldset> 标签 <fieldset> 标签内的一组表单元素会在 WEB 浏览器中以特殊的方式显示，比如不同样式的边界、3D效果等。 <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><form><fieldset><legend>个人信息:</legend>姓名: <input type="text"><br>邮箱: <input type="text"><br>生日: <input type="text"></fieldset></form></body></html> 24、HTML <embed> 标签 <embed> 标签用来定义在页面中嵌入的内容，比如插件。比如，在下面的实例中我们嵌入了一个 flash 动画： <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><embed src="/statics/demosource/helloworld.swf" tppabs="http://W3Cschool.com/tags/helloworld.swf"></body></html> 25、HTML <font> 标签 - HTML5 不支持 <font> 标签的使用示例如下所示，该标签已经过时，因此我们不建议您使用该标签。 <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><p><font size="3" color="red">这是一些文本！</font></p><p><font size="2" color="blue">这是一些文本！</font></p><p><font face="verdana" color="green">这是一些文本！</font></p></body></html> 26、HTML <label> 标签 <label> 标签是一种常见的表单控件，触发对应表单控件功能，让用户在使用表单的时候能够有更好的体验。参考下述的实例： <!DOCTYPE html><html><head> <meta charset="utf-8"> <title>W3Cschool(w3cschool.cn)</title> </head><body><p>点击其中一个文本标签选中选项：</p><form action="/statics/demosource/demo-form.php"><label for="male">Male</label><input type="radio" name="sex" id="male" value="male"><br><label for="female">Female</label><input type="radio" name="sex" id="female" value="female"><br><br><input type="submit" value="提交"></form></body></html> 记录一些重要标签！ 本篇文章为转载内容。原文链接：https://blog.csdn.net/chehec2010/article/details/85060460。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...，我们可以进一步关注自动化测试领域的发展动态和技术演进。近期，随着人工智能与软件测试技术的深度融合，诸如Selenium、PyAutoGUI等开源工具在UI自动化测试方面的应用越来越广泛。其中，PyAutoGUI作为一款基于Python的图形用户界面自动化库，不仅能够模拟鼠标和键盘操作，还支持跨平台使用，对于Windows、Mac OS X及Linux系统均能提供一致的操作接口。 与此同时，针对更复杂的交互场景如游戏或三维设计软件，一些高级模拟技术如Robot Framework、Appium也开始受到广泛关注。这些框架不仅能模拟基本的键盘鼠标输入，还能处理更精细的触屏手势操作，并能适应各种移动设备和桌面环境，极大提高了自动化测试的覆盖率和效率。 另外，在安全性方面，研究人员正不断探索如何防止恶意软件通过模拟合法用户的键盘和鼠标操作进行攻击。例如，某些安全软件已开始采用行为分析和机器学习算法来识别并阻止非人类产生的异常输入模式，确保只有真实的用户交互才能触发敏感操作。 总之，Python win32api提供的键盘鼠标模拟功能为自动化测试与脚本编写打开了新世界的大门，而结合最新的自动化测试技术和安全防护手段，我们不仅可以更高效地实现UI自动化，还能在保障用户体验的同时，有效抵御潜在的安全威胁。未来，随着相关技术的持续发展和完善，这一领域的应用场景将更加丰富多元。

...了基于oneAPI在自动驾驶、人工智能医疗影像处理等方面的应用案例，突显了oneAPI在实际项目中的强大适应性和灵活性。 对于开发者来说，参与Intel Developer Zone社区或访问GitHub上的oneAPI示例代码库是持续跟进和学习的最佳途径之一，这里不仅有详尽的教程指导，还有众多开发者分享的一线实践经验，帮助你更好地掌握oneAPI，并将其应用于解决复杂计算问题和应对未来挑战。

...讯》发表了一篇关于“在线字符串编辑与动态回文判定”的研究报告。研究者提出了一种新颖的在线算法，能够在字符串实时更新过程中高效地判断其是否为回文，并能快速找到使字符串变为非回文所需的最少编辑操作。这一成果不仅对于文本处理、数据压缩等领域具有重要价值，也对解决类似的编程挑战提供了新的思路。 此外，在ACM国际大学生程序设计竞赛（ACM-ICPC）和谷歌代码 Jam 等全球顶级编程赛事中，频繁出现与回文串相关的题目，参赛者需灵活运用算法知识来解决实际问题。比如，有题目要求选手在最短时间内编写程序，找出将一个字符串转换为非回文串的最小操作次数，这与我们讨论的文章主题不谋而合，展现了理论与实践相结合的重要性。 同时，回文串在密码学、遗传学以及文学创作等多个领域均有应用。例如，在DNA序列分析中，回文结构往往关联着基因调控的重要区域；在密码学中，特定类型的回文串可用于构建加密算法的关键部分。深入理解并熟练掌握回文串的相关性质及处理方法，无疑有助于我们在这些领域取得更多的技术突破。 总之，从基础的编程题出发，我们可以洞察到字符串处理与算法优化在前沿科研和实际应用中的深远影响。通过持续关注和学习此类问题的最新研究成果与应用案例，我们能够不断提升自身的算法设计和问题解决能力。

...每个标签占多大，会自动去算百分比sizes = [70,20,10]colors = ['red','yellowgreen','lightskyblue']colors = ['gray','00FFFF','FF1493']灰、粉、蓝绿将某部分爆炸出来， 使用括号，将第一块分割出来，数值的大小是分割出来的与其他两块的间隙explode = (0.05,0.05,0)patches,l_text,p_text = plt.pie(sizes,explode=explode,labels=labels,colors=colors,labeldistance = 1.1,autopct = '%3.1f%%',shadow = False,startangle = 90,pctdistance = 0.6)labeldistance，文本的位置离远点有多远，1.1指1.1倍半径的位置autopct，圆里面的文本格式，%3.1f%%表示小数有三位，整数有一位的浮点数shadow，饼是否有阴影startangle，起始角度，0，表示从0开始逆时针转，为第一块。一般选择从90度开始比较好看pctdistance，百分比的text离圆心的距离patches, l_texts, p_texts，为了得到饼图的返回值，p_texts饼图内部文本的，l_texts饼图外label的文本改变文本的大小方法是把每一个text遍历。调用set_size方法设置它的属性for t in l_text:t.set_size(25)for t in p_text:t.set_size(20) 设置x，y轴刻度一致，这样饼图才能是圆的plt.axis('equal')plt.legend(loc="upper left",frameon=False,fontsize=20,borderaxespad=-5)plt.title('721法则', y=-0.1,fontsize=30,loc="center")plt.savefig("721法则.png")plt.show() 下图还是我画的，当然，没有上面那个美观。 第二个图import matplotlib.pyplot as pltplt.rcParams['font.family']='SimHei'plt.figure(figsize=(6, 9))labels = '实践与经验','交流与反馈','培训与学习'sizes = [70.0,20.0,10.0]explode = (0.1,0,0)colors = ['gray','00FFFF','FF1493']plt.pie(sizes,explode=explode,labels=labels,colors=colors,labeldistance=1.1,\autopct='%d%%',shadow=True,counterclock=False)plt.legend(loc="upper left",frameon=False,fontsize=18,borderaxespad=-5)plt.axis('equal')plt.title('721法则', y=-0.1,fontsize=18)plt.savefig("721法则.png")plt.show() 结论：我们不但要会画，还要学着画得尽可能美，实践是唯一的途径。 Python入门教程 如果你现在还是不会Python也没关系，下面我会给大家免费分享一份Python全套学习资料， 包含视频、源码、课件，希望能帮到那些不满现状，想提升自己却又没有方向的朋友，可以和我一起来学习交 流。 ① Python所有方向的学习路线图，清楚各个方向要学什么东西 ② 600多节Python课程视频，涵盖必备基础、爬虫和数据分析 ③ 100多个Python实战案例，含50个超大型项目详解，学习不再是只会理论 ④ 20款主流手游迫解 爬虫手游逆行迫解教程包 ⑤ 爬虫与反爬虫攻防教程包，含15个大型网站迫解 ⑥ 爬虫APP逆向实战教程包，含45项绝密技术详解 ⑦ 超300本Python电子好书，从入门到高阶应有尽有 ⑧ 华为出品独家Python漫画教程，手机也能学习 ⑨ 历年互联网企业Python面试真题,复习时非常方便 👉Python学习视频600合集👈 观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。 👉实战案例👈 光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。 👉100道Python练习题👈 检查学习结果。 👉面试刷题👈 资料领取 上述这份完整版的Python全套学习资料已经上传CSDN官方，朋友们如果需要可以微信扫描下方CSDN官方认证二维码输入“领取资料” 即可领取 好文推荐 了解python的前景：https://blog.csdn.net/weixin_49891576/article/details/127187029 了解python的兼职：https://blog.csdn.net/weixin_49891576/article/details/127125308 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_49891576/article/details/130861900。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...复用无阻塞传输，有效解决了延迟和丢包问题。阅读关于HTTP/3的最新研究与实践案例，比如《HTTP/3：下一代互联网传输协议的变革与应用》，将有助于我们掌握未来WebService通信的新趋势和技术细节。 此外，对于安全防护方面，随着网络攻击手段的日益复杂化，保障WebService的安全性至关重要。一篇题为《深度解析：如何强化你的WebService安全防护体系》的文章详述了多种常见的安全威胁及应对策略，包括但不限于DDoS防御、SQL注入防范、OAuth2.0授权机制的应用等，这对于提升自建WebService的安全等级具有极高的参考价值。 综上所述，在实际开发和运维过程中，结合最新的技术和最佳实践，不断优化和完善WebService的实现方案，既能提高系统的稳定性和效率，也能确保其在面对各种挑战时具备足够的安全性和适应性。

...上的公共ntp服务器自动修正时间即可 一、系统时间和硬件时间 Linux在默认情况下，系统时间和硬件时间并不会自动同步。而是以异步的方式运行，互不干扰。其中硬件时间的运行，是靠Bios电池来维持，而系统时间，是用CPU 时钟来维持的。 在系统开机的时候，会自动从Bios中取得硬件时间，设置为系统时间。 1.1 date命令 用来查看和设置系统时间 date 查看系统当前时间sudo date -s "2023-03-18 11:16:10" 修改系统时间为 "xxxx-xx-xx xx:xx:xx"===============================================================================nvidia@nvidia-desktop:~$ dateВт мар 18 11:16:27 +08 2023nvidia@nvidia-desktop:~$nvidia@nvidia-desktop:~$nvidia@nvidia-desktop:~$ sudo date -s "2023-03-18 11:16:10"[sudo] password for nvidia:Вт мар 18 11:16:10 +08 2023nvidia@nvidia-desktop:~$ 硬件时间的设置，可以用hwclock 1.2 hwclock 命令 查看当前硬件时间 注意：hwclock 所有命令需要使用root 权限 nvidia@nvidia-desktop:~$ hwclockhwclock: Cannot access the Hardware Clock via any known method.hwclock: Use the --debug option to see the details of our search for an access method.nvidia@nvidia-desktop:~$nvidia@nvidia-desktop:~$nvidia@nvidia-desktop:~$ sudo hwclock2023-03-21 11:18:49.607690+0800nvidia@nvidia-desktop:~$ 将系统时间同步到硬件时间 hwclock -w 将硬件时间同步到系统时间 hwclock -s 二、不同机器间时间同步 为了避免主机时间因为长期运作下所导致的时间偏差，进行时间同步(synchronize)的工作是非常必要的。Linux系统下，一般使用ntp服务器来同步不同机器的时间。一台机器，可以同时是ntp服务器和ntp客户机。 2.1 ntpdate命令实现 ntpdate 安装： yum install ntpdate -y Centos系统======================================sudo apt install ntpdate Ubuntu系统 时间同步 sudo ntpdate -u cn.pool.ntp.org18 Mar 18:25:22 ntpdate[18673]: adjust time server 84.16.73.33 offset 0.015941 sec 使用ntpdate 只是强制将系统时间设置为ntp服务器时间，如果cpu tick有问题，时间还是会不准。所以，一般配合cron命令，来进行定期同步设置。比如，在crontab中添加： sudo crontab -e0 12 /usr/sbin/ntpdate 192.168.10.110 上述命令的意思是：每天的12点整，从192.168.10.110 ntp服务器同步一次时间（前提是 192.168.10.110有ntp服务）。 2.2 Ntp客户端代码实现 本质上还是创建socket连接去获取ntp服务的时间与本地时间比较，不一致修改本机时间即可。 NtpClient.h //// Created by lwang on 2023-03-18.//ifndef NTP_CLIENT_Hdefine NTP_CLIENT_Hinclude <stdio.h>include <stdlib.h>include <string.h>include <time.h>include <iostream>include <unistd.h>include <sys/select.h>include <sys/time.h>include <sys/socket.h>include <arpa/inet.h>include <netdb.h>include <errno.h>include <endian.h>include <map>include <string>include <mutex>using namespace std;define NTP_LI 0define NTP_VERSION_NUM 3define NTP_MODE_CLIENT 3define NTP_MODE_SERVER 4define NTP_STRATUM 0define NTP_POLL 4define NTP_PRECISION -6define NTP_MIN_LEN 48define NTP_SERVER_PORT 123define NTP_SERVER_ADDR "119.28.183.184"define TIMEOUT 2define BUFSIZE 1500define JAN_1970 0x83aa7e80define NTP_CONV_FRAC32(x) (uint64_t)((x) ((uint64_t)1 << 32))define NTP_REVE_FRAC32(x) ((double)((double)(x) / ((uint64_t)1 << 32)))define NTP_CONV_FRAC16(x) (uint32_t)((x) ((uint32_t)1 << 16))define NTP_REVE_FRAC16(x) ((double)((double)(x) / ((uint32_t)1 << 16)))define USEC2FRAC(x) ((uint32_t)NTP_CONV_FRAC32((x) / 1000000.0))define FRAC2USEC(x) ((uint32_t)NTP_REVE_FRAC32((x)1000000.0))define NTP_LFIXED2DOUBLE(x) ((double)(ntohl(((struct l_fixedpt )(x))->intpart) - JAN_1970 + FRAC2USEC(ntohl(((struct l_fixedpt )(x))->fracpart)) / 1000000.0))struct s_fixedpt{uint16_t intpart;uint16_t fracpart;};struct l_fixedpt{uint32_t intpart;uint32_t fracpart;};struct ntphdr{if __BYTE_ORDER == __BID_ENDIANunsigned int ntp_li : 2;unsigned int ntp_vn : 3;unsigned int ntp_mode : 3;endifif __BYTE_ORDER == __LITTLE_ENDIANunsigned int ntp_mode : 3;unsigned int ntp_vn : 3;unsigned int ntp_li : 2;endifuint8_t ntp_stratum;uint8_t ntp_poll;int8_t ntp_precision;struct s_fixedpt ntp_rtdelay;struct s_fixedpt ntp_rtdispersion;uint32_t ntp_refid;struct l_fixedpt ntp_refts;struct l_fixedpt ntp_orits;struct l_fixedpt ntp_recvts;struct l_fixedpt ntp_transts;};class NtpClient {public:NtpClient();virtual ~NtpClient();void GetNtpTime(std::string &ntpTime);in_addr_t HostTransfer(const char host);int PaddingNtpPackage(void buf, size_t size);double GetOffset(const struct ntphdr ntp, const struct timeval recvtv);private:int m_sockfd;};endif / NTP_CLIENT_H / NtpClient.cpp //// Created by lwang on 2023-03-18.//include "NtpClient.h"NtpClient::NtpClient() { }NtpClient::~NtpClient() {}in_addr_t NtpClient::HostTransfer(const char host){in_addr_t saddr;struct hostent hostent;if ((saddr = inet_addr(host)) == INADDR_NONE){if ((hostent = gethostbyname(host)) == NULL){return INADDR_NONE;}memmove(&saddr, hostent->h_addr, hostent->h_length);}return saddr;}int NtpClient::PaddingNtpPackage(void buf, size_t size) // 构建并发送NTP请求报文{if (!size)return -1;struct ntphdr ntp;struct timeval tv;memset(buf, 0, BUFSIZE);ntp = (struct ntphdr )buf;ntp->ntp_li = NTP_LI;ntp->ntp_vn = NTP_VERSION_NUM;ntp->ntp_mode = NTP_MODE_CLIENT;ntp->ntp_stratum = NTP_STRATUM;ntp->ntp_poll = NTP_POLL;ntp->ntp_precision = NTP_PRECISION;gettimeofday(&tv, NULL); // 把目前的时间用tv 结构体返回ntp->ntp_transts.intpart = htonl(tv.tv_sec + JAN_1970);ntp->ntp_transts.fracpart = htonl(USEC2FRAC(tv.tv_usec));size = NTP_MIN_LEN;return 0;}double NtpClient::GetOffset(const struct ntphdr ntp, const struct timeval recvtv) // 偏移量{double t1, t2, t3, t4;t1 = NTP_LFIXED2DOUBLE(&ntp->ntp_orits);t2 = NTP_LFIXED2DOUBLE(&ntp->ntp_recvts);t3 = NTP_LFIXED2DOUBLE(&ntp->ntp_transts);t4 = recvtv->tv_sec + recvtv->tv_usec / 1000000.0;return ((t2 - t1) + (t3 - t4)) / 2;}void NtpClient::GetNtpTime(std::string &ntpTime){char buffer[64] = {0};char cmd[128] = {0};tm local;char buf[BUFSIZE];size_t nbytes;int maxfd1;struct sockaddr_in servaddr;fd_set readfds;struct timeval timeout, recvtv, tv;double offset;servaddr.sin_family = AF_INET;servaddr.sin_port = htons(NTP_SERVER_PORT);servaddr.sin_addr.s_addr = HostTransfer(NTP_SERVER_ADDR);if ((m_sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){perror("socket error");return ;}if (connect(m_sockfd, (struct sockaddr )&servaddr, sizeof(struct sockaddr)) != 0){perror("connect error");return ;}nbytes = BUFSIZE;if (PaddingNtpPackage(buf, &nbytes) != 0){fprintf(stderr, "construct ntp request error \n");exit(-1);}send(m_sockfd, buf, nbytes, 0);FD_ZERO(&readfds);FD_SET(m_sockfd, &readfds);maxfd1 = m_sockfd + 1;timeout.tv_sec = TIMEOUT;timeout.tv_usec = 0;if (select(maxfd1, &readfds, NULL, NULL, &timeout) > 0){if (FD_ISSET(m_sockfd, &readfds)){if ((nbytes = recv(m_sockfd, buf, BUFSIZE, 0)) < 0){perror("recv error");exit(-1);}// 计算C/S时间偏移量gettimeofday(&recvtv, NULL);offset = GetOffset((struct ntphdr )buf, &recvtv);gettimeofday(&tv, NULL);tv.tv_sec += (int)offset;tv.tv_usec += offset - (int)offset;local = localtime((time_t )&tv.tv_sec);strftime(buffer, 64, "%Y-%m-%d %H:%M:%S", local);ntpTime = std::string(buffer);} }return ;} main.cpp include "NtpClient.h"int main(){std::string ntpTime = "";char curBuf[64] = {0};struct timeval cur;tm local;NtpClient client;client.GetNtpTime(ntpTime);cout << "ntpTime: " << ntpTime << endl;gettimeofday(&cur, NULL);local = localtime((time_t )&cur.tv_sec);strftime(curBuf, 64, "%Y-%m-%d %H:%M:%S", local);std::string curTime = std::string(curBuf);cout << "curTime: " << curTime << endl;if (curTime != ntpTime){cout << "start time calibrate!" << endl;std::string cmd = "sudo date -s \"" + ntpTime + "\"";system(cmd.c_str());cout << "cmd: " << cmd << endl;}else{cout << "time seem" << endl;}return 0;} 推荐一个零声学院免费教程，个人觉得老师讲得不错， 分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis， fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker， TCP/IP，协程，DPDK等技术内容，点击立即学习: 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_46935110/article/details/129683157。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...ptr生命周期结束时自动释放，然而，由于auto_ptr在转移指针所有权后会产生野指针，导致程序运行时crash，如下面示例代码所示： auto_ptr<int> p1(new int(10));auto_ptr<int> p2 = p1; //转移控制权p1 += 10; //crash，p1为空指针，可以用p1->get判空做保护 因此在C++11又推出了unique_ptr、shared_ptr、weak_ptr三种智能指针，慢慢取代auto_ptr。 unique_ptr的使用 unique_ptr是auto_ptr的继承者，对于同一块内存只能有一个持有者，而unique_ptr和auto_ptr唯一区别就是unique_ptr不允许赋值操作，也就是不能放在等号的右边（函数的参数和返回值例外），这一定程度避免了一些误操作导致指针所有权转移，然而，unique_str依然有提供所有权转移的方法move，调用move后，原unique_ptr就会失效，再用其访问裸指针也会发生和auto_ptr相似的crash，如下面示例代码，所以，即使使用了unique_ptr，也要慎重使用move方法，防止指针所有权被转移。 unique_ptr<int> up(new int(5));//auto up2 = up; // 编译错误auto up2 = move(up);cout << up << endl; //crash，up已经失效，无法访问其裸指针 除了上述用法，unique_ptr还支持创建动态数组。在C++中，创建数组有很多方法，如下所示： // 静态数组，在编译时决定了数组大小int arr[10];// 通过指针创建在堆上的数组，可在运行时动态指定数组大小，但需要手动释放内存int arr = new int[10];// 通过std::vector容器创建动态数组，无需手动释放数组内存vector<int> arr(10);// 通过unique_ptr创建动态数组，也无需手动释放数组内存，比vector更轻量化unique_ptr<int[]> arr(new int[10]); 这里需要注意的是，不管vector还是unique_ptr，虽然可以帮我们自动释放数组内存，但如果数组的元素是复杂数据类型时，我们还需要在其析构函数中正确释放内存。 真正的智能指针：shared_ptr auto_ptr和unique_ptr都有或多或少的缺陷，因此C++11还推出了shared_ptr，这也是目前工程内使用最多最广泛的智能指针，他使用引用计数（感觉有参考Objective-C的嫌疑），实现对同一块内存可以有多个引用，在最后一个引用被释放时，指向的内存才释放，这也是和unique_ptr最大的区别。 另外，使用shared_ptr过程中有几点需要注意： 构造shared_ptr的方法，如下示例代码所示，我们尽量使用shared_ptr构造函数或者make_shared的方式创建shared_ptr，禁止使用裸指针赋值的方式，这样会shared_ptr难于管理指针的生命周期。 // 使用裸指针赋值构造，不推荐，裸指针被释放后，shared_ptr就野了，不能完全控制裸指针的生命周期，失去了智能指针价值int p = new int(10);shared_ptr<int>sp = p;delete p; // sp将成为野指针，使用sp将crash// 将裸指针作为匿名指针传入构造函数，一般做法，让shared_ptr接管裸指针的生命周期，更安全shared_ptr<int>sp1(new int(10));// 使用make_shared，推荐做法，更符合工厂模式，可以连代码中的所有new，更高效；方法的参数是用来初始化模板类shared_ptr<int>sp2 = make_shared<int>(10); 禁止使用指向shared_ptr的裸指针，也就是智能指针的指针，这听起来就很奇怪，但开发中我们还需要注意，使用shared_ptr的指针指向一个shared_ptr时，引用计数并不会加一，操作shared_ptr的指针很容易就发生野指针异常。 shared_ptr<int>sp = make_shared<int>(10);cout << sp.use_count() << endl; //输出1shared_ptr<int> sp1 = &sp;cout << (sp1).use_count() << endl; //输出依然是1(sp1).reset(); //sp成为野指针cout << sp << endl; //crash 使用shared_ptr创建动态数组，在介绍unique_ptr时我们就讲过创建动态数组，而shared_ptr同样可以做到，不过稍微复杂一点，如下代码所示，除了要显示指定析构方法外（因为默认是T的析构函数，不是T[]），另外对外的数据类型依然是shared_ptr<T>，非常有迷惑性，看不出来是数组，最后不能直接使用下标读写数组，要先get()获取裸指针才可以使用下标。所以，不推荐使用shared_ptr来创建动态数组，尽量使用unique_ptr，这可是unique_ptr为数不多的优势了。 template <typename T>shared_ptr<T> make_shared_array(size_t size) {return shared_ptr<T>(new T[size], default_delete<T[]>());}shared_ptr<int>sp = make_shared_array(10); //看上去是shared<int>类型，实际上是数组sp.get()[0] = 100; //不能直接使用下标读写数组元素，需要通过get()方法获取裸指针后再操作 用shared_ptr实现多态，在我们使用裸指针时，实现多态就免不了定义虚函数，那么用shared_ptr时也不例外，不过有一处是可以省下的，就是析构函数我们不需要定义为虚函数了，如下面代码所示： class A {public:~A() {cout << "dealloc A" << endl;} };class B : public A {public:~B() {cout << "dealloc B" << endl;} };int main(int argc, const char argv[]) {A a = new B();delete a; //只打印dealloc Ashared_ptr<A>spa = make_shared<B>(); //析构spa是会先打印dealloc B，再打印dealloc Areturn 0;} 循环引用，笔者最先接触引用计数的语言就是Objective-C，而OC中最常出现的内存问题就是循环引用，如下面代码所示，A中引用B，B中引用A，spa和spb的强引用计数永远大于等于1，所以直到程序退出前都不会被退出，这种情况有时候在正常的业务逻辑中是不可避免的，而解决循环引用的方法最有效就是改用weak_ptr，具体可见下一章。 class A {public:shared_ptr<B> b;};class B {public:shared_ptr<A> a;};int main(int argc, const char argv[]) {shared_ptr<A> spa = make_shared<A>();shared_ptr<B> spb = make_shared<B>();spa->b = spb;spb->a = spa;return 0;} //main函数退出后，spa和spb强引用计数依然为1，无法释放 刚柔并济：weak_ptr 正如上一章提到，使用shared_ptr过程中有可能会出现循环引用，关键原因是使用shared_ptr引用一个指针时会导致强引用计数+1，从此该指针的生命周期就会取决于该shared_ptr的生命周期，然而，有些情况我们一个类A里面只是想引用一下另外一个类B的对象，类B对象的创建不在类A，因此类A也无需管理类B对象的释放，这个时候weak_ptr就应运而生了，使用shared_ptr赋值给一个weak_ptr不会增加强引用计数（strong_count），取而代之的是增加一个弱引用计数（weak_count），而弱引用计数不会影响到指针的生命周期，这就解开了循环引用，上一章最后的代码使用weak_ptr可改造为如下代码。 class A {public:shared_ptr<B> b;};class B {public:weak_ptr<A> a;};int main(int argc, const char argv[]) {shared_ptr<A> spa = make_shared<A>();shared_ptr<B> spb = make_shared<B>();spa->b = spb; //spb强引用计数为2，弱引用计数为1spb->a = spa; //spa强引用计数为1，弱引用计数为2return 0;} //main函数退出后，spa先释放，spb再释放，循环解开了使用weak_ptr也有需要注意的点，因为既然weak_ptr不负责裸指针的生命周期，那么weak_ptr也无法直接操作裸指针，我们需要先转化为shared_ptr，这就和OC的Strong-Weak Dance有点像了，具体操作如下：shared_ptr<int> spa = make_shared<int>(10);weak_ptr<int> spb = spa; //weak_ptr无法直接使用裸指针创建if (!spb.expired()) { //weak_ptr最好判断是否过期，使用expired或use_count方法，前者更快spb.lock() += 10; //调用weak_ptr转化为shared_ptr后再操作裸指针}cout << spa << endl; //20 智能指针原理 看到这里，智能指针的用法基本介绍完了，后面笔者来粗浅地分析一下为什么智能指针可以有效帮我们管理裸指针的生命周期。 使用栈对象管理堆对象 在C++中，内存会分为三部分，堆、栈和静态存储区，静态存储区会存放全局变量和静态变量，在程序加载时就初始化，而堆是由程序员自行分配，自行释放的，例如我们使用裸指针分配的内存；而最后栈是系统帮我们分配的，所以也会帮我们自动回收。因此，智能指针就是利用这一性质，通过一个栈上的对象（shared_ptr或unique_ptr）来管理一个堆上的对象（裸指针），在shared_ptr或unique_ptr的析构函数中判断当前裸指针的引用计数情况来决定是否释放裸指针。 shared_ptr引用计数的原理 一开始笔者以为引用计数是放在shared_ptr这个模板类中，但是细想了一下，如果这样将shared_ptr赋值给另一个shared_ptr时，是怎么做到两个shared_ptr的引用计数同时加1呢，让等号两边的shared_ptr中的引用计数同时加1？不对，如果还有第二个shared_ptr再赋值给第三个shared_ptr那怎么办呢？或许通过下面的类图便清楚个中奥秘。 [ boost中shared_ptr与weak_ptr类图 ] 我们重点关注shared_ptr<T>的类图，它就是我们可以直接操作的类，这里面包含裸指针T，还有一个shared_count的对象，而shared_count对象还不是最终的引用计数，它只是包含了一个指向sp_counted_base的指针，这应该就是真正存放引用计数的地方，包括强应用计数和弱引用计数，而且shared_count中包含的是sp_counted_base的指针，不是对象，这也就意味着假如shared_ptr<T> a = b，那么a和b底层pi_指针指向的是同一个sp_counted_base对象，这就很容易做到多个shared_ptr的引用计数永远保持一致了。 多线程安全 本章所说的线程安全有两种情况： 多个线程操作多个不同的shared_ptr对象 C++11中声明了shared_ptr的计数操作具有原子性，不管是赋值导致计数增加还是释放导致计数减少，都是原子性的，这个可以参考sp_counted_base的源码，因此，基于这个特性，假如有多个shared_ptr共同管理一个裸指针，那么多个线程分别通过不同的shared_ptr进行操作是线程安全的。 多个线程操作同一个shared_ptr对象 同样的道理，既然C++11只负责sp_counted_base的原子性，那么shared_ptr本身就没有保证线程安全了，加入两个线程同时访问同一个shared_ptr对象，一个进行释放（reset），另一个读取裸指针的值，那么最后的结果就不确定了，很有可能发生野指针访问crash。 作者：腾讯技术工程 https://mp.weixin.qq.com/s?__biz=MjM5ODYwMjI2MA==&mid=2649743462&idx=1&sn=c9d94ddc25449c6a0052dc48392a33c2&utm_source=tuicool&utm_medium=referralmp.weixin.qq.com 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_31467557/article/details/113049179。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...素市场化配置改革亟需解决的关键问题之一便是如何构建统一的数据流通体系。报告建议，应加快制定和完善数据分级分类管理制度，鼓励采用先进的技术手段如区块链、联邦学习等，以提升数据流动的安全性和透明度。这表明，无论是在国际还是国内层面，围绕数据安全的技术创新与政策规范都呈现出同步加强的趋势。 值得注意的是，尽管Hadoop因其强大的分布式计算能力在全球范围内得到了广泛应用，但其在实际部署过程中仍面临诸多挑战，例如如何在满足业务需求的同时避免因权限配置不当而导致的数据泄露风险。对此，专家指出，企业应当加强对员工的数据安全意识培训，同时积极引入第三方审计机制，定期评估系统内的访问控制策略是否符合最新的行业标准。此外，随着量子计算等新兴技术的发展，未来的数据加密方案也需要重新审视，以应对潜在的安全威胁。 综上所述，无论是国际法规的变化还是国内政策的调整，都在推动数据安全领域发生深刻变革。对于那些希望借助Hadoop等工具实现高效数据迁移的企业而言，只有紧跟时代步伐，不断优化自身的数据管理体系，才能在未来竞争中立于不败之地。

...不仅体现了数据结构在解决实际问题中的核心地位，也为广大编程爱好者和学生提供了检验自身数据结构掌握程度的实战平台。 此外，知名在线教育平台Coursera最近上线了一门由斯坦福大学教授主讲的《数据结构与算法》课程，该课程采用现代编程语言进行实例教学，并结合最新的算法研究成果，帮助学习者深化对数据结构原理的理解，进一步提升其在真实场景下的应用能力。 总的来说，在当前的编程领域中，数据结构的重要性不言而喻，无论是工业界对于高性能数据结构的持续优化，还是学术竞赛对数据结构应用的深度挖掘，抑或是在线教育资源对于数据结构教育的不断升级，都为我们提供了丰富的学习资源和实践机会，以更好地应对日新月异的技术挑战。

...DML支持事务,在非自动提交模式时,可以利用rollback回滚操作. 数据查询语言 DQL - 筛选,分组,连表查询 面试重点 TCL 和 DCL - 事务控制语句TCL- 负责实现数据库中事务支持的语言,commit rollback savepoint等指令- DCL数据库控制语言- 管理数据库的授权,角色控制等,grant(授权),revoke(取消授权) 练习： 案例：创建一张表customer（顾客） create table customer(cid int(4) primary key comment '顾客编号',cname varchar(50) comment '顾客姓名',sex char(5) comment '顾客性别',address varchar(50) comment '地址',phone varchar(11) comment '手机',email varchar(50) comment '邮箱'); show create table customer; 插入5条数据 insert into customer values(1001,'小明','男','楼上18号','123','123@163.com');insert into customer values(1002,'小红','女','楼上17号','1234','1234@163.com');insert into customer values(1003,'老王','男','楼上18号隔壁','1234','1234@163.com');insert into customer values(1004,'老宋','男','楼上17号隔壁','1234','1234@163.com');insert into customer values(1005,'小马','女','楼上17号隔壁','1234','1234@163.com'); -1 修改一条数据的姓名 小红的姓名 -2 修改一条数据的性别 老王的性别 -3 修改一条数据的电话 1001号的电话 -4 修改一条数据的邮箱 邮箱为123@163.com,改成323@163.com -5 查询性别为 男的所有数据 select from customer where sex="男"; -6 自定义DDL操作的需求,5道题,可以同上面book表的操作 数据库数据类型 主要包括5大类 整数类型 int, big int 浮点数类型 double decimal 字符串类型 char varchar text 日期类型 date datetime timestamp time year... 其他数据类型 set.... 字符串 - char(固定长度) 定长字符串 最多255个字节- 定多少长度,就占用多少长度- 多了放不进去,少了用空格补全- 不认识内容尾部的空格- varchar(最大长度) 变长字符串 最大65535字节,但是使用一般不超过255- 只要不超过定的长度,都可以放进去- 以内容真实长度为准- 认识内容尾部的空格- text 最大65535字节- blob 大数据对象,以二进制(字节)的方式存储 整数 tinyint 1字节 smallint 2字节 int 4字节 bigint 8字节 int(6)影响的是查询时显示长度(zerofill)不影响数据的保存长度 create table t1(id1 int,id2 int(5)); insert into t1 values(111111,111111); alter table t1 modify id1 int zerofill; alter table t1 modify id2 int(5) zerofill; insert into t1 values (1,1); float 4字节 double 8字节 double(8,2) 可能会产生精度的缺失 10.0/3 3.3333333336 decimal 不会缺失精度,但是使用的时候需要指定总长度和小数位数 日期 - date 年月日- time 时分秒- datetime 年月日时分秒,到9999年,而且需要手动输入,如果没有手动输入,就显示null.- timestamp 年月日时分秒,在没有数据手动插入时,自动填入当前时间.最大值2038- bigint 1970-1-1 0:0:0 格林威治时间 案例：创建表t，字段d1 date，d2 time,d3 datetime,d4 timestamp create table t(id int,d1 date,d2 time,d3 datetime,d4 timestamp);insert into t (d1,d2) values ('1910-01-10','12:32:12');insert into t values(1,'2018-12-21','15:12:00','1995-02-10 12:08:12','2030-10-10 15:19:32');insert into t values(2,'3018-01-25','15:12:34','9234-12-31 12:12:12','2030-12-31 12:12:12');insert into t values(2,'3018-01-25','15:12:34','9999-12-31 23:59:59','2030-12-31 12:12:12'); 练习 创建人物表，插入，修改，查询 create table person(id int(4) primary key,name varchar(50),age int(3));insert into person values(1,"梅超风",36);insert into person values(2,"洪七公",96);insert into person values(3,"杨过",40);insert into person values(4,"令狐冲",28);insert into person values(5,"张三丰",100);insert into person values(6,"张翠山",27);insert into person values(7,"张无忌",27);insert into person values(8,"赵敏",18);insert into person values(9,"独孤求败",250);insert into person values(10,"楚留香",36);1.案例：修改张三丰的name为刘备，id为11update person set name="刘备",id=11 where name="张三丰";2.案例：修改2号人物的的name为夏侯渊update person set name="夏侯渊" where id=2;3.案例：根据条件修改person表中的数据,修改id是6的数据中，姓名改为'任我行', 年龄改为39update person set name="任我行",age=39 where id=6;4.案例：修改姓名是‘楚留香'的数据，把id改为20，年龄改为19update person set id=20,age=19 where name="楚留香";5.案例：把person所有的数据的年龄全部改为20 update person set age=20;6.案例：修改id为7的数据，把id改为100，姓名改为杨过，年龄改为21update person set id=100,name="杨过",age=21 where id=7;7.案例：修改姓名是独孤求败，把年龄改为35update person set age=35 where name="独孤求败";8.案例：修改id=8的信息，把姓名改为房玄龄update person set name="房玄龄" where id=8;9.案例 :修改id为20并且年龄为20的人的姓名为刘德华(郑少秋也行)提示 where...and...update person set name="郑少秋" where id=20 and age=20; 查询 没有条件的简单查询 select from 表名;查询表中所有的数据 select from person; select from t; select from emp; select from dept; 查询某些列中的值 select name as '姓名' from person; select name as '姓名',age as '年龄' from person; select id as '编号',name as '姓名',age as '年龄' from person; 学习过程的编程习惯select from 表; 工作中的编程习惯select id,name,age from person; 查询emp表中所有员工的姓名,上级领导的编号,职位,工资 select ename,mgr,job,sal from emp; 查询emp表中所有员工的编号,姓名,所属部门编号,工资 select empno,ename,deptno,sal from emp; 查询dept表中所有部门的名称和地址 select dname,loc from dept; 如果忘记了mysql的用户名和密码怎么办 卸载重新装 不重装软件如何修改密码 1.停止mysql服务 2.cmd中输入一个命令 mysqld --skip-grant-tables; -通过控制台,开启了一个mysql服务 3.开启一个新的cmd -mysql -u root -p 可以不使用密码进入数据库 show databases;----mysql 5. use mysql; 6. update user set password=password('新密码') where user="root"; 7. 关闭mysqld这个服务/进程 8. 重启mysql服务 作业 mysql02,一天的代码重新敲一遍,熟悉emp和dept列名 本篇文章为转载内容。原文链接：https://blog.csdn.net/sinat_41915844/article/details/79770973。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...的值时，这段代码可以自动重新执行 let m = 0// 一段代码console.log(m)console.log(m 2)console.log(m 2)m = 200 上面的这样一种可以自动响应数据变量的代码机制，我们就称之为是响应式的 对象的响应式 4.2 响应式函数设计 首先，执行的代码中可能不止一行代码，所以我们可以将这些代码放到一个函数中： 那么问题就变成了，当数据发生变化时，自动去执行某一个函数； 但是有一个问题：在开发中是有很多的函数的，如何区分一个函数需要响应式，还是不需要响应式呢？ 很明显，下面的函数中 foo 需要在 obj 的 name 发生变化时，重新执行，做出相应； bar 函数是一个完全独立于 obj 的函数，它不需要执行任何响应式的操作； // 对象的响应式const obj = {name: 'why',age: 18}function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)}function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行 响应式函数的实现 watchFn 如何区分响应式函数？ 这个时候我们封装一个新的函数 watchFn 凡是传入到 watchFn 的函数，就是需要响应式的 其他默认定义的函数都是不需要响应式的 / 封装一个响应式的函数 /let reactiveFns = []function watchFn(fn) {reactiveFns.push(fn)}// 对象的响应式const obj = {name: 'why',age: 18}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行reactiveFns.forEach((fn) => {fn()}) 4.3 响应式依赖的收集 目前收集的依赖是放到一个数组中来保存的，但是这里会存在数据管理的问题： 在实际开发中需要监听很多对象的响应式 这些对象需要监听的不只是一个属性，它们很多属性的变化，都会有对应的响应式函数 不可能在全局维护一大堆的数组来保存这些响应函数 所以要设计一个类，这个类用于管理某一个对象的某一个属性的所有响应式函数： 相当于替代了原来的简单 reactiveFns 的数组； class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe'depend.notify() 4.4 监听对象的变化 那么接下来就可以通过之前的方式来监听对象的变化： 方式一：通过 Object.defineProperty 的方式（vue2采用的方式）； 方式二：通过 new Proxy 的方式（vue3采用的方式）； 我们这里先以Proxy的方式来监听 class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)depend.notify()} })watchFn(function foo() {const newName = objProxy.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(objProxy.name)})watchFn(function demo() {console.log(objProxy.name, 'demo function ---------')})objProxy.name = 'kobe'objProxy.name = 'james'/ 你好啊，李银河Hello Worldkobekobe demo function ---------你好啊，李银河Hello Worldjamesjames demo function ---------/ 4.5 对象的依赖管理 目前是创建了一个 Depend 对象，用来管理对于 name 变化需要监听的响应函数： 但是实际开发中我们会有不同的对象，另外会有不同的属性需要管理； 如何可以使用一种数据结构来管理不同对象的不同依赖关系呢？ 在前面我们刚刚学习过 WeakMap，并且在学习 WeakMap 的时候我讲到了后面通过 WeakMap 如何管理这种响应式的数据依赖： 实现 可以写一个 getDepend 函数专门来管理这种依赖关系 / 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取mapconst map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象const depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 正确的依赖收集 我们之前收集依赖的地方是在 watchFn 中： 但是这种收集依赖的方式我们根本不知道是哪一个 key 的哪一个 depend 需要收集依赖； 只能针对一个单独的 depend 对象来添加你的依赖对象； 那么正确的应该是在哪里收集呢？应该在我们调用了 Proxy 的 get 捕获器时 因为如果一个函数中使用了某个对象的 key，那么它应该被收集依赖 / 封装一个响应式函数 /let activeReactviceFn = nullfunction watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数activeReactviceFn && depend.addDepend(activeReactviceFn)return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 4.6 对 Depend 重构 两个问题： 问题一：如果函数中有用到两次 key，比如 name，那么这个函数会被收集两次 问题二：我们并不希望将添加 reactiveFn 放到 get 中，因为它是属于 Depend 的行为 所以我们需要对 Depend 类进行重构： 解决问题一的方法：不使用数组，而是使用 Set 解决问题二的方法：添加一个新的方法，用于收集依赖 // 保存当前需要收集的响应式函数let activeReactviceFn = nullclass Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })watchFn(function () {console.log(objProxy.name, '--------------')console.log(objProxy.name, '++++++++++++++')})objProxy.name = 'kobe'/ why --------------why ++++++++++++++kobe --------------kobe ++++++++++++++/ 4.7 创建响应式对象 目前的响应式是针对于obj一个对象的，我们可以创建出来一个函数，针对所有的对象都可以变成响应式对象 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)return new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 4.8 Vue2 响应式原理 前面所实现的响应式的代码，其实就是 Vue3 中的响应式原理： Vue3 主要是通过 Proxy 来监听数据的变化以及收集相关的依赖的 Vue2 中通过 Object.defineProerty的方式来实现对象属性的监听 可以将 reactive 函数进行如下的重构： 在传入对象时，我们可以遍历所有的 key，并且通过属性存储描述符来监听属性的获取和修改 在 setter 和 getter 方法中的逻辑和前面的 Proxy 是一致的 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {const dep = getDepend(obj, key)dep.depend()return value},set: function (newValue) {value = newValueconst dep = getDepend(obj, key)dep.notify()} })})return obj}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 本篇文章为转载内容。原文链接：https://blog.csdn.net/wanghuan1020/article/details/126774033。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

... 三.命令历史限制与自动注销 1.命令历史限制： 2.终端自动注销： 四.PAM安全认证 1.su的命令的安全隐患 2.什么是PAM 3.PAM认证原理 4.PAM安全认证流程 五.限制使用su命令的用户（pam-wheel认证模块） 1.su命令概述： 2. su命令的用途以及用法： 3.配置su的授权（加入wheel组）（pam_wheel认证模块：）： 4.配置/etc/sudoers文件(授权用户较多的时候使用)： 六.开关机安全控制 1.调整BIOS引导设置 2.GRUB限制 七.终端以及登录控制 1.限制root只在安全终端登录 2..禁止普通用户登录 八.系统弱口令检测 1.JOHN the Ripper，简称为JR 2.安装弱口令账号 3.密码文件的暴力破解 九.网络端口扫描 1.NMAP 2.格式 总结： 一.账号安全基本措施 1.系统账号清理 1.将非登录用户的Shell设为/sbin/nologin （ps：在我们使用Linux系统时，除了用户创建的账号之外，还会产生系统或程序安装过程中产生的许多其他账号，除了超级用户root外，其他账号都是用来维护系统运作的，一般不允许登录，常见的非登录用户有bin、adm、mail、lp、nobody、ftp等。） 格式：usermod -s /sbin/nologin 用户名 2锁定长期不使用的账号： [root@hehe ~] usermod -L test2 锁定用户账号方法一[root@hehe ~] passwd -l test3 锁定用户账号方法二[root@hehe ~] usermod -U test2 解锁用户账号方法一[root@hehe~] passwd -u test3 解锁用户账号方法二查看账户有没有被锁：passwd -S [用户名] 3.删除无用的账号 [root@hehe ~] userdel test1[root@hehe~] userdel -r test2 4.锁定账号文件passwd，shadow [root@hehe ~] chattr +i /etc/passwd /etc/shadow 锁定文件，包括root也无法修改[root@hehe ~] chattr -i /etc/passwd /etc/shadow 解锁文件[root@hehe ~] lsattr /etc/passwd /etc/shadow查看文件状态属性 举个例子： 二.密码安全控制： 1.设置密码有效期： 1.[root@localhost ~] chage -M 60 test3 这种方法适合修改已经存在的用户1​2.[root@localhost ~] vim /etc/login.defs 这种适合以后添加新用户PASS_MAX_DAYS 30 1.这个方法适用于早就已经存在的用户： 2.这个方法适用于新用户 2.要求用户下次登录时改密码： [root@hehe ~] chage -d 0 [用户名] 强制要求用户下次登陆时修改密码 三.命令历史限制与自动注销 1.命令历史限制： 1.减少记录的命令条数 减少记录命令的条数：1.[root@hehe ~] vim /etc/profile 进入配置文件修改限制命令条数。适合新用户HISTSIZE=200 修改限制命令为200条，系统默认是1000条profile [root@lhehe ~] source /etc/ 刷新配置文件，使文件立即生效2.[root@hehe~] export HISTSIZE=200 适用于当前（之后）用户[root@hehe~] source /etc/profile [root@hehe ~] source /etc/profile 刷新配置文件，使文件立即生效 1.减少记录命令的条数（适用之前的用户）： 2.注销时自动清空命令历史 3. 注销时自动清空命令：[root@hehe ~] vim ~/.bash_logout（临时清除，重启缓存的话还在）echo "" > ~/.bash_history（永久删除）history是查你使用过的命令 2.终端自动注销： 1.闲置600秒后自动注销 闲置600秒后自动注销：[root@hehe ~]vim .bash_profile 进入配置文件export TMOUT=600 全局声明超过60秒闲置后自动注销终端[root@hehe ~] source .bash_profile [root@hehe ~] echo $TMOUT[root@hehe ~] export TMOUT=600 如果不在配置文件输入这条命令，那么是对当前用户生效​[root@hehe ~]vim .bash_profile export TMOUT=600 注释掉这条命令，就不会自动注销了 四.PAM安全认证 1.su的命令的安全隐患 1.，默认情况下，任何用户都允许使用su命令，有机会反复尝试其他用户(如root) 的登录密码，带来安全风险； 2.为了加强su命令的使用控制，可借助于PAM认证模块,只允许极个别用户使用su命令进行切换。 2.什么是PAM 1.PAM(Pluggable Authentication Modules)可插拔式认证模块 2.是一种高效而且灵活便利的用户级别的认证方式； 3.也是当前Linux服务器普遍使用的认证方式。 4.PAM提供了对所有服务进行认证的中央机制，适用于login，远程登陆，su等应用 5.系统管理员通过PAM配置文件来制定不同的应用程序的不同认证策略 3.PAM认证原理 1.PAM认证一般遵循的顺序: Service (服务) --> PAM (配置文件) --> pam_.so;， 2.PAM认证首先要确定哪一项应用服务，然后加载相应的PAM的配置文件(位于/etc/pam.d下)，最后调用认 模块(位于/lib64/security/下）进行安全认证。 3.用户访问服务器的时候，服务器的某一个服务程序把用户的请求发送到PAM模块进行认证。不同的应用程序所对应的PAM模块也是不同的。 4.如果想查看某个程序是否支持PAM认证，可以用ls命令进行查看/etc/pam.d/。 ls /etc/pam.d/ | grep su 5.PAM的配置文件中的每一行都是一个独立的认证过程，它们按从上往下的顺序依次由PAM模块调用。 4.PAM安全认证流程 控制类型也称做Control Flags，用于PAM验证类型的返回结果 用户1 用户2 用户3 用户4 auth required 模块1 pass fail pass pass auth sufficient 模块2 pass pass fail pass auth required 模块3 pass pass pass fail 结果 pass fail pass pass 4 五.限制使用su命令的用户（pam-wheel认证模块） 1.su命令概述： 通过su命令可以非常方便切换到另一个用户，但前提条件是必须知道用户登录密码。对于生产环境中的Linux服务器，每多一个人知道特权密码，安全风险就多一分。于是就多了一种折中的办法，使用sudo命令提升执行权限，不过需要由管理员预先进行授权， 指定用户使用某些命令： 2. su命令的用途以及用法： 用途：以其他用户身份（如root）执行授权命令用法：sudo 授权命令 3.配置su的授权（加入wheel组）（pam_wheel认证模块：）： 进入授权命令：1.visudo 或者 vim /etc/sudoers语法格式：1.用户 主机名=命令程序列表2.用户 主机名=（用户）命令程序列表-l：列出用户在主机上可用的和被禁止的命令;一般配置好/etc/sudoers后，要用这个命令来查看和测试是不是配置正确的;-v：验证用户的时间戳;如果用户运行sudo后，输入用户的密码后，在短时间内可以不用输入口令来直接进行sudo操作;用-v可以跟踪最新的时间戳;-u：指定以以某个用户执行特定操作;-k：删除时间戳，下一个sudo命令要求用求提供密码; 1.首先创建3个组 2.vim /etc/pam.d/su把第六行注释去掉保存退出 1. 以上两行是默认状态(即开启第一行，注释第二行)，这种状态下是允许所有用户间使用su命令进行切换的 2.两行都注释也是运行所有用户都能使用su命令，但root下使用su切换到其他普通用户需要输入密码: 3.如果第–行不注释，则root 使用su切换普通用户就不需要输入密码( pam_ rootok. so模块的主要作用是使uid为0的用户，即root用户能够直接通过认证而不用输入密码。) 4.如果开启第二行，表示只有root用户和wheel1组内的用户才可以使用su命令。 5.如果注释第一行，开启第二行，表示只有whee1组内的用户才能使用su命令，root用户也被禁用su命令。 3.将liunan加入到wheel之后，hehe就有了使用su命令的权限 4.使用pam_wheel认证后，没有在wheel里的用户都不能再用su 5.whoami命令确定当前用户是谁 4.配置/etc/sudoers文件(授权用户较多的时候使用)： visudo单个授权visudo 或者 vim /etc/sudoers记录格式：user MACHINE=COMMANDS可以使用通配符“ ”号任意值和“ ！”号进行取反操作。%组名代表一整个组权限生效后，输入密码后5分钟可以不用重新输入密码。例如：visudo命令下user kiro=(root)NOPASSWD:/usr/sbin/useradd,PASSWD:/usr/sbin/usermod代表 kiro主机里的user用户，可以无密码使用useradd命令，有密码使用usermod/etc/sudoers多个授权Host_Alias MYHOST= localhost 主机别名：主机名、IP、网络地址、其他主机别名!取反Host_Alias MAILSVRS=smtp,pop（主机名）User_Alias MYUSER = kiro，user1,lisi 用户别名：包含用户、用户组（%组名（使用引导))、还可以包含其他其他已经用户的别名User_Alias OPERATORS=zhangsan,tom,lisi（需要授权的用户）Cmnd_Alias MYCMD = /sbin/,/usr/bin/passwd 命令路劲、目录（此目录内的所有命令)、其他事先定义过的命令别名Cmnd_Alias PKGTOOLS=/bin/rpm,/usr/bin/yum（授权）MYUSER MYHOST = NOPASSWD : MYCMDDS 授权格式sudo -l 查询目前sudo操作查看sudo操作记录需启用Defaults logfile配置默认日志文件: /var/log/sudosudo -l 查看当前用户获得哪些sudo授权（启动日志文件后，sudo操作过程才会被记录） 1.首先用visudo 或者 vim /etc/sudoers进入，输入需要授权的命令 2.切换到taojian用户，因为设置了它不能使用创建用户的命令所以无法创建 六.开关机安全控制 1.调整BIOS引导设置 1.将第一引导设备设为当前系统所在硬盘2.禁止从其他设备(光盘、U盘、网络)引导系统3.将安全级别设为setup，并设置管理员密码 2.GRUB限制 1.使用grub2-mkpasswd-pbkdf2生成密钥2.修改/etclgrub.d/00_header文件中，添加密码记录3.生成新的grub.cfg配置文件 方法一： 通常情况下在系统开机进入GRUB菜单时，按e键可以查看并修改GRUB引导参数，这对服务器是一个极大的威胁。可以为GRUB菜单设置一个密码，只有提供正确的密码才被允许修改引导参数。grub2-mkpasswd-pbkdf2 根据提示设置GRUB菜单的密码PBKDF2 hash of your password is grub.pbkd..... 省略部分内容为经过加密生成的密码字符串cp /boot/grub2/grub.cfg /boot/grub2/grub.cfg.bak 8cp /etc/grub.d/00_header /etc/grub.d/00_header.bak 9vim /etc/grub.d/00_headercat << EOFset superusers="root" 设置用户名为rootpassword_pbkdf2 root grub.pbkd2..... 设置密码，省略部分内容为经过加密生成的密码字符串EOF16grub2-mkconfig -o /boot/grub2/grub.cfg 生成新的grub.cfg文件重启系统进入GRUB菜单时，按e键将需要输入账号密码才能修改引导参数。 方法二： 1.一步到位2.grub2-setpassword 七.终端以及登录控制 1.限制root只在安全终端登录 ​安全终端配置文件在 /etc/securetty 2..禁止普通用户登录 1.建立/etc/nologin文件 2.删除nologin文件或重启后即恢复正常 vim /etc/securetty在端口前加号拒绝访问touch /etc/nologin 禁止普通用户登录rm -rf /etc/nologin 取消禁止 八.系统弱口令检测 1.JOHN the Ripper，简称为JR 1.一款密码分析工具，支持字典式的暴力破解2.通过对shadow文件的口令分析，可以检测密码强度3.官网网站：http://www.openwall.com/john/ 2.安装弱口令账号 1.获得Linux/Unix服务器的shadow文件2.执行john程序，讲shadow文件作为参数 3.密码文件的暴力破解 1.准备好密码字典文件，默认为password.lst2.执行john程序，结合--wordlist=字典文件 九.网络端口扫描 1.NMAP 1.—款强大的网络扫描、安全检测工具,支持ping扫描，多端口检测等多种技术。2.官方网站: http://nmap.orgl3.CentOS 7.3光盘中安装包,nmap-6.40-7.el7.x86_64.rpm 2.格式 NMAP [扫描类型] [选项] <扫描目标....> 安装NMAP软件包rpm -qa | grep nmapyum install -y nmapnmap命令常用的选项和扫描类型-p：指定扫描的端口。-n：禁用反向DNS 解析 (以加快扫描速度)。-sS：TCP的SYN扫描（半开扫描)，只向目标发出SYN数据包，如果收到SYN/ACK响应包就认为目标端口正在监听，并立即断开连接;否则认为目标端口并未开放。-sT：TCP连接扫描，这是完整的TCP扫描方式(默认扫描类型)，用来建立一个TCP连接，如果成功则认为目标端口正在监听服务，否则认为目标端口并未开放。-sF：TCP的FIN扫描，开放的端口会忽略这种数据包，关闭的端口会回应RST数据包。许多防火墙只对SYN数据包进行简单过滤，而忽略了其他形式的TCP attack 包。这种类型的扫描可间接检测防火墙的健壮性。-sU：UDP扫描，探测目标主机提供哪些UDP服务，UDP扫描的速度会比较慢。-sP：ICMP扫描，类似于ping检测，快速判断目标主机是否存活，不做其他扫描。-P0：跳过ping检测，这种方式认为所有的目标主机是存活的，当对方不响应ICMP请求时，使用这种方式可以避免因无法 ping通而放弃扫描。 总结： 1.账号基本安全措施：系统账号处理、密码安全控制、命令历史清理、自动注销 2.用户切换与提权（su、sudo） 3.开关机安全控制（BIOS引导设置、禁止Ctrl+Alt+Del快捷键、GRUB菜单设置密码） 4.终端控制 5.弱口令检测——John the Ripper 6.端口扫描——namp 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_67474417/article/details/123982900。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...征、降低模型复杂度和解决多重共线性问题的目的。 Lasso回归（Least Absolute Shrinkage and Selection Operator Regression） , Lasso回归是一种特殊的线性回归模型，属于正则化回归家族的一员。在建模过程中，它引入了一个惩罚项，该惩罚项会对模型参数的绝对值求和进行限制，这导致某些不重要的特征系数被压缩至零，从而实现了特征选择和稀疏解的效果。在信用卡消费预测案例中，由于原始数据中的多个自变量可能存在多重共线性问题，采用Lasso回归可以自动筛选出与因变量最相关的少数几个自变量，优化模型性能，提高预测准确性。

...组里，系统就会帮他们自动分配任务（也就是主题的分区），这样大家就不会抢来抢去，重复干同样的活儿啦！而且呢，要是有个消费者挂掉了或者出问题了，其他的消费者就会顶上来，接手它负责的那些分区，接着干活儿，完全不受影响。 --- 3. 组织结构 Kafka的大脑与四肢 3.1 集群（Cluster）：Kafka的心脏 Kafka集群是由多个Broker组成的，Broker是Kafka的核心组件，负责存储和转发消息。一个Broker就是一个节点，多个Broker协同工作，形成一个分布式的系统。 java // 启动Kafka Broker nohup kafka-server-start.sh config/server.properties & Broker的数量决定了系统的容错能力和性能。其实啊，通常咱们都会建议弄三个Broker，为啥呢？就怕万一有个家伙“罢工”了，比如突然挂掉或者出问题，别的还能顶上，整个系统就不耽误干活啦！不过，Broker的数量也不能太多，否则会增加管理和维护的成本。 3.2 Zookeeper：Kafka的大脑 Zookeeper是Kafka的协调器，它负责管理集群的状态和配置。没有Zookeeper，Kafka就无法正常运作。比如说啊，新添了个Broker（也就是那个消息中转站），Zookeeper就会赶紧告诉其他Broker：“嘿，快看看这位新伙伴，更新一下你们的状态吧！”还有呢，要是某个分区的老大换了（Leader切换了），Zookeeper也会在一旁默默记好这笔账，生怕漏掉啥重要信息似的。 java // 启动Zookeeper nohup zookeeper-server-start.sh config/zookeeper.properties & 虽然Zookeeper很重要，但它也有一定的局限性。比如，它可能会成为单点故障，影响整个系统的稳定性。因此，近年来Kafka也在尝试去掉对Zookeeper的依赖，开发了自己的内部协调机制。 3.3 日志（Log）：Kafka的四肢 日志是Kafka存储消息的地方，每个分区对应一个日志文件。嘿，这个日志设计可太聪明了！它用的是顺序写入的方法，就像一条直线往前跑，根本不用左顾右盼，写起来那叫一个快，效率直接拉满！ java // 查看日志路径 cat config/server.properties | grep log.dirs 日志的大小可以通过参数log.segment.bytes来控制。默认值是1GB，你可以根据实际情况调整。要是日志文件太大了，查个东西就像在大海捞针一样慢吞吞的；但要是弄得太小吧，又老得换新的日志文件，麻烦得很，还费劲。 --- 4. 实战演练 从零搭建一个Kafka环境 说了这么多理论，咱们来实际操作一下吧！假设我们要搭建一个简单的Kafka环境，用来收集用户的登录日志。 4.1 安装Kafka和Zookeeper 首先，我们需要安装Kafka和Zookeeper。可以从官网下载最新的二进制包，解压后按照文档配置即可。 bash 下载Kafka wget https://downloads.apache.org/kafka/3.4.0/kafka_2.13-3.4.0.tgz 解压 tar -xzf kafka_2.13-3.4.0.tgz 4.2 创建主题和消费者 接下来，我们创建一个名为login_logs的主题，并启动一个消费者来监听消息。 bash 创建主题 bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic login_logs 启动消费者 bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic login_logs --from-beginning 4.3 生产消息 最后，我们可以编写一个简单的Java程序来生产消息。 java import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; import java.util.Properties; public class KafkaProducerExample { public static void main(String[] args) { Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); KafkaProducer producer = new KafkaProducer<>(props); for (int i = 0; i < 10; i++) { producer.send(new ProducerRecord<>("login_logs", "key" + i, "value" + i)); } producer.close(); } } 这段代码会向login_logs主题发送10条消息，每条消息都有一个唯一的键和值。 --- 5. 总结 Kafka的魅力在于细节 好了，到这里咱们的Kafka之旅就告一段落了。通过这篇文章，我希望大家能更好地理解Kafka的命名规范和组织结构。Kafka为啥这么牛？因为它在设计的时候真是把每个小细节都琢磨得特别透。就像给主题起名字吧，分个区啦，还有消费者组怎么配合干活儿，这些地方都能看出人家确实是下了一番功夫的，真不是随便凑合出来的！ 当然，Kafka的学习之路还有很多内容需要探索，比如监控、调优、安全等等。其实我觉得啊，只要你把命名的规矩弄明白了，东西该怎么放也心里有数了，那你就算是走上正轨啦，成功嘛，它就已经在向你招手啦！加油吧，朋友们！ --- 希望这篇文章对你有所帮助，如果有任何疑问，欢迎随时交流哦！