C++ Boost 异步网络编程基础

Boost库为C++提供了强大的支持，尤其在多线程和网络编程方面。其中，Boost.Asio库是一个基于前摄器设计模式的库，用于实现高并发和网络相关的开发。Boost.Asio核心类是io_service，它相当于前摄模式下的Proactor角色。所有的IO操作都需要通过io_service来实现。

在异步模式下，程序除了发起IO操作外，还需要定义一个用于回调的完成处理函数。io_service将IO操作交给操作系统执行，但它不同步等待，而是立即返回。调用io_service的run成员函数可以等待异步操作完成。当异步操作完成时，io_service会从操作系统获取结果，再调用相应的处理函数（handler）来处理后续逻辑。

这种异步模型的优势在于它能够更有效地利用系统资源，避免线程阻塞，提高程序的并发性能。Boost.Asio的设计让开发者能够以高效的方式开发跨平台的并发网络应用，使C++在这方面能够与类似Java等语言相媲美。

ASIO异步定时器

boost::asio::deadline_timer 是 Boost.Asio 库中用于处理定时器的类。它允许你在一段时间后或在指定的时间点触发回调函数。deadline_timer 通常与 io_service 配合使用，以实现异步定时器功能。

以下是 boost::asio::deadline_timer 的一些重要概念和方法：

构造函数： deadline_timer 的构造函数通常需要一个 io_service 对象和一个时间参数。时间参数可以是相对时间（相对于当前时间的一段时间间隔）或绝对时间（具体的时刻）。

cppCopy codeboost::asio::io_service io_service;
boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(5));

expires_from_now 方法： 通过调用 expires_from_now 方法，可以设置相对于当前时间的时间间隔，来定义定时器的到期时间。

cppCopy code
timer.expires_from_now(boost::posix_time::seconds(10));

expires_at 方法： 通过调用 expires_at 方法，可以设置定时器的到期时间为一个具体的时刻。

cppCopy codeboost::posix_time::ptime expiryTime = boost::posix_time::second_clock::local_time() + boost::posix_time::seconds(10);
timer.expires_at(expiryTime);

async_wait 方法： async_wait 方法用于启动异步等待定时器的到期。它接受一个回调函数作为参数，该回调函数将在定时器到期时被调用。

cppCopy codevoid timerCallback(const boost::system::error_code& /*e*/)
{std::cout << "Timer expired!" << std::endl;
}timer.async_wait(boost::bind(timerCallback, boost::asio::placeholders::error));

取消定时器： 你可以通过调用 cancel 方法来取消定时器，以停止它在到期时触发回调函数。

cppCopy code
timer.cancel();

boost::asio::deadline_timer 提供了一种灵活和强大的方式来处理异步定时器操作，使得你可以方便地执行定时任务、调度操作或执行周期性的工作。

#include <iostream>
#include <boost/asio.hpp>using namespace std;
using namespace boost::asio;void handler(const boost::system::error_code &ec)
{cout << "hello lyshark A" << endl;
}void handler2(const boost::system::error_code &ec)
{cout << "hello lyshark B" << endl;
}int main(int argc,char *argv)
{boost::asio::io_service service;boost::asio::deadline_timer timer(service, boost::posix_time::seconds(5));timer.async_wait(handler);boost::asio::deadline_timer timer2(service, boost::posix_time::seconds(10));timer2.async_wait(handler2);service.run();std::system("pause");return 0;
}

上述代码运行后，会分别间隔5秒及10秒，用来触发特定的handler函数，效果如下图所示；

在 Boost.Asio 中，io_service::run() 是一个关键的方法，它用于运行 I/O 服务的事件循环。通常，run() 方法会一直运行，直到没有更多的工作需要完成，即直到没有未完成的异步操作。

如果多个异步函数同时调用同一个 io_service 的 run() 方法，可以考虑将 run() 方法单独摘出来，以便在线程函数中多次调用。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread.hpp>using namespace std;
using namespace boost::asio;void handler(const boost::system::error_code &ec)
{cout << "hello lyshark A" << endl;
}void handler2(const boost::system::error_code &ec)
{cout << "hello lyshark B" << endl;
}boost::asio::io_service service;void run()
{service.run();
}int main(int argc,char *argv)
{boost::asio::deadline_timer timer(service, boost::posix_time::seconds(5));timer.async_wait(handler);boost::asio::deadline_timer timer2(service, boost::posix_time::seconds(10));timer2.async_wait(handler2);boost::thread thread1(run);boost::thread thread2(run);thread1.join();thread2.join();std::system("pause");return 0;
}

上述代码的运行效果与第一个案例一致，唯一的不同在于，该案例中我们通过boost::thread分别启动了两个线程，并通过join()分别等待这两个线程的执行结束，让异步与线程分离。

通过多次触发计时器，实现重复计时器功能，如下代码使用 Boost.Asio 实现了一个异步定时器的例子。

该程序定义了一个计数器 count，并创建了一个 steady_timer 对象 io_timer，设置其到期时间为 1 秒。然后，通过 io_timer.async_wait 启动了一个异步等待操作，该操作在计时器到期时调用 print 函数。

在 print 函数中，首先判断计数器是否小于 5，如果是，则输出计数器的值，并将计时器的到期时间延迟 1 秒。然后，再次启动新的异步等待操作，递归调用 print 函数。当计数器达到 5 时，停止了 io 对象，这会导致 io.run() 返回，程序退出。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>// 定义输出函数
void print(const boost::system::error_code &,boost::asio::steady_timer * io_timer, int * count)
{// 如果计时器等于4也就是循环5此后自动停止if (*count < 5){std::cout << "Print函数计数器: " << *count << std::endl;++(*count);// 将计时器到期时间向后延时1秒io_timer->expires_at(io_timer->expiry() + boost::asio::chrono::seconds(1));// 启动一个新的异步等待io_timer->async_wait(boost::bind(print,boost::asio::placeholders::error, io_timer, count));}
}int main(int argc, char *argv)
{boost::asio::io_context io;int count = 0;// 定义IO时间为1秒boost::asio::steady_timer io_timer(io, boost::asio::chrono::seconds(1));// 绑定并调用print函数io_timer.async_wait(boost::bind(print, boost::asio::placeholders::error, &io_timer, &count));io.run();std::cout << "循环已跳出,总循环次数: " << count << std::endl;std::system("pause");return 0;
}

运行上述代码，输出效果如下图所示，通过计数器循环执行特定次数并输出，每次间隔为1秒。

与之前的代码相比，如下所示的版本使用了一个类 print 来封装定时器操作。

与之前版本相比的主要不同点：

  1. 类的引入： 引入了 print 类，将定时器和计数器等相关的操作封装到了一个类中，提高了代码的封装性和可读性。
  2. 构造函数和析构函数： 在 print 类中使用构造函数初始化 timer_ 定时器，而在析构函数中打印最终循环次数。这样的设计使得对象的创建和销毁分别与初始化和清理相关的操作关联起来。
  3. 成员函数 run_print： 使用了成员函数 run_print 作为定时器回调函数，无需再使用 boost::bind 绑定 this 指针，直接使用类的成员变量，提高了代码的简洁性。
  4. 对象的创建和运行： 在 main 函数中，直接创建了 print 对象 ptr，并通过 io.run() 来运行异步操作，无需手动调用 async_wait。这种方式更加面向对象，将异步操作和对象的生命周期绑定在一起。
#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>class print
{
private:boost::asio::steady_timer timer_;int count_;public:// 构造时引用io_context对象,使用它初始化timerprint(boost::asio::io_context& io) : timer_(io, boost::asio::chrono::seconds(1)), count_(0){// 使用 bind 绑定当前对象的 this 指针，利用成员 count 控制计时器的执行timer_.async_wait(boost::bind(&print::run_print, this));}// 在析构中打印结果~print(){std::cout << "循环已跳出,总循环次数: " << count_ << std::endl;}// 作为类的成员函数，无需再传入参数，直接使用当前对象的成员变量void run_print(){if (count_ < 5){std::cout << "Print函数计时器: " << count_ << std::endl;++count_;timer_.expires_at(timer_.expiry() + boost::asio::chrono::seconds(1));timer_.async_wait(boost::bind(&print::run_print, this));}}
};int main(int argc, char *argv)
{boost::asio::io_context io;print ptr(io);io.run();std::system("pause");return 0;
}

这个输出效果与之前基于过程的保持一致，其他的并无差异；

如下版本的代码相对于之前的版本引入了 io_context::strand 来保证定时器回调函数的串行执行，避免了多个线程同时执行 print1 和 print2 导致的竞态条件。

与之前版本相比的主要不同点：

  1. io_context::strand 的引入： 引入了 io_context::strand 对象 strand_，用于确保 print1 和 print2 的回调函数在同一线程内按序执行。io_context::strand 在多线程环境中提供了同步操作，确保绑定到 strand_ 上的操作不会同时执行。
  2. bind_executor 的使用： 在 async_wait 中使用了 boost::asio::bind_executor 函数，将定时器的回调函数与 strand_ 绑定，保证了异步操作的执行在 strand_ 内。这样可以确保 print1 和 print2 不会在不同线程中同时执行。
  3. 多线程运行 io_context： 引入了两个子线程 t 和 t1，分别调用 io_context::run 来运行 io_context。这样可以使 io_context 在两个独立的线程中运行，增加了并发性。
  4. 线程的 Join： 在 main 函数中，通过 t.join() 和 t1.join() 等待两个子线程执行完成后再退出程序。这样确保了 main 函数在所有线程都完成后再结束。

总体而言，这个版本通过引入 io_context::strand 以及多线程运行 io_context，解决了异步操作可能导致的竞态条件，增强了程序的并发性。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>class print
{
public:print(boost::asio::io_context& io) : strand_(io),  // strand用于控制handler的执行timer1_(io, boost::asio::chrono::seconds(1)),   // 运行两个计时器timer2_(io, boost::asio::chrono::seconds(1)),count_(0){// 启动异步操作时，每个 handler 都绑定到 strand 对象// bind_executor() 返回一个新的 handler，它将自动调度其包含的 print::print1// 通过将 handler 绑定到同一个 strand，保证两个print不会同时执行timer1_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print1, this)));timer2_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print2, this)));}void print1(){if (count_ < 10){std::cout << "Print 1: " << count_ << std::endl;++count_;timer1_.expires_at(timer1_.expiry() + boost::asio::chrono::seconds(1));timer1_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print1, this)));}}void print2(){if (count_ < 10){std::cout << "Print 2: " << count_ << std::endl;++count_;timer2_.expires_at(timer2_.expiry() + boost::asio::chrono::seconds(1));timer2_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print2, this)));}}private:boost::asio::io_context::strand strand_;boost::asio::steady_timer timer1_;boost::asio::steady_timer timer2_;int count_;
};int main(int argc,char *argv[])
{// 第一个线程boost::asio::io_context io;print ptr(io);// 定义两个子线程boost::thread t(boost::bind(&boost::asio::io_context::run, &io));boost::thread t1(boost::bind(&boost::asio::io_context::run, &io));io.run();t.join();t1.join();std::system("pause");return 0;
}

输出效果如下图所示；

ASIO异步网络通信

异步通信的原理与同步通信不同，主要体现在程序对IO请求的处理上。在异步状态下，程序发起IO请求后会立即返回，无需等待IO操作完成。无论IO操作成功还是失败，程序都可以继续执行其他任务，不会被阻塞。当IO请求被执行完成后，系统会通过回调函数的方式通知调用者，使其能够获取操作的状态或结果。

这种异步通信的机制带来了一些优势：

  1. 提高并发性： 在异步模式下，程序在等待IO操作完成的过程中不会阻塞，可以继续执行其他任务，充分利用了宝贵的CPU时间。这使得程序更容易实现高并发，同时处理多个IO操作。
  2. 节省时间： 由于程序不需要等待IO操作完成，可以更加高效地利用时间。在同步模式下，程序必须等待每个IO操作的完成，而在异步模式下，可以在等待的时间内执行其他任务，提高了整体效率。
  3. 提高系统响应性： 异步通信使得程序能够更灵活地响应IO事件，及时处理完成的IO操作。这对于需要快速响应用户请求的系统非常重要，如网络通信、图形用户界面等。
  4. 减少资源浪费： 在异步模式下，程序可以通过回调函数获取IO操作的结果，而无需通过轮询或其他方式一直等待。这减少了对系统资源的浪费，提高了系统的效率。

异步通信的原理在于通过非阻塞的方式发起IO请求，充分利用等待IO完成的时间，通过回调函数的方式获取IO操作的结果，以提高程序的并发性、响应性和效率。

使用Boost.Asio库实现简单的异步TCP服务器。

对代码的主要分析：

  1. IOService 结构体：
    • 该结构体负责管理 io_service 和 acceptor。
    • 构造函数初始化 io_service 和 acceptor 对象。acceptor 用于监听连接请求。
    • start() 函数启动异步等待连接操作，当有客户端连接请求时，触发 accept_handler。
  2. start() 函数：
    • 在 start() 函数中，通过 async_accept 异步等待连接请求，当有客户端连接请求时，会触发 accept_handler 函数。
    • 创建了一个新的 tcp::socket 对象，并使用 async_accept 异步等待连接请求。
    • accept_handler 函数被绑定，负责处理连接成功后的操作。
  3. accept_handler 函数：
    • 当有客户端连接成功时，该函数会被调用。
    • 递归调用 start()，以便继续等待新的连接请求。
    • 输出远程客户端的IP地址。
    • 创建一个字符串指针 pstr，并发送 “hello lyshark” 给客户端。
  4. write_handler 函数：
    • 当异步写操作完成时，该函数被调用。
    • 输出已发送的信息。
  5. main 函数：
    • 创建了一个 io_service 对象和 IOService 对象 server。
    • 调用 server.start() 启动服务器。
    • 调用 io.run() 启动 IO 服务，使其保持运行状态，直到所有异步操作完成。

整体而言，这个程序通过异步的方式接受客户端连接，并在连接建立后异步发送消息给客户端。使用 Boost.Asio 提供的异步操作可以实现高效的并发网络编程。

#include <iostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/smart_ptr.hpp>using namespace boost::asio;
using boost::system::error_code;
using ip::tcp;struct IOService
{IOService(io_service &io) :m_iosev(io), m_acceptor(io, tcp::endpoint(tcp::v4(), 80)){std::cout << "执行构造函数" << std::endl;}void start(){// 非阻塞等待连接boost::shared_ptr<tcp::socket> psocket(new tcp::socket(m_iosev));// 绑定 IOService::accept_handler 当有请求进来时,自动回调到绑定accept_handler函数上m_acceptor.async_accept(*psocket,boost::bind(&IOService::accept_handler, this, psocket, _1));}// 有客户端连接时accept_handler触发void accept_handler(boost::shared_ptr<tcp::socket> psocket, error_code ec){if (ec) return;// 再次递归调用start()函数继续等待新连接进入start();// 显示远程IPstd::cout << "远端IP: " << psocket->remote_endpoint().address() << std::endl;// 发送信息(非阻塞)boost::shared_ptr<std::string> pstr(new std::string("hello lyshark"));// 绑定 IOService::write_handler 回调函数,当发送完成后,自动触发 write_handlerpsocket->async_write_some(buffer(*pstr),boost::bind(&IOService::write_handler, this, pstr, _1, _2));}// 异步写操作完成后write_handler触发void write_handler(boost::shared_ptr<std::string> pstr,error_code ec, size_t bytes_transferred){if (!ec)std::cout << *pstr << " 已发送" << std::endl;}private:io_service &m_iosev;ip::tcp::acceptor m_acceptor;
};int main(int argc, char* argv[])
{io_service io;IOService server(io);server.start();io.run();return 0;
}

客户端代码

#include <iostream>
#include <string>
#include <boost/asio.hpp>using namespace boost::asio;int main(int argc, char *argv[])
{io_service io_service;ip::tcp::endpoint ep(ip::address::from_string("127.0.0.1"), 1000);ip::tcp::socket socket(io_service);socket.connect(ep);char buffer[1024] = { 0 };socket.read_some(boost::asio::buffer(buffer));std::cout << buffer << std::endl;std::system("pause");return 0;
}

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

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

相关文章

leetCode 100. 相同的树 和 leetCode 101. 对称二叉树 和 110. 平衡二叉树 和 199. 二叉树的右视图

leetCode 100. 相同的树 和 leetCode 101. 对称二叉树 和 110. 平衡二叉树 和 199. 二叉树的右视图

1.leetCode 100. 相同的树 C代码&#xff1a; class Solution { public:bool isSameTree(TreeNode* p, TreeNode* q) {if(p nullptr || q nullptr) return pq;return p->val q->val && isSameTree(p->left,q->left) && isSameTree(p->righ…
阅读更多...
详解Java中的异常体系机构（throw，throws，try-catch，finally，自定义异常）

详解Java中的异常体系机构（throw，throws，try-catch，finally，自定义异常）

目录 一.异常的概念 二.异常的体系结构 三.异常的处理 异常处理思路 LBYL&#xff1a;Look Before You Leap EAFP: Its Easier to Ask Forgiveness than Permission 异常抛出throw 异常的捕获 提醒声明throws try-catch捕获处理 finally的作用 四.自定义异常类 一.异…
阅读更多...
openEuler20.03学习01-创建虚拟机

openEuler20.03学习01-创建虚拟机

赶个时髦&#xff0c;开始学习openEuler 20.03 (LTS-SP3) 操作系统iso下载地址&#xff1a;https://repo.openeuler.openatom.cn/openEuler-20.03-LTS-SP3/ISO/x86_64/openEuler-20.03-LTS-SP3-x86_64-dvd.iso 公司有现成的vmware环境&#xff0c;创建虚拟机i测试&#xff0c…
阅读更多...
【pandas】数据透视表【pivot_table】

【pandas】数据透视表【pivot_table】

pivot_table pandas的pivot_table函数是一个非常有用的工具&#xff0c;用于创建一个数据透视表&#xff0c;这是一种用于数据总结和分析的表格形式。 以下是pivot_table的基本语法&#xff1a; pandas.pivot_table(data, valuesNone, indexNone, columnsNone, aggfuncmean,…
阅读更多...
基于opencv+ImageAI+tensorflow的智能动漫人物识别系统——深度学习算法应用(含python、JS、模型源码)+数据集（三）

基于opencv+ImageAI+tensorflow的智能动漫人物识别系统——深度学习算法应用(含python、JS、模型源码)+数据集（三）

目录 前言总体设计系统整体结构图系统流程图 运行环境爬虫模型训练实际应用 模块实现1. 数据准备1&#xff09;爬虫下载原始图片2&#xff09;手动筛选图片 2. 数据处理1&#xff09;切割得到人物脸部2&#xff09;重新命名处理后的图片3&#xff09;添加到数据集 3. 模型训练及…
阅读更多...
十大排序之归并排序（详解）

十大排序之归并排序（详解）

文章目录 &#x1f412;个人主页&#x1f3c5;算法思维框架&#x1f4d6;前言&#xff1a; &#x1f380;归并排序 时间复杂度O(n*logn)&#x1f387;1. 算法步骤思想&#x1f387;2、动画演示&#x1f387;3.代码实现 &#x1f412;个人主页 &#x1f3c5;算法思维框架 &#…
阅读更多...
lvm 扩容根分区失败记录

lvm 扩容根分区失败记录

lvm 扩容根分区失败记录 1、问题描述2、错误描述3、解决方法重启系统进入grub界面&#xff0c;选择kernel 2.x 启动系统。然后同样的resize2fs命令扩容成功。 1、问题描述 根分区不足。 系统有2个内核版本&#xff0c;一个是kernel 2.x&#xff0c;另一个是kernel 4.x。 这次l…
阅读更多...
C语言剔除相关数（ZZULIOJ1204:剔除相关数）

C语言剔除相关数（ZZULIOJ1204:剔除相关数）

题目描述 一个数与另一个数如果含有相同数字和个数的字符&#xff0c;则称两数相关。现有一堆乱七八糟的整数&#xff0c;里面可能充满了彼此相关的数&#xff0c;请你用一下手段&#xff0c;自动地将其剔除。 输入&#xff1a;多实例测试。每组数据包含一个n(n<1000)&#…
阅读更多...
知行之桥EDI系统HTTP签名验证

知行之桥EDI系统HTTP签名验证

本文简要概述如何在知行之桥EDI系统中使用 HTTP 签名身份验证&#xff0c;并将使用 CyberSource 作为该集成的示例。 API 概述 首字母缩略词 API 代表“应用程序编程接口”。这听起来可能很复杂&#xff0c;但真正归结为 API 是一种允许两个不同实体相互通信的软件。自开发以…
阅读更多...
2023.11.25-电商项目建设业务学习1-指标,业务流程,核销

2023.11.25-电商项目建设业务学习1-指标,业务流程,核销

目录 1.指标分类(原子指标,派生指标,衍生指标) 2.一些业务名词 3.四大业务流程-销售需求 3.1-线上线下销售 3.2线上线下退款 4.四大业务流程-会员业务 5.四大业务流程-供应链业务 6.四大业务流程-商城业务 7.核销主题需求分析 1.指标分类(原子指标,派生指标,衍生指标) 原…
阅读更多...
JVM类加载的过程和JVM垃圾回收机制

JVM类加载的过程和JVM垃圾回收机制

文章目录 一、JVM类加载的过程1.1类加载的基本流程1.1.1加载1.1.2验证1.1.3准备1.1.4解析1.1.5初始化 1.2双亲委派模型 二、JVM垃圾回收机制2.1找到垃圾2.1.1引用计数(比如Python&#xff0c;PHP中用到)2.1.2可达性分析(比如Java中用到) 2.2释放垃圾2.2.1标记清除2.2.2复制算法…
阅读更多...
Nginx配置文件中的关键字是什么？详细解释来了

Nginx配置文件中的关键字是什么？详细解释来了

点击上方蓝字关注我 Nginx 是一款高性能的 Web 服务器软件&#xff0c;同时也是一款反向代理服务器软件。Nginx 的配置文件通常是 /etc/nginx/nginx.conf&#xff0c;以下是一个典型的配置文件&#xff0c;并对其中的关键字进行详细解释。 1. 配置文件 perlCopy codeuser ngin…
阅读更多...
计算机编程零基础编程学什么语言，中文编程工具构件简介软件下载

计算机编程零基础编程学什么语言，中文编程工具构件简介软件下载

计算机编程零基础编程学什么语言&#xff0c;中文编程工具构件简介软件下载 给大家分享一款中文编程工具&#xff0c;零基础轻松学编程&#xff0c;不需英语基础&#xff0c;编程工具可下载。 这款工具不但可以连接部分硬件&#xff0c;而且可以开发大型的软件&#xff0c;象如…
阅读更多...
Redis集群(新)

Redis集群(新)

1.什么是集群 Redis集群实现了对Redis的水平扩容&#xff0c;可实现并发写操作&#xff0c;启动n个redis节点&#xff0c;将数据分别存储在不同的节点中&#xff0c;每块节点负责不同区域的插槽&#xff0c;所以Redis集群通过分区来提供一定程度的可用性。 Redis集群现采用的是…
阅读更多...
EFAK-v3.0.1版部署与使用

EFAK-v3.0.1版部署与使用

一、前言 EFAK&#xff08;(Eagle For Apache Kafka&#xff0c;以前称为Kafka Eagle&#xff09;用于在使用 Topic 的情况下监控 Kafka 集群。包含Offset 的产生、Lag的变化、Partition的分布、Owner、Topic的创建以及修改的时间等信息。 二、环境&安装包 官方下载连接E…
阅读更多...
Spring Boot 整合MyBatis-Plus 详解

Spring Boot 整合MyBatis-Plus 详解

MyBatis-Plus (opens new window)&#xff08;简称 MP&#xff09;是一个 MyBatis (opens new window)的增强工具&#xff0c;在 MyBatis 的基础上只做增强不做改变&#xff0c;为简化开发、提高效率而生。 全新的 MyBatis-Plus 3.0 版本基于 JDK8&#xff0c;提供了 lambda 形…
阅读更多...
积分球吸收光谱测量的领域有哪些？

积分球吸收光谱测量的领域有哪些？

积分球吸收光谱测量是一种常用的吸收光谱测量方法&#xff0c;它通过将样品放置在积分球的入口处&#xff0c;球内的光线经过多次反射后形成均匀的照度分布&#xff0c;然后使用光度计或光谱仪对光线进行测量&#xff0c;可以获得样品的相关参数。 在积分球吸收光谱测量中&…
阅读更多...
十大排序之选择排序（详解）

十大排序之选择排序（详解）

文章目录 &#x1f412;个人主页&#x1f3c5;算法思维框架&#x1f4d6;前言&#xff1a; &#x1f380;选择排序 时间复杂度O(n^2)&#x1f387;1. 算法步骤思想&#x1f387;2.动画实现&#x1f387; 3.代码实现 &#x1f412;个人主页 &#x1f3c5;算法思维框架 &#x1f…
阅读更多...
Java数组的复制、截取（内含例题：力扣-189.轮转数组）

Java数组的复制、截取（内含例题：力扣-189.轮转数组）

目录 数组的复制、截取&#xff1a; 1、使用Arrays中的copyOf方法完成数组的拷贝 2、使用Arrays中的copyofRange方法完成数组的拷贝 题目链接&#xff1a; 数组的复制、截取&#xff1a; 1、使用Arrays中的copyOf方法完成数组的拷贝 public class Csdn {public static vo…
阅读更多...
Edit And Resend测试接口工具（浏览器上的Postman）

Edit And Resend测试接口工具（浏览器上的Postman）

优点 可以不用设置Cookie或者Token&#xff0c;只设置参数进行重发接口测试API 使用Microsoft Rdge浏览器 F12——然后点击网络——在页面点击发起请求——然后选择要重发的请求右键选择Edit And Resend——在网络控制台设置自己要设置的参数去测试自己写的功能
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023