Qt网络通信

Qt提供了一套强大的网络通信功能，可以用于在应用程序中进行网络通信。以下是Qt网络通信的主要组件和功能：

1. QNetworkAccessManager：

2. 是Qt中的网络访问管理器，用于发送HTTP请求并接收响应。它支持GET、POST、PUT、DELETE等HTTP请求方法，并提供了丰富的功能，如设置请求头、处理重定向、处理身份验证等。

3. 接口说明：

4. 构造函数：
   QNetworkAccessManager(parent: QObject = None)：构造一个 QNetworkAccessManager 实例。
   parent：可选参数，指定父对象，用于内存管理。
   方法：
   get(request: QNetworkRequest) -> QNetworkReply：发送一个 GET 请求并返回响应的 QNetworkReply 对象。
   
   request：QNetworkRequest 对象，包含请求的 URL、请求头等信息。
   post(request: QNetworkRequest, data: QByteArray) -> QNetworkReply：发送一个 POST 请求并返回响应的 QNetworkReply 对象。
   
   request：QNetworkRequest 对象，包含请求的 URL、请求头等信息。
   data：包含要发送的数据的 QByteArray 对象。
   put(request: QNetworkRequest, data: QByteArray) -> QNetworkReply：发送一个 PUT 请求并返回响应的 QNetworkReply 对象。
   
   request：QNetworkRequest 对象，包含请求的 URL、请求头等信息。
   data：包含要发送的数据的 QByteArray 对象。
   deleteResource(request: QNetworkRequest) -> QNetworkReply：发送一个 DELETE 请求并返回响应的 QNetworkReply 对象。
   
   request：QNetworkRequest 对象，包含请求的 URL、请求头等信息。
   head(request: QNetworkRequest) -> QNetworkReply：发送一个 HEAD 请求并返回响应的 QNetworkReply 对象。
   
   request：QNetworkRequest 对象，包含请求的 URL、请求头等信息。
   createRequest(op: QNetworkAccessManager.Operation, request: QNetworkRequest, outgoingData: QIODevice = None) -> QNetworkReply：创建一个自定义的网络请求，并返回对应的 QNetworkReply 对象。
   
   op：QNetworkAccessManager.Operation 枚举，表示请求的操作类型，如 GET、POST、PUT、DELETE 等。
   request：QNetworkRequest 对象，包含请求的 URL、请求头等信息。
   outgoingData：可选参数，用于发送数据的 QIODevice 对象。
   setConfiguration(config: QNetworkConfiguration)：设置网络配置，用于特定网络访问的设置。
   
   config：QNetworkConfiguration 对象，包含特定的网络配置。
   configuration() -> QNetworkConfiguration：获取当前网络配置。
   
   返回：QNetworkConfiguration 对象，表示当前网络配置。
   cookieJar() -> QNetworkCookieJar：获取当前的 Cookie 管理器。
   
   返回：QNetworkCookieJar 对象，表示当前的 Cookie 管理器。
   setCookieJar(cookieJar: QNetworkCookieJar)：设置 Cookie 管理器。
   
   cookieJar：QNetworkCookieJar 对象，用于管理 Cookie。
   setProxyFactory(factory: QNetworkProxyFactory)：设置代理工厂，用于处理网络请求的代理设置。
   
   factory：QNetworkProxyFactory 对象，用于处理代理设置。
   信号：
   QNetworkAccessManager 也提供了一些信号，用于通知网络请求的状态和进度。
   
   authenticationRequired(QNetworkReply *reply, QAuthenticator *authenticator)：当服务器要求身份验证时触发的信号。
   encrypted(QNetworkReply *reply)：在通过 SSL 加密连接时触发的信号。
   finished(QNetworkReply *reply)：当一个网络请求完成时触发的信号。
   networkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility accessible)：当网络可用性状态发生变化时触发的信号。
   preSharedKeyAuthenticationRequired(QNetworkReply *reply, QSslPreSharedKeyAuthenticator *authenticator)：当服务器要求预共享密钥验证时触发的信号。
   proxyAuthenticationRequired(QNetworkProxy proxy, QAuthenticator *authenticator)：当使用代理服务器时，要求代理服务器身份验证时触发的信号。
   以上就是 QNetworkAccessManager 类的主要接口说明，它提供了便捷的方法来处理网络请求和响应，并且通过信号提供了网络状态和进度的反馈。注意在使用 QNetworkAccessManager 进行网络访问时，要确保适当地处理身份验证、代理设置和错误处理等方面的逻辑。

   使用代码：

5. #include <QCoreApplication>
   #include <QtNetwork/QNetworkAccessManager>
   #include <QtNetwork/QNetworkRequest>
   #include <QtNetwork/QNetworkReply>
   #include <QDebug>
   
   int main(int argc, char *argv[])
   {
       QCoreApplication a(argc, argv);
   
       // 创建QNetworkAccessManager对象
       QNetworkAccessManager manager;
   
       // 创建QNetworkRequest对象，并设置请求的URL
       QNetworkRequest request;
       request.setUrl(QUrl("https://api.example.com/data"));
   
       // 发送GET请求
       QNetworkReply *reply = manager.get(request);
   
       // 连接请求完成的信号
       QObject::connect(reply, &QNetworkReply::finished, [&](){
           // 判断请求是否成功
           if(reply->error() == QNetworkReply::NoError)
           {
               // 读取响应的数据
               QByteArray data = reply->readAll();
               qDebug() << "Response: " << data;
           }
           else
           {
               qDebug() << "Error: " << reply->errorString();
           }
   
           // 请求完成后释放reply对象
           reply->deleteLater();
           // 退出应用程序
           a.quit();
       });
   
       return a.exec();
   }
   

   上述代码中，我们首先创建了一个QNetworkAccessManager对象，然后创建了一个QNetworkRequest对象，并设置了请求的URL。接着，我们使用QNetworkAccessManager的get()方法发送GET请求，并获取到一个QNetworkReply对象。然后，我们连接了QNetworkReply的finished()信号，当请求完成时会触发该信号。在信号的槽函数中，我们判断请求是否成功，如果成功则读取响应的数据并输出，否则输出错误信息。最后，我们释放reply对象并退出应用程序。

6. QNetworkRequest：

7. 表示一个网络请求，可以设置请求URL、请求方法、请求头等信息。

8. 接口说明：

9. 构造函数：
   QNetworkRequest(url: QUrl = QUrl())：构造一个 QNetworkRequest 实例。
   url：可选参数，指定请求的 URL。
   方法：
   setUrl(url: QUrl)：设置请求的 URL。
   
   url：QUrl 对象，表示请求的 URL。
   url() -> QUrl：获取请求的 URL。
   
   返回：QUrl 对象，表示请求的 URL。
   setAttribute(attribute: QNetworkRequest.Attribute, value: Any)：设置请求的属性。
   
   attribute：QNetworkRequest.Attribute 枚举，表示要设置的属性类型。
   value：任意类型的值，表示要设置的属性值。
   attribute(attribute: QNetworkRequest.Attribute, defaultValue: Any = None) -> Any：获取请求的属性值。
   
   attribute：QNetworkRequest.Attribute 枚举，表示要获取的属性类型。
   defaultValue：可选参数，当属性不存在时返回的默认值。
   返回：任意类型的值，表示请求的属性值。
   hasAttribute(attribute: QNetworkRequest.Attribute) -> bool：检查请求是否具有特定的属性。
   
   attribute：QNetworkRequest.Attribute 枚举，表示要检查的属性类型。
   返回：True 表示请求具有该属性，False 表示请求不具有该属性。
   setRawHeader(headerName: QByteArray, value: QByteArray)：设置原始请求头。
   
   headerName：QByteArray 对象，表示请求头的名称。
   value：QByteArray 对象，表示请求头的值。
   rawHeader(headerName: QByteArray) -> QByteArray：获取原始请求头的值。
   
   headerName：QByteArray 对象，表示请求头的名称。
   返回：QByteArray 对象，表示请求头的值。
   hasRawHeader(headerName: QByteArray) -> bool：检查请求是否具有特定的原始请求头。
   
   headerName：QByteArray 对象，表示请求头的名称。
   返回：True 表示请求具有该请求头，False 表示请求不具有该请求头。
   setHeader(header: QNetworkRequest.KnownHeaders, value: Any)：设置请求的已知头。
   
   header：QNetworkRequest.KnownHeaders 枚举，表示已知请求头类型。
   value：任意类型的值，表示请求头的值。
   header(header: QNetworkRequest.KnownHeaders) -> Any：获取请求的已知头的值。
   
   header：QNetworkRequest.KnownHeaders 枚举，表示已知请求头类型。
   返回：任意类型的值，表示请求头的值。
   hasRawHeader(headerName: QByteArray) -> bool：检查请求是否具有特定的已知头。
   
   header：QNetworkRequest.KnownHeaders 枚举，表示已知请求头类型。
   返回：True 表示请求具有该已知头，False 表示请求不具有该已知头。
   setSslConfiguration(config: QSslConfiguration)：设置 SSL 配置，用于加密连接。
   
   config：QSslConfiguration 对象，表示 SSL 配置。
   sslConfiguration() -> QSslConfiguration：获取当前的 SSL 配置。
   
   返回：QSslConfiguration 对象，表示当前的 SSL 配置。
   枚举类型 QNetworkRequest.Attribute：
   HttpStatusCodeAttribute：HTTP 状态码的属性，用于获取 HTTP 响应状态码。
   HttpReasonPhraseAttribute：HTTP 响应原因短语的属性，用于获取 HTTP 响应的原因短语。
   RedirectionTargetAttribute：重定向目标的属性，用于获取重定向的目标 URL。
   ConnectionEncryptedAttribute：连接是否通过 SSL 加密的属性。
   CacheLoadControlAttribute：缓存加载控制的属性。
   CacheSaveControlAttribute：缓存保存控制的属性。
   SourceIsFromCacheAttribute：源数据是否来自缓存的属性。
   DoNotBufferUploadDataAttribute：不要缓冲上传数据的属性。
   HttpPipeliningAllowedAttribute：是否允许 HTTP 管道传输的属性。
   枚举类型 QNetworkRequest.KnownHeaders：
   QNetworkRequest.KnownHeaders 是一组已知的 HTTP 请求头类型，包括但不限于以下几种：
   
   ContentTypeHeader：表示请求的内容类型。
   ContentLengthHeader：表示请求的内容长度。
   LocationHeader：表示请求的重定向位置。
   LastModifiedHeader：表示请求的最后修改时间。
   CookieHeader：表示请求的 Cookie。
   UserAgentHeader：表示请求的用户代理信息。
   ServerHeader：表示服务器的响应头。
   ContentDispositionHeader：表示请求的内容描述。
   AcceptHeader：表示请求可接受的内容类型。
   

   使用代码：

10. from PyQt5.QtCore import QUrl
    from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
    from PyQt5.QtWidgets import QApplication
    import sys
    
    def handle_response(reply: QNetworkReply):
        if reply.error() == QNetworkReply.NoError:
            data = reply.readAll()
            print("Response data:", data.data().decode('utf-8'))
        else:
            print("Error occurred:", reply.errorString())
    
        reply.deleteLater()
        QApplication.quit()
    
    def make_request():
        url = QUrl("https://jsonplaceholder.typicode.com/posts/1")
        request = QNetworkRequest(url)
    
        manager = QNetworkAccessManager()
        reply = manager.get(request)
        reply.finished.connect(lambda: handle_response(reply))
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        make_request()
        sys.exit(app.exec_())
    

    在这个案例中，我们创建了一个简单的应用程序，使用 QNetworkAccessManager 发送了一个 GET 请求到 https://jsonplaceholder.typicode.com/posts/1，这个 URL 是一个测试 API，它会返回一个 JSON 格式的响应。

    首先，我们导入所需的模块，并定义了一个 handle_response 函数来处理响应。在这个函数中，我们检查网络回复是否没有错误，如果没有错误，则读取响应数据并打印到控制台。如果有错误，我们也打印出错误信息。最后，我们使用 deleteLater() 方法来删除网络回复对象，并通过 QApplication.quit() 来退出应用程序。

    接着，我们定义了一个 make_request 函数来发送请求。我们使用 QUrl 创建了请求的 URL，然后使用 QNetworkRequest 创建了请求对象，将 URL 设置为请求的 URL。

    然后，我们创建了一个 QNetworkAccessManager 对象，用于处理网络请求。通过 get 方法发送了一个 GET 请求，并将响应与 handle_response 函数连接起来，以便在请求完成时进行处理。

    最后，在 main 函数中，我们初始化了应用程序并调用 make_request 函数来发送请求。最后，使用 sys.exit(app.exec_()) 来启动 Qt 事件循环。

11. QNetworkReply：

    表示一个网络响应，包含了响应的数据、状态码、响应头等信息。可以通过它获取和处理服务器返回的数据。

12. 接口说明：

13. 方法：
    isFinished() -> bool：检查网络回复是否已完成。
    
    返回：True 表示网络回复已完成，False 表示网络回复未完成。
    isRunning() -> bool：检查网络回复是否正在运行中。
    
    返回：True 表示网络回复正在运行，False 表示网络回复未运行。
    isReadable() -> bool：检查网络回复是否可读。
    
    返回：True 表示网络回复可读，False 表示网络回复不可读。
    error() -> QNetworkReply.NetworkError：获取网络回复的错误代码。
    
    返回：QNetworkReply.NetworkError 枚举，表示网络回复的错误代码。
    errorString() -> str：获取网络回复的错误信息字符串。
    
    返回：字符串，表示网络回复的错误信息。
    readAll() -> QByteArray：读取网络回复的所有数据。
    
    返回：QByteArray 对象，表示网络回复的所有数据。
    read(size: int) -> QByteArray：读取指定大小的数据。
    
    size：要读取的数据大小。
    返回：QByteArray 对象，表示读取的数据。
    attribute(attribute: QNetworkRequest.Attribute, defaultValue: Any = None) -> Any：获取网络回复的属性值。
    
    attribute：QNetworkRequest.Attribute 枚举，表示要获取的属性类型。
    defaultValue：可选参数，当属性不存在时返回的默认值。
    返回：任意类型的值，表示网络回复的属性值。
    header(header: QNetworkRequest.KnownHeaders) -> Any：获取网络回复的已知头的值。
    
    header：QNetworkRequest.KnownHeaders 枚举，表示已知响应头类型。
    返回：任意类型的值，表示网络回复的已知头的值。
    rawHeader(headerName: QByteArray) -> QByteArray：获取网络回复的原始响应头的值。
    
    headerName：QByteArray 对象，表示响应头的名称。
    返回：QByteArray 对象，表示网络回复的原始响应头的值。
    attribute(attribute: QNetworkRequest.Attribute, defaultValue: Any = None) -> Any：获取网络回复的属性值。
    
    attribute：QNetworkRequest.Attribute 枚举，表示要获取的属性类型。
    defaultValue：可选参数，当属性不存在时返回的默认值。
    返回：任意类型的值，表示网络回复的属性值。
    rawHeaderList() -> List[QByteArray]：获取网络回复的原始响应头列表。
    
    返回：QList[QByteArray] 对象，表示网络回复的原始响应头列表。
    枚举类型 QNetworkReply.NetworkError：
    QNetworkReply.NetworkError 枚举表示网络回复的错误代码，包括但不限于以下几种：
    
    NoError：没有错误。
    ConnectionRefusedError：连接被拒绝。
    RemoteHostClosedError：远程主机关闭了连接。
    HostNotFoundError：未找到主机。
    TimeoutError：连接超时。
    OperationCanceledError：操作被取消。
    SslHandshakeFailedError：SSL 握手失败。
    

14. 使用代码

15. from PyQt5.QtCore import QUrl
    from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
    from PyQt5.QtWidgets import QApplication
    import sys
    
    def handle_response(reply: QNetworkReply):
        if reply.error() == QNetworkReply.NoError:
            data = reply.readAll()
            print("Response data:", data.data().decode('utf-8'))
        else:
            print("Error occurred:", reply.errorString())
    
        reply.deleteLater()
        QApplication.quit()
    
    def make_request():
        url = QUrl("https://jsonplaceholder.typicode.com/posts/1")
        request = QNetworkRequest(url)
    
        manager = QNetworkAccessManager()
        reply = manager.get(request)
        reply.finished.connect(lambda: handle_response(reply))
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        make_request()
        sys.exit(app.exec_())
    

    在这个代码示例中，我们创建了一个简单的应用程序，使用 QNetworkAccessManager 发送了一个 GET 请求到 https://jsonplaceholder.typicode.com/posts/1，这个 URL 是一个测试 API，它会返回一个 JSON 格式的响应。

    首先，我们导入所需的模块，并定义了一个 handle_response 函数来处理响应。在这个函数中，我们检查网络回复是否没有错误，如果没有错误，则读取响应数据并打印到控制台。如果有错误，我们也打印出错误信息。最后，我们使用 deleteLater() 方法来删除网络回复对象，并通过 QApplication.quit() 来退出应用程序。

    接着，我们定义了一个 make_request 函数来发送请求。我们使用 QUrl 创建了请求的 URL，然后使用 QNetworkRequest 创建了请求对象，将 URL 设置为请求的 URL。

    然后，我们创建了一个 QNetworkAccessManager 对象，用于处理网络请求。通过 get 方法发送了一个 GET 请求，并将响应与 handle_response 函数连接起来，以便在请求完成时进行处理。

    最后，在 main 函数中，我们初始化了应用程序并调用 make_request 函数来发送请求。最后，使用 sys.exit(app.exec_()) 来启动 Qt 事件循环。

16. QNetworkCookieJar：

17. 用于管理和处理HTTP请求中的Cookie。

18. 接口说明：

19. 方法：
    allCookies() -> List[QNetworkCookie]：获取所有的 cookie。
    
    返回：QList[QNetworkCookie]，表示所有的 cookie 列表。
    setCookiesFromUrl(cookies: List[QNetworkCookie], url: QUrl)：从给定 URL 设置 cookie。
    
    cookies：QList[QNetworkCookie]，要设置的 cookie 列表。
    url：QUrl，cookie 所属的 URL。
    deleteCookie(cookie: QNetworkCookie)：删除指定的 cookie。
    
    cookie：QNetworkCookie，要删除的 cookie。
    insertCookie(cookie: QNetworkCookie)：插入一个新的 cookie。
    
    cookie：QNetworkCookie，要插入的 cookie。
    updateCookie(cookie: QNetworkCookie)：更新一个已存在的 cookie。
    
    cookie：QNetworkCookie，要更新的 cookie。
    clear()：清空所有的 cookie。
    
    信号：
    cookieAdded(cookie: QNetworkCookie)：当一个新的 cookie 被插入时发出的信号。
    
    cookie：QNetworkCookie，新添加的 cookie。
    cookieChanged(cookie: QNetworkCookie)：当一个 cookie 被修改时发出的信号。
    
    cookie：QNetworkCookie，被修改的 cookie。
    cookieRemoved(cookie: QNetworkCookie)：当一个 cookie 被删除时发出的信号。
    
    cookie：QNetworkCookie，被删除的 cookie。

20. 使用代码：

21. from PyQt5.QtCore import QUrl
    from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkCookieJar, QNetworkRequest, QNetworkReply
    from PyQt5.QtWidgets import QApplication
    import sys
    
    class MyCookieJar(QNetworkCookieJar):
        def __init__(self):
            super().__init__()
    
        def cookiesForUrl(self, url):
            # 在这里可以自定义返回指定 URL 的 cookie 列表
            return super().cookiesForUrl(url)
    
        def setCookiesFromUrl(self, cookies, url):
            # 在这里可以自定义设置指定 URL 的 cookie
            super().setCookiesFromUrl(cookies, url)
    
    def handle_response(reply: QNetworkReply):
        if reply.error() == QNetworkReply.NoError:
            data = reply.readAll()
            print("Response data:", data.data().decode('utf-8'))
        else:
            print("Error occurred:", reply.errorString())
    
        reply.deleteLater()
        QApplication.quit()
    
    def make_request():
        url = QUrl("https://jsonplaceholder.typicode.com/posts/1")
        request = QNetworkRequest(url)
    
        cookie_jar = MyCookieJar()
        manager = QNetworkAccessManager()
        manager.setCookieJar(cookie_jar)
    
        reply = manager.get(request)
        reply.finished.connect(lambda: handle_response(reply))
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        make_request()
        sys.exit(app.exec_())
    

    在这个代码示例中，我们首先定义了一个继承自 QNetworkCookieJar 的子类 MyCookieJar。在这个子类中，我们可以重写 cookiesForUrl 方法和 setCookiesFromUrl 方法来自定义 cookie 的管理逻辑。在示例中，我们使用了父类的默认实现，但你可以根据自己的需求来实现自定义逻辑。

    然后，在 make_request 函数中，我们创建了一个 MyCookieJar 的实例，用于管理 cookie。然后，我们创建了一个 QNetworkAccessManager 对象，并将自定义的 cookie 管理器设置给它，从而在网络请求中使用自定义的 cookie 管理逻辑。

    接着，我们发送一个 GET 请求到 https://jsonplaceholder.typicode.com/posts/1，这个 URL 是一个测试 API，它会返回一个 JSON 格式的响应。在请求完成后，通过 handle_response 函数来处理响应数据。

    最后，在 main 函数中，我们初始化了应用程序并调用 make_request 函数来发送请求。最后，使用 sys.exit(app.exec_()) 来启动 Qt 事件循环。

22. QNetworkConfigurationManager：

23. 用于管理网络配置，例如网络连接状态、可用网络接口等。

24. 接口说明：

25. 方法：
    defaultConfiguration() -> QNetworkConfiguration：获取默认的网络配置。
    
    返回：QNetworkConfiguration 对象，表示默认的网络配置。
    allConfigurations(flags: QNetworkConfiguration.StateFlags = QNetworkConfiguration.Active) -> List[QNetworkConfiguration]：获取满足指定条件的所有网络配置列表。
    
    flags：QNetworkConfiguration.StateFlags 枚举，表示要获取的网络配置的状态标志，默认为 QNetworkConfiguration.Active，表示获取活动的网络配置。
    返回：QList[QNetworkConfiguration] 对象，表示满足条件的网络配置列表。
    isOnline() -> bool：检查设备是否在线（即是否连接到网络）。
    
    返回：True 表示设备在线，False 表示设备离线。
    updateConfigurations()：更新可用的网络配置列表。
    
    configurationAdded.connect(slot_function)：连接一个槽函数，当新的网络配置被添加时触发。
    
    configurationChanged.connect(slot_function)：连接一个槽函数，当网络配置发生更改时触发。
    
    configurationRemoved.connect(slot_function)：连接一个槽函数，当网络配置被移除时触发。
    
    onlineStateChanged.connect(slot_function)：连接一个槽函数，当设备的在线状态发生改变时触发。
    
    信号：
    configurationAdded(configuration: QNetworkConfiguration)：当新的网络配置被添加时发出的信号。
    
    configuration：QNetworkConfiguration 对象，新添加的网络配置。
    configurationChanged(configuration: QNetworkConfiguration)：当网络配置发生更改时发出的信号。
    
    configuration：QNetworkConfiguration 对象，发生更改的网络配置。
    configurationRemoved(configuration: QNetworkConfiguration)：当网络配置被移除时发出的信号。
    
    configuration：QNetworkConfiguration 对象，被移除的网络配置。
    onlineStateChanged(online: bool)：当设备的在线状态发生改变时发出的信号。
    
    online：布尔值，表示设备是否在线。

    代码使用：

    from PyQt5.QtCore import QCoreApplication, QUrl
    from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkConfigurationManager, QNetworkRequest, QNetworkReply
    
    def handle_response(reply: QNetworkReply):
        if reply.error() == QNetworkReply.NoError:
            data = reply.readAll()
            print("Response data:", data.data().decode('utf-8'))
        else:
            print("Error occurred:", reply.errorString())
    
        reply.deleteLater()
        QCoreApplication.quit()
    
    if __name__ == "__main__":
        app = QCoreApplication([])
    
        # Create QNetworkConfigurationManager instance
        config_manager = QNetworkConfigurationManager()
    
        # Check if the device is online
        online = config_manager.isOnline()
        print("Is online:", online)
    
        # Get all active configurations
        configurations = config_manager.allConfigurations()
        for config in configurations:
            print("Configuration Name:", config.name())
            print("Bearer Type:", config.bearerTypeName())
    
        # Create QNetworkAccessManager instance
        manager = QNetworkAccessManager()
    
        # Make a GET request
        url = QUrl("https://jsonplaceholder.typicode.com/posts/1")
        request = QNetworkRequest(url)
        reply = manager.get(request)
        reply.finished.connect(lambda: handle_response(reply))
    
        app.exec_()
    

    在这个代码示例中，我们首先导入所需的模块，并创建了一个 QCoreApplication 实例来运行 Qt 事件循环。

    然后，我们创建了一个 QNetworkConfigurationManager 实例 config_manager，并使用 isOnline() 方法来检查设备是否在线，并打印出在线状态。

    接着，我们使用 allConfigurations() 方法获取所有的网络配置列表，并遍历打印每个配置的名称和连接类型。

    然后，我们创建了一个 QNetworkAccessManager 实例 manager，用于发送网络请求。在这个例子中，我们发送了一个 GET 请求到 https://jsonplaceholder.typicode.com/posts/1，这个 URL 是一个测试 API，它会返回一个 JSON 格式的响应。

    最后，我们连接了 reply.finished 信号到 handle_response 函数，用于处理响应数据。

26. QTcpSocket和QUdpSocket：

27. 用于创建TCP和UDP套接字，实现基于TCP和UDP的网络通信。

28. 接口说明：

29. QTcpSocket：

30. 方法：

31. connectToHost(host: str, port: int)：连接到指定的主机和端口。
    disconnectFromHost()：断开与主机的连接。
    write(data: bytes)：将数据写入连接。
    readAll() -> bytes：读取所有可用数据。
    waitForReadyRead(msecs: int)：等待数据准备就绪，最多等待指定毫秒数。
    state() -> QAbstractSocket.SocketState：获取当前 socket 状态。
    

32. 信号：

33. connected：当连接成功建立时发出。
    disconnected：当连接关闭时发出。
    readyRead：当有数据可读取时发出。

    QUdpSocket

34. QUdpSocket 是用于进行基于 UDP 协议的网络通信的类。它适用于在不需要建立持久连接的情况下进行数据传输。以下是一些常用的方法和信号：

    方法：

    bind(port: int, mode: QAbstractSocket.BindFlag = QAbstractSocket.DefaultForPlatform)：绑定到指定的端口和模式。
    writeDatagram(data: bytes, host: str, port: int)：将数据报文发送到指定的主机和端口。
    readDatagram(maxSize: int) -> Tuple[bytes, str, int]：读取一个数据报文和发送者的信息。

    
    信号：

35. readyRead：当有数据可读取时发出。
    这些类都提供了一系列用于管理网络通信的方法和信号。你可以根据自己的需求，选择适当的类和方法来实现 TCP 或 UDP 的数据传输。在实际使用时，你需要创建这些类的对象，并根据需要连接信号和调用方法来进行网络通信操作。

36. 使用代码：

37. 使用 QTcpSocket 进行 TCP 通信的客户端代码：

38. from PyQt5.QtCore import QCoreApplication
    from PyQt5.QtNetwork import QTcpSocket
    
    def handle_connected():
        print("Connected to server.")
        tcp_socket.write(b"Hello, server!")
    
    def handle_ready_read():
        data = tcp_socket.readAll()
        print("Received data from server:", data.data().decode())
    
    def handle_disconnected():
        print("Disconnected from server.")
        QCoreApplication.quit()
    
    if __name__ == "__main__":
        app = QCoreApplication([])
    
        tcp_socket = QTcpSocket()
        tcp_socket.connected.connect(handle_connected)
        tcp_socket.readyRead.connect(handle_ready_read)
        tcp_socket.disconnected.connect(handle_disconnected)
    
        tcp_socket.connectToHost("127.0.0.1", 12345)
    
        app.exec_()
    

    使用 QTcpSocket 进行 TCP 通信的服务器端代码：

39. from PyQt5.QtCore import QCoreApplication
    from PyQt5.QtNetwork import QTcpServer
    
    def handle_new_connection():
        client_socket = tcp_server.nextPendingConnection()
        client_socket.readyRead.connect(handle_ready_read)
        client_socket.disconnected.connect(client_socket.deleteLater)
    
    def handle_ready_read():
        client_socket = sender()
        data = client_socket.readAll()
        print("Received data from client:", data.data().decode())
        client_socket.write(b"Hello, client!")
        client_socket.disconnectFromHost()
    
    if __name__ == "__main__":
        app = QCoreApplication([])
    
        tcp_server = QTcpServer()
        tcp_server.newConnection.connect(handle_new_connection)
    
        tcp_server.listen(port=12345)
    
        app.exec_()
    

    使用 QUdpSocket 进行 UDP 通信的代码：

40. from PyQt5.QtCore import QCoreApplication
    from PyQt5.QtNetwork import QUdpSocket
    
    def handle_ready_read():
        while udp_socket.hasPendingDatagrams():
            data, host, port = udp_socket.readDatagram(1024)
            print(f"Received data from {host.toString()}:{port}: {data.data().decode()}")
    
    if __name__ == "__main__":
        app = QCoreApplication([])
    
        udp_socket = QUdpSocket()
        udp_socket.readyRead.connect(handle_ready_read)
    
        udp_socket.bind(12345)
    
        app.exec_()
    

41. QSslSocket和QSslConfiguration：

42. 用于支持加密的SSL/TLS通信，实现安全的网络通信。

43. 接口说明：

44. QSslSocket

45. 方法：

46. setSslConfiguration(config: QSslConfiguration)：设置用于 SSL 连接的配置。
    sslConfiguration() -> QSslConfiguration：获取当前 SSL 配置。
    connectToHostEncrypted(host: str, port: int, mode: QIODevice.OpenMode = QIODevice.ReadWrite)：使用 SSL 加密连接到指定主机和端口。
    

    信号：

47. encrypted：当 SSL 加密连接成功建立时发出。
    sslErrors：当 SSL 错误发生时发出。

    QSslConfiguration

48. QSslConfiguration 是用于配置 SSL 连接的类。它包含了 SSL 的各种设置，如加密算法、证书验证、协议版本等。以下是一些常用的方法：

    方法：

    setDefaultConfiguration(config: QSslConfiguration)：设置默认的 SSL 配置。
    defaultConfiguration() -> QSslConfiguration：获取默认的 SSL 配置。
    setPeerVerifyMode(verifyMode: QSslSocket.PeerVerifyMode)：设置对端证书验证模式。
    peerVerifyMode() -> QSslSocket.PeerVerifyMode：获取对端证书验证模式。
    setProtocol(sslProtocol: QSsl.SslProtocol)：设置 SSL 协议版本。
    protocol() -> QSsl.SslProtocol：获取 SSL 协议版本。

    QSslConfiguration 还有其他一些方法，用于设置和获取证书、私钥、CA（证书授权机构）和密码等相关的信息。

    请注意，使用 QSslSocket 和 QSslConfiguration 进行加密通信时，你需要安装支持 SSL 的库，如 OpenSSL 或 Secure Transport（在 macOS 上）。Qt 提供了 QSslSocket 的 supportsSsl() 静态方法，用于检查当前 Qt 库是否支持 SSL。

49. QHostInfo：

50. 用于获取主机的IP地址和主机名。

51. 接口说明：

52. 方法：

53. lookupHost(hostName: str, receiver: QObject, member: Callable)：异步查询主机名对应的 IP 地址信息，将结果通过指定的信号接收。receiver 是接收信号的对象，member 是信号处理函数。
    abortHostLookup(receiver: QObject)：中断正在进行的主机名查询。
    localHostName() -> str：获取本地主机名。
    localDomainName() -> str：获取本地域名。

    信号：

54. finished(QHostInfo)：主机名查询完成后发出的信号。QHostInfo 包含了查询到的 IP 地址列表和主机名列表。

    使用代码：

55. from PyQt5.QtCore import QCoreApplication
    from PyQt5.QtNetwork import QHostInfo
    
    def handle_host_lookup(info: QHostInfo):
        if info.error() == QHostInfo.NoError:
            print("Host name:", info.hostName())
            print("IP addresses:")
            for address in info.addresses():
                print("  -", address.toString())
        else:
            print("Error occurred:", info.errorString())
    
        QCoreApplication.quit()
    
    if __name__ == "__main__":
        app = QCoreApplication([])
    
        host_name = "www.google.com"
        QHostInfo.lookupHost(host_name, app, handle_host_lookup)
    
        app.exec_()
    

56. QTcpServer：

57. 用于创建TCP服务器，实现服务器端的网络通信。

58. 接口说明：

59. 方法：

60. listen(host: QHostAddress = QHostAddress.Any, port: int = 0) -> bool：开始在指定主机和端口上监听连接请求。
    close()：停止监听连接请求，并关闭服务器。
    isListening() -> bool：检查服务器是否正在监听连接请求。
    serverAddress() -> QHostAddress：获取服务器的地址。
    serverPort() -> int：获取服务器的端口。

    信号：

61. newConnection：当有新的连接请求到达时发出。

    使用代码：

62. from PyQt5.QtCore import QCoreApplication
    from PyQt5.QtNetwork import QTcpServer, QTcpSocket
    
    class MyTcpServer(QTcpServer):
        def incomingConnection(self, socketDescriptor):
            print("New connection established.")
            client_socket = QTcpSocket()
            client_socket.setSocketDescriptor(socketDescriptor)
            client_socket.readyRead.connect(self.handle_ready_read)
            client_socket.disconnected.connect(client_socket.deleteLater)
    
        def handle_ready_read(self):
            client_socket = self.sender()
            data = client_socket.readAll()
            print("Received data from client:", data.data().decode())
            client_socket.write(b"Hello, client!")
            client_socket.disconnectFromHost()
    
    if __name__ == "__main__":
        app = QCoreApplication([])
    
        server = MyTcpServer()
        server.listen(port=12345)
    
        app.exec_()
    

63. QAbstractSocket：

64. 是QTcpSocket和QUdpSocket的基类，提供了一些共同的功能，如连接建立和断开、错误处理等。

65. 接口说明：

66. 方法：

67. bind(address: QHostAddress, port: int, mode: BindMode = DefaultForPlatform) -> bool：绑定到指定的地址和端口，用于服务器端的绑定操作。
    connectToHost(hostName: str, port: int, openMode: QIODevice.OpenMode = ReadWrite)：连接到指定的主机和端口，用于客户端的连接操作。
    disconnectFromHost()：断开与主机的连接。
    abort()：中止当前操作并立即关闭套接字。
    state() -> QAbstractSocket.SocketState：获取当前套接字的状态，返回值为 SocketState 枚举类型。
    error() -> QAbstractSocket.SocketError：获取套接字的错误状态，返回值为 SocketError 枚举类型。
    errorString() -> str：获取描述错误状态的字符串。
    isValid() -> bool：检查套接字是否有效。
    setSocketOption(option: QAbstractSocket.SocketOption, value: Any) -> bool：设置套接字选项。
    socketOption(option: QAbstractSocket.SocketOption) -> Any：获取套接字选项的值。

    信号：

68. connected：当连接成功建立时发出。
    disconnected：当连接断开时发出。
    hostFound：当主机名解析成功时发出。
    stateChanged(QAbstractSocket.SocketState)：当套接字状态发生变化时发出。
    errorOccurred(QAbstractSocket.SocketError)：当发生错误时发出。

    枚举类型：

69. QAbstractSocket.SocketState：描述套接字状态的枚举类型，包括 UnconnectedState、HostLookupState、ConnectingState、ConnectedState、BoundState 和 ClosingState。
    QAbstractSocket.SocketError：描述套接字错误的枚举类型，包括 ConnectionRefusedError、RemoteHostClosedError、HostNotFoundError、SocketAccessError 等等。

    以上是Qt网络通信的一些主要组件和功能，可以根据具体的需求选择合适的组件和方法进行网络通信的开发。