C++ 简单实现RPC网络通讯

news2024/11/15 15:53:23

        RPC是远程调用系统简称，它允许程序调用运行在另一台计算机上的过程，就像调用本地的过程一样。RPC 实现了网络编程的“过程调用”模型，让程序员可以像调用本地函数一样调用远程函数。最近在做的也是远程调用过程，所以通过重新梳理RPC来整理总结一下。

        项目来源：

        GitHub - qicosmos/rest_rpc: modern C++(C++11), simple, easy to use rpc framework

目录

一、RPC简介

1.1 简介

1.2 本地调用和远程调用的区别

1.3 RPC运行的流程

1.4 小结

二、RPC简单实现

2.1 客户端实现代码

2.2 服务端代码

三、加强版RPC（以“RPC简单实现”为基础）

3.1 加入错误处理

3.2 加入网络连接（socket）

3.3 加强并发性

3.4 加入容错机制（修改客户端部分）

3.5 负载均衡

四、总结

一、RPC简介

1.1 简介

        RPC指的是计算机A的进程调用另外一台计算机B的进程，A上的进程被挂起，B上被调用的进程开始执行，当B执行完毕后将执行结果返回给A，A的进程继续执行。调用方可以通过使用参数将信息传送给被调用方，然后通过传回的结果得到信息。这些传递的信息都是被加密过或者其他方式处理。这个过程对开发人员是透明的，因此RPC可以看作是本地过程调用的一种扩展，使被调用过程不必与调用过程位于同一物理机中。

        RPC可以用于构建基于B/S模式的分布式应用程序：请求服务是一个客户端、而服务提供程序是一台服务器。和常规和本地的调用过程一样，远程过程调用是同步操作，在结果返回之前，需要暂时中止请求程序。

RPC的优点：

  1. 支持面向过程和面向线程的模型；
  2. 内部消息传递机制对用户隐藏；
  3. 基于 RPC 模式的开发可以减少代码重写；
  4. 可以在本地环境和分布式环境中运行；

1.2 本地调用和远程调用的区别

        以ARM环境为例，我们拆解本地调用的过程，以下面代码为例：

int selfIncrement(int a)
{
    return a + 1;
}

int a = 10;
selfIncrement(a);

        当执行到selfIncrement(a)时，首先把a存入寄存器R0，之后转到函数地址selfIncrement，执行函数内的指令 ADD R0,#1。跳转到函数的地址偏移量在编译时确定。

        但是如果这是一个远程调用，selfIncrement函数存在于其他机器，为了实现远程调用，请求方和服务方需要提供需要解决以下问题：

        1. 网络传输。

                本地调用的参数存放在寄存器或栈中，在同一块内存中，可以直接访问到。远程过程调用需要借助网络来传递参数和需要调用的函数 ID。

        2. 编解码

                请求方需要将参数转化为字节流，服务提供方需要将字节流转化为参数。

        3. 函数映射表

                服务提供方的函数需要有唯一的 ID 标识，请求方通过 ID 标识告知服务提供方需要调用哪个函数。

以上三个功能即为 RPC 的基本框架所必须包含的功能。

1.3 RPC运行的流程

一次 RPC 调用的运行流程大致分为如下七步，具体如下图所示。

  1. 客户端调用客户端存根程序，将参数传入；
  2. 客户端存根程序将参数转化为标准格式，并编组进消息；
  3. 客户端存根程序将消息发送到传输层，传输层将消息传送至远程服务器；
  4. 服务器的传输层将消息传递到服务器存根程序，存根程序对阐述进行解包，并使用本地调用的机制调用所需的函数；
  5. 运算完成之后，将结果返回给服务器存根，存根将结果编组为消息，之后发送给传输层;
  6. 服务器传输层将结果消息发送给客户端传输层；
  7. 客户端存根对返回消息解包，并返回给调用方。

        服务端存根和客户端存根可以看做是被封装起来的细节，这些细节对于开发人员来说是透明的，但是在客户端层面看到的是 “本地” 调用了 selfIncrement() 方法，在服务端层面，则需要封装、网络传输、解封装等等操作。因此 RPC 可以看作是传统本地过程调用的一种扩展，其使得被调用过程不必与调用过程位于同一物理机中。

1.4 小结

        RPC 的目标是做到在远程机器上调用函数与本地调用函数一样的体验。 为了达到这个目的，需要实现网络传输、序列化与反序列化、函数映射表等功能，其中网络传输可以使用socket或其他，序列化和反序列化可以使用protobuf，函数映射表可以使用std::function。

        lambda与std::function内容可以看：

C++11 匿名函数lambda的使用_Thomas_Lbw的博客-CSDN博客

C++11 std::function 基础用法_Thomas_Lbw的博客-CSDN博客

  lambda 表达式和 std::function 的功能是类似的，lambda 表达式可以转换为 std::function，一般情况下，更多使用 lambda 表达式，只有在需要回调函数的情况下才会使用 std::function。

二、RPC简单实现

2.1 客户端实现代码

#include <iostream>
#include <memory>
#include <thread>
#include <functional>
#include <cstring>

class RPCClient
{
public:
    using RPCCallback = std::function<void(const std::string&)>;
    RPCClient(const std::string& server_address) : server_address_(server_address) {}
    ~RPCClient() {}

    void Call(const std::string& method, const std::string& request, RPCCallback callback)
    {
        // 序列化请求数据
        std::string data = Serialize(method, request);
        // 发送请求
        SendRequest(data);
        // 开启线程接收响应
        std::thread t([this, callback]() {
            std::string response = RecvResponse();
            // 反序列化响应数据
            std::string result = Deserialize(response);
            callback(result);
        });
        t.detach();
    }

private:
    std::string Serialize(const std::string& method, const std::string& request)
    {
        // 省略序列化实现
    }

    void SendRequest(const std::string& data)
    {
        // 省略网络发送实现
    }

    std::string RecvResponse()
    {
        // 省略网络接收实现
    }

    std::string Deserialize(const std::string& response)
    {
        // 省略反序列化实现
    }

private:
    std::string server_address_;
};

int main()
{
    std::shared_ptr<RPCClient> client(new RPCClient("127.0.0.1:8000"));
    client->Call("Add", "1,2", [](const std::string& result) {
        std::cout << "Result: " << result << std::endl;
    });
    return 0;
}

        这段代码定义了RPCClient类来处理客户端的请求任务，用到了lambda和std::function来处理函数调用，在Call中使用多线程技术。main中使用智能指针管理Rpcclient类，并调用了客户端的Add函数。 

        127.0.0.1为本地地址，对开发来说需要使用本地地址自测，端口号为8000，需要选择一个空闲端口来通信。

2.2 服务端代码

        下面是服务端的实现

#include <iostream>
#include <map>
#include <functional>
#include <memory>
#include <thread>
#include <mutex>

// 使用第三方库实现序列化和反序列化
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/map.hpp>

using namespace std;

// 定义RPC函数类型
using RPCCallback = std::function<std::string(const std::string&)>;

class RPCHandler {
public:
    void registerCallback(const std::string& name, RPCCallback callback) {
        std::unique_lock<std::mutex> lock(mtx_);
        callbacks_[name] = callback;
    }

    std::string handleRequest(const std::string& request) {
        // 反序列化请求
        std::map<std::string, std::string> requestMap;
        std::istringstream is(request);
        boost::archive::text_iarchive ia(is);
        ia >> requestMap;

        // 查找并调用对应的回调函数
        std::string name = requestMap["name"];
        std::string args = requestMap["args"];
        std::unique_lock<std::mutex> lock(mtx_);
        auto it = callbacks_.find(name);
        if (it == callbacks_.end()) {
            return "Error: Unknown function";
        }
        RPCCallback callback = it->second;
        return callback(args);
    }

private:
    std::map<std::string, RPCCallback> callbacks_;
    std::mutex mtx_;
};

int main() {
    RPCHandler rpcHandler;

    // 注册回调函数
    rpcHandler.registerCallback("add", [](const std::string& args) {
        std::istringstream is(args);
        int a, b;
        is >> a >> b;
        int result = a + b;
        std::ostringstream os;
        os << result;
        return os.str();
    });

    rpcHandler.registerCallback("sub", [](const std::string& args) {
        std::istringstream is(args);
        int a, b;
        is >> a >> b;
        int result = a - b;
        std::ostringstream os;
        os << result;
        return os.str
    });

    // 创建处理请求的线程
    std::thread requestThread([&]() {
        while (true) {
            std::string request;
            std::cin >> request;
            std::string response = rpcHandler.handleRequest(request);
            std::cout << response << std::endl;
        }
    });

    requestThread.join();
    return 0;
}

上面的代码实现了一个简单的C++ RPC服务端。主要实现了以下功能：

  1. 定义了RPC函数类型 RPCCallback，使用std::function<std::string(const std::string&)>表示。
  2. RPCHandler类实现了注册函数和处理请求的功能。
  3. 在main函数中创建了一个RPCHandler对象，并注册了两个函数"add" 和 "sub"。这些函数通过lambda表达式实现，并在被调用时通过std::istringstream读取参数并返回结果。
  4. 创建了一个新线程requestThread来处理请求。在这个线程中，通过std::cin读取请求，然后调用RPCHandler的handleRequest函数并使用std::cout输出响应。

注意，这套代码是最简单的RPC机制，只能调用本地的资源，他还存在以下缺点：

  1. 代码并没有处理错误处理，如果请求格式不正确或函数不存在，服务端将会返回“Error: Unknown function”。
  2. 没有使用网络库进行通信，所以只能在本机上使用。
  3. 没有提供高效的并发性能，所有请求都在单独的线程中处理。
  4. 没有考虑RPC服务的可用性和高可用性，如果服务端崩溃或不可用，客户端将无法继续使用服务。
  5. 没有考虑RPC服务的可扩展性，如果有大量请求需要处理，可能会导致性能问题。
  6. 使用了第三方库Boost.Serialization来实现序列化和反序列化，如果不想使用第三方库，可能需要自己实现序列化的功能。

下面我们一步一步完善它。

三、加强版RPC（以“RPC简单实现”为基础）

3.1 加入错误处理

        下面是 RPCHandler 类中加入错误处理的代码示例:

class RPCHandler {
public:
    // 其他代码...

    std::string handleRequest(const std::string& request) {
        // 反序列化请求
        std::map<std::string, std::string> requestMap;
        std::istringstream is(request);
        boost::archive::text_iarchive ia(is);
        ia >> requestMap;

        // 查找并调用对应的回调函数
        std::string name = requestMap["name"];
        std::string args = requestMap["args"];
        std::unique_lock<std::mutex> lock(mtx_);
        auto it = callbacks_.find(name);
        if (it == callbacks_.end()) {
            return "Error: Unknown function";
        }
        RPCCallback callback = it->second;
        try {
            return callback(args);
        } catch (const std::exception& e) {
            return "Error: Exception occurred: " + std::string(e.what());
        } catch (...) {
            return "Error: Unknown exception occurred";
        }
    }
};

        上面的代码在 RPCHandler 类的 handleRequest 函数中加入了错误处理的代码，它使用了 try-catch 语句来捕获可能发生的异常。如果找不到对应的函数或发生了异常，会返回错误信息。这样，如果请求格式不正确或函数不存在，服务端将会返回相应的错误信息。

3.2 加入网络连接（socket）

        加入网络连接不需要动服务端的实现，只需要在main里创造套接字去链接就好：

int main() 
{
    io_context ioc;
    ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 8080));
    RPCHandler rpcHandler;
    // 注册函数
    rpcHandler.registerCallback("add", [](const std::string& args) {
        std::istringstream is(args);
        int a, b;
        is >> a >> b;
        int result = a + b;
        std::ostringstream os;
        os << result;
        return os.str();
    });

    rpcHandler.registerCallback("sub", [](const std::string& args) {
        std::istringstream is(args);
        int a, b;
        is >> a >> b;
        int result = a - b;
        std::ostringstream os;
        os << result;
        return os.str();
    });

    // 等待连接
    while (true) {
        ip::tcp::socket socket(ioc);
        acceptor.accept(socket);

        // 创建线程处理请求
        std::thread requestThread([&](ip::tcp::socket socket) {
            while (true) {
                // 读取请求
                boost::asio::streambuf buf;
                read_until(socket, buf, '\n');
                std::string request = boost::asio::buffer_cast<const char*>(buf.data());
                request.pop_back();

                // 处理请求
                std::string response = rpcHandler.handleRequest(request);

                // 发送响应
                write(socket, buffer(response + '\n'));
            }
        }, std::move(socket));

        requestThread.detach();
    }

    return 0;
}

        这是一个使用Boost.Asio库实现的RPC服务端代码示例。它使用了TCP协议监听8080端口，等待客户端的连接。当有客户端连接时，创建一个新线程来处理请求。请求和响应通过网络传输。

3.3 加强并发性

       使用并发和异步机制，忽略重复代码，实现如下：

class RPCHandler {
public:
    // ...
    void handleConnection(ip::tcp::socket socket) {
        while (true) {
            // 读取请求
            boost::asio::streambuf buf;
            read_until(socket, buf, '\n');
            std::string request = boost::asio::buffer_cast<const char*>(buf.data());
            request.pop_back();

            // 使用并行执行处理请求
            std::vector<std::future<std::string>> futures;
            for (int i = 0; i < request.size(); i++) {
                futures.emplace_back(std::async(std::launch::async, &RPCHandler::handleRequest, this, request[i]));
            }

            // 等待所有请求处理完成并发送响应
            for (auto& f : futures) {
                std::string response = f.get();
                write(socket, buffer(response + '\n'));
            }
        }
    }
};

        这样，请求会被分成多个部分并行处理，可以利用多核 CPU 的优势提高服务端的并发性能。

        main（）：

int main() {
    io_context ioc;
    ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 8080));
    RPCHandler rpcHandler;

    // 注册函数
    rpcHandler.registerCallback("add", [](const std::string& args) {
        std::istringstream is(args);
        int a, b;
        is >> a >> b;
        int result = a + b;
        std::ostringstream os;
        os << result;
        return os.str();
    });

    rpcHandler.registerCallback("sub", [](const std::string& args) {
        std::istringstream is(args);
        int a, b;
        is >> a >> b;
        int result = a - b;
        std::ostringstream os;
        os << result;
        return os.str();
    });

    // 创建线程池
    boost::thread_pool::executor pool(10);

    // 等待连接
    while (true) {
        ip::tcp::socket socket(ioc);
        acceptor.accept(socket);

        // 将请求添加到线程池中处理
        pool.submit(boost::bind(&RPCHandler::handleConnection, &rpcHandler, std::move(socket)));
    }

    return 0;
}

        在 main 函数中可以使用 boost::thread_pool::executor 来管理线程池，在线程池中提交任务来处理请求。这里的线程池大小设置为10，可以根据实际情况调整。

3.4 加入容错机制（修改客户端部分）

        在其中使用了重试机制来保证客户端能够重新连接服务端：

class RPCClient {
public:
    RPCClient(const std::string& address, int port) : address_(address), port_(port), socket_(io_context_) {
        connect();
    }

    std::string call(const std::string& name, const std::string& args) {
        // 序列化请求
        std::ostringstream os;
        boost::archive::text_oarchive oa(os);
        std::map<std::string, std::string> request;
        request["name"] = name;
        request["args"] = args;
        oa << request;
        std::string requestStr = os.str();

        // 发送请求
        write(socket_, buffer(requestStr + '\n'));

        // 读取响应
        boost::asio::streambuf buf;
        read_until(socket_, buf, '\n');
        std::string response = boost::asio::buffer_cast<const char*>(buf.data());
        response.pop_back();

        return response;
    }

private:
    void connect() {
        bool connected = false;
        while (!connected) {
            try {
                socket_.connect(ip::tcp::endpoint(ip::address::from_string(address_), port_));
                connected = true;
            } catch (const std::exception& e) {
                std::cerr << "Error connecting to server: " << e.what() << std::endl;
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
        }
    }

    std::string address_;
    int port_;
    io_context io_context_;
    ip::tcp::socket socket_;
};

        在这个示例中，当连接服务端失败时，客户端会在一定的时间间隔后重试连接，直到成功连接上服务端为止。

3.5 负载均衡

        服务端需要处理大量的请求，这部分的实现是可以独立拎出来长篇大论的，在此贴出其他大神的帖子吧。

服务器负载均衡_负载均衡服务器_我是一条胖咸鱼的博客-CSDN博客

什么是负载均衡，看完文章秒懂_爱铭网络的博客-CSDN博客_负载均衡 

 

四、总结

        至此，我们逐步完善了RPC，在最简单的RPC基础上加入了网络连接、加入错误处理、增强了并发访问的功能、并加入了容错机制，但是对于一个可以让客户正常使用的RPC来说，这还远远不够，我本人也是实力有限，仅仅能读懂或者解析部分RPC的设计动机及原理，要详细介绍RPC光写这些是远远不够的。工作中一套RPC附加其他功能需要一个团队忙活差不多两个月，我仅仅在其中负责测试工具开发和代码生成，所以有不妥的地方请读者谅解，有错的地方请指出必将改正。好梦！！！

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

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

相关文章

项目管理平台，如何助力CMMI3-5级高效落地？

项目管理平台，如何助力CMMI3-5级高效落地？

近日CoCode旗下Co-ProjectV3.0智能项目管理平台全面升级&#xff0c;CoCode产品4大版本全新发布&#xff0c;用户不限版本30天免费试用&#xff1b;平台全面支持CMMI3-5级&#xff0c;助力CMMI高效落地。 一、4大版本全新发布 不限版本30天免费试用 Co-Project V3.0智能项目管理…
阅读更多...
FPGA：组合逻辑电路的设计

FPGA：组合逻辑电路的设计

文章目录组合逻辑电路的设计组合逻辑电路的设计步骤组合逻辑电路的设计举例例1例2组合逻辑电路的设计 根据实际逻辑问题&#xff0c;求出所要求逻辑功能的最简单逻辑电路。 组合逻辑电路的设计步骤 1.逻辑抽象&#xff1a;根据实际逻辑问题的因果关系确定输入、输出变量&…
阅读更多...
【寒假每日一题】DAY8 倒置字符串

【寒假每日一题】DAY8 倒置字符串

牛客网链接&#xff1a;传送门 【❤️温馨提示】自己做一遍&#xff0c;再看解析效果更佳哟 描述 将一句话的单词进行倒置&#xff0c;标点不倒置。输入描述&#xff1a; 每个测试输入包含1个测试用例&#xff1a; I like beijing. 输入用例长度不超过100输出描述&#xff1a…
阅读更多...
Open3D 点云投影至指定平面（Python版本）

Open3D 点云投影至指定平面（Python版本）

文章目录 一、简介二、实现代码三、实现效果参考资料一、简介 假设给定的平面为 a x + b y + c z + 1 = 0 ax+by+cz+1=0
阅读更多...
Python基础（二十四）：面向对象核心知识

Python基础（二十四）：面向对象核心知识

文章目录 面向对象核心知识 一、面向对象三大特性 1、封装 2、继承 3、多态
阅读更多...
音频音量调整中的ramp up down

音频音量调整中的ramp up down

在日常生活中不管是打电话还是听音乐&#xff0c;都会遇到音量不合适而去调整音量的情况。如果音量调整软件处理不好&#xff0c;就会听到pop noise。产生pop noise的原因是音量直接从当前值骤变到目标值&#xff0c;而不是缓慢的变。如果缓慢的变就不会有pop noise了。图1显示…
阅读更多...
select for update是行锁还是表锁，还真得看情况

select for update是行锁还是表锁，还真得看情况

背景 看到许多写select for update是行锁还是表锁的文章&#xff0c;但每篇文章的结论好像都不太一样。同时&#xff0c;是行锁还是表锁的问题直接影响着系统的性能&#xff0c;所以特意为大家调研一番&#xff0c;也就有了本篇文章&#xff0c;一共为大家汇总验证了20个场景下…
阅读更多...
MES系统选型攻略,优秀MES系统应具备哪些性质

MES系统选型攻略,优秀MES系统应具备哪些性质

在众多MES系统中&#xff0c;企业怎样才能找到最适合自己的产品&#xff1f;那么&#xff0c;一套高质量的MES系统&#xff0c;究竟有什么特点&#xff1f;随着全球经济一体化的发展&#xff0c;中美两国之间的贸易战争日趋白热化&#xff0c;中国作为一个生产大国&#xff0c;…
阅读更多...
行为型模式 - 迭代器模式iterator

行为型模式 - 迭代器模式iterator

模式的定义与特点 迭代器模式&#xff08;iterator Pattern&#xff09;&#xff0c;为的提是可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集&#xff0c;聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个…
阅读更多...
ffmpeg源码编译vs2013版本

ffmpeg源码编译vs2013版本

完整版安装ffmpeg 一、安装choco 1.Set-ExecutionPolicy AllSigned 2.Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.N…
阅读更多...
链队基本操作（笔记版）

链队基本操作（笔记版）

本节主要针对链栈的基本操作进行解析。 # coding:___utf-8___ # author:Guoxuan Sun time:2023/1/12 #链栈的基本操作 #链栈的创建与顺序栈的区别就是每个结点都有一个指针域 #同时链栈也是有两个指针front和rear #链栈中的front指针指向的结点是第一个结点&#xff0c;不是空…
阅读更多...
关于MySQL中的存储引擎

关于MySQL中的存储引擎

存储引擎&#xff1a;&#xff08;了解内容&#xff09; 1、什么是存储引擎&#xff0c;有什么用&#xff1f; 存储引擎是mysql中特有的一个术语&#xff0c;其他数据库中没有。 存储引擎就是一个表存储/组织数据的方式。不同的存储引擎&#xff0c;表存储数据的方式不同。 目前…
阅读更多...
基于Androidstudio的宠物交友app

基于Androidstudio的宠物交友app

需求信息&#xff1a; 客户端&#xff1a; 1&#xff1a;登录注册&#xff1a;用户可以通过自己的信息进行账号的注册 2&#xff1a;宠物信息&#xff1a;列表显示发布的宠物想&#xff0c;可以通过条件对宠物信息进行筛选&#xff0c;以及沟通意向点亮 3&#xff1a;宠物圈&am…
阅读更多...
java调用python文件的几种方式

java调用python文件的几种方式

java调用python的契机来自于一个项目需要用到算法&#xff0c;但是算法工程师们写的python&#xff0c;于是就有了java后端调用python脚本的需求&#xff0c;中间遇到了许多问题&#xff0c;特此记录整理了一次。1、java调用python的方式有哪几种1.1 方法一&#xff1a;jpython…
阅读更多...
选择排序.

选择排序.

一、简单选择排序 void select_sort(int a[], int len){ //len为数组长度for (int i 0; i < len-1; i){//n个数需要比较n-1趟int min i;//记录最小值的位置for (int j i1; j < len-1; j){if (a[j] < a[min]) min j;//更新最小值的位置} if (min ! i) swap(a[i], …
阅读更多...
vue3 项目篇商场 之 初始化项目

vue3 项目篇商场 之 初始化项目

目录vue3 项目篇商场 之 初始化项目1&#xff1a;安装 rem 适配src 同级目录下创建 postcss.config.jsmain.ts2 :使用字体图标加字体图标 &#xff08; Symbol 这个选项&#xff09;public / index.html使用效果3 sass4&#xff1a;vant3引入 按需引入 ( 非 vite )4-1 babel.co…
阅读更多...
2022年，开源社最亮的星

2022年，开源社最亮的星

开源社成立于 2014 年&#xff0c;是由志愿贡献于开源事业的个人成员&#xff0c;依 “贡献、共识、共治” 原则所组成&#xff0c;始终维持厂商中立、公益、非营利的特点&#xff0c;是最早以 “开源治理、国际接轨、社区发展、开源项目” 为使命的开源社区联合体。本次年度评…
阅读更多...
常用的专业数据恢复软件有哪些？恢复数据就看这10个！

常用的专业数据恢复软件有哪些？恢复数据就看这10个！

互联网时代&#xff0c;我们都习惯使用电脑来进行办公&#xff0c;电脑里面都保存着我们很多数据。数据的日积月累&#xff0c;会导致电脑的运行速度减缓&#xff0c;为此我们都会定期对电脑进行清理。 如果在清理过程中&#xff0c;不小心误删或者格式化了数据&#xff0c;有…
阅读更多...
漏洞挖掘之信息收集

漏洞挖掘之信息收集

简介 对单一指定目标网站进行黑盒测试&#xff0c;最重要的就是信息收集&#xff0c;因为网站管理员肯定会在用户经常访问的主网站进行经常维护&#xff0c;而那些子域名&#xff0c;没有什么人访问的&#xff0c;可能就会忘记维护&#xff0c;挖洞的突破点大都在于子域名上&am…
阅读更多...
Android/Linux 子系统Graphics图形栈入门普法介绍

Android/Linux 子系统Graphics图形栈入门普法介绍

Android/Linux 子系统Graphics图形栈入门普法介绍 写在最前面 由于工作原因&#xff0c;最近在公司做了一个关于Android/Linux 子系统Graphics图形栈入门相关知识的培训介绍&#xff0c;个人感觉对于想要了解入门这块的朋友还是有一定帮助的。由于博客不能直接放入ppt&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023