将 Aira2 集成到 Go项目中

繁依Fanyi2024-06-22 2:01

介绍

Aria2 简介

Aria2 是一个轻量级的、跨平台的命令行下载工具，具有强大的多连接、多协议支持，以及灵活的任务控制功能。它可以同时从 HTTP、HTTPS、FTP、BitTorrent 和磁力链接等来源下载文件，并支持断点续传，可以在下载过程中暂停和恢复任务。Aria2 采用 C++ 编写，是一个高效、稳定且功能丰富的下载工具，在开源社区中得到了广泛的应用和认可。

Go 语言简介

Go 是一种由 Google 开发的开源编程语言，于 2009 年首次发布。它被设计为一种简单、高效、可靠的系统编程语言，具有强大的并发支持和优秀的标准库，尤其适用于构建并发和网络应用程序。Go 语言的设计目标之一是提供一种简洁而高效的方式来处理并发，使得编写并行程序变得更加容易和安全。

目的：将 Aria2 集成到 Go 项目中

本文的目的是向读者介绍如何将 Aria2 集成到 Go 项目中。通过将 Aria2 集成到你的 Go 项目中，你可以利用 Aria2 提供的强大功能来实现高效的文件下载。通过 Aria2 的多连接、多协议支持，你可以轻松地从各种来源下载文件，并通过 Go 语言的并发支持实现高性能的并行下载。将 Aria2 集成到你的 Go 项目中，不仅可以提升下载速度和稳定性，还可以简化代码结构，降低开发成本，让你的项目更加高效、可靠。

通过本文，读者将学习如何使用 Aria2 的 JSON-RPC 接口来控制下载任务，并将 Aria2 集成到自己的 Go 项目中。我们将从 Aria2 和 Go 语言的基本概念开始介绍，然后逐步深入到如何在 Go 中利用 Aria2 实现高效的文件下载。通过本文的指导，读者将掌握将 Aria2 集成到自己的 Go 项目中的技能，为他们的项目带来更强大的下载能力。

现在让我们开始探索如何将 Aria2 集成到 Go 项目中吧！

Aria2 简介

Aria2 是什么？

Aria2 是一个轻量级的、跨平台的命令行下载工具，由 Tatsuhiro Tsujikawa 开发。它是一个开源软件，最初发布于 2006 年，现在已经成为下载管理器领域中的主流工具之一。Aria2 可以同时从 HTTP、HTTPS、FTP、BitTorrent 和磁力链接等多种来源下载文件，并支持断点续传和多连接下载。它是一个功能强大、灵活且易于使用的下载工具，广泛应用于个人用户和企业环境。

特性和功能

Aria2 具有许多强大的特性和功能，使其成为一个受欢迎的下载工具：

  • 多连接下载: Aria2 支持同时使用多个连接下载同一个文件，可以显著提高下载速度。
  • 多协议支持: Aria2 支持 HTTP、HTTPS、FTP、BitTorrent 和磁力链接等多种下载协议，可以从各种来源下载文件。
  • 断点续传: Aria2 支持断点续传，如果下载中断，可以随时暂停和恢复下载任务，而不必重新下载文件。
  • 并行下载: Aria2 支持同时下载多个文件，可以通过并行下载来提高整体下载速度。
  • 灵活的任务控制: Aria2 提供了丰富的任务控制功能，可以设置下载优先级、限速、文件名等参数，满足不同用户的需求。
  • 轻量级: Aria2 是一个轻量级的命令行工具，占用资源少，运行稳定，适用于各种环境。

为什么选择 Aria2？

有几个原因使得 Aria2 成为一个受欢迎的下载工具：

  1. 功能丰富: Aria2 提供了丰富的特性和功能，满足了各种下载需求，从个人用户到企业级应用都可以使用。
  2. 跨平台性: Aria2 可以在各种操作系统上运行，包括 Windows、Linux、Mac 等，具有良好的跨平台兼容性。
  3. 开源免费: Aria2 是一个开源软件，可以免费使用和修改，没有任何使用限制，受到开发者和用户的欢迎。
  4. 活跃的社区: Aria2 有一个活跃的开发和用户社区，提供了丰富的文档和资源，用户可以方便地获取支持和帮助。
  5. 可扩展性: Aria2 支持通过插件和扩展来扩展其功能，用户可以根据自己的需求定制和扩展 Aria2 的功能。

总的来说，Aria2 是一个功能强大、灵活且易于使用的下载工具，适用于各种下载需求。无论是个人用户还是企业用户，都可以通过选择 Aria2 来实现高效的文件下载。

Aria2 RPC 接口

什么是 Aria2 RPC？

Aria2 RPC（Remote Procedure Call）是 Aria2 提供的一种远程控制接口，允许用户通过发送 JSON-RPC 请求来控制 Aria2 的行为。使用 RPC 接口，用户可以从远程位置控制 Aria2 的下载任务，包括添加任务、暂停任务、取消任务等操作，同时还可以获取下载状态和统计信息。Aria2 RPC 接口使用简单、灵活，可以方便地与各种编程语言和平台集成。

如何启用 Aria2 RPC？

要使用 Aria2 RPC 接口，首先需要启用 Aria2 的 RPC 功能。可以通过在启动命令中添加 --enable-rpc 参数来启用 RPC 功能。例如：

bash 复制代码 
aria2c --enable-rpc

此外，还可以通过添加 --rpc-listen-all 参数来监听所有网络接口，以便从远程位置访问 Aria2 的 RPC 接口。例如：

bash 复制代码 
aria2c --enable-rpc --rpc-listen-all

这样就可以在默认端口 6800 上启动 Aria2 的 RPC 服务器，可以从远程位置发送 JSON-RPC 请求来控制 Aria2 的行为。

RPC 接口的基本操作

Aria2 RPC 接口提供了丰富的操作，包括添加任务、暂停任务、取消任务等。以下是一些常见的 RPC 接口操作：

  • 添加下载任务 : 使用 aria2.addUri 方法可以向 Aria2 添加一个下载任务，指定下载链接和保存路径等参数。
  • 暂停下载任务 : 使用 aria2.pause 方法可以暂停正在进行的下载任务。
  • 恢复下载任务 : 使用 aria2.unpause 方法可以恢复暂停的下载任务。
  • 取消下载任务 : 使用 aria2.remove 方法可以取消指定的下载任务，并删除相关的文件。
  • 获取下载状态 : 使用 aria2.tellStatus 方法可以获取指定任务的下载状态，包括下载进度、下载速度等信息。
  • 获取全局统计信息 : 使用 aria2.getGlobalStat 方法可以获取 Aria2 的全局统计信息，包括当前活动任务数、已完成任务数等。

通过这些基本的 RPC 接口操作，用户可以方便地控制 Aria2 的行为，并获取下载任务的状态和统计信息。

Go 中的 JSON-RPC

什么是 JSON-RPC？

JSON-RPC（JavaScript Object Notation - Remote Procedure Call）是一种基于 JSON 数据格式的轻量级远程过程调用协议。它允许客户端向服务器发送一个方法调用请求，服务器则返回一个响应，以便在客户端和服务器之间进行通信。JSON-RPC 是一种简单而灵活的协议，适用于各种编程语言和平台，它使得不同系统之间的交互变得更加简单和可靠。

Go 中如何使用 JSON-RPC 进行通信？

在 Go 中，可以使用标准库中的 net/http 包来发送和接收 JSON-RPC 请求。首先，需要构建一个 JSON-RPC 请求对象，并将其编码为 JSON 字符串，然后将其发送到服务器。服务器接收到请求后，解码 JSON 字符串，并根据请求中的方法名调用相应的方法，并将方法的执行结果编码为 JSON 字符串，然后将其作为响应返回给客户端。

以下是一个简单的示例，演示了如何在 Go 中使用 JSON-RPC 进行通信：

go 复制代码 
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type Request struct {
    Method string        `json:"method"`
    Params []interface{} `json:"params"`
    ID     string        `json:"id"`
}

type Response struct {
    ID     string      `json:"id"`
    Result interface{} `json:"result"`
}

func sendRPCRequest(method string, params []interface{}, url string) (*Response, error) {
    request := Request{
        Method: method,
        Params: params,
        ID:     "1",
    }

    jsonData, err := json.Marshal(request)
    if err != nil {
        return nil, err
    }

    resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var response Response
    err = json.NewDecoder(resp.Body).Decode(&response)
    if err != nil {
        return nil, err
    }

    return &response, nil
}

func main() {
    // JSON-RPC 服务器地址
    rpcURL := "http://example.com/jsonrpc"

    // 发送 JSON-RPC 请求
    method := "exampleMethod"
    params := []interface{}{"param1", "param2"}
    response, err := sendRPCRequest(method, params, rpcURL)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("Response:", response)
}

在这个示例中，我们定义了一个 sendRPCRequest 函数来发送 JSON-RPC 请求，并在 main 函数中调用它来发送一个简单的 JSON-RPC 请求。你需要将 rpcURL 替换为你的 JSON-RPC 服务器地址，并根据你的需求修改方法名和参数。

在 Go 中集成 Aria2

导入所需的库

在 Go 中集成 Aria2，首先需要导入所需的库。我们将使用 net/http 包来发送 HTTP 请求，并使用 encoding/json 包来处理 JSON 数据。以下是导入所需库的代码：

go 复制代码 
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

构建 JSON-RPC 请求

接下来，我们需要构建一个 JSON-RPC 请求对象，该对象包含要调用的方法名和参数。我们将创建一个 Request 结构体来表示 JSON-RPC 请求，并将其编码为 JSON 格式的字符串。以下是构建 JSON-RPC 请求的代码：

go 复制代码 
type Request struct {
    Method string        `json:"method"`
    Params []interface{} `json:"params"`
    ID     string        `json:"id"`
}

func buildRPCRequest(method string, params []interface{}, id string) ([]byte, error) {
    request := Request{
        Method: method,
        Params: params,
        ID:     id,
    }

    jsonData, err := json.Marshal(request)
    if err != nil {
        return nil, err
    }

    return jsonData, nil
}

发送请求到 Aria2

现在我们已经构建了 JSON-RPC 请求对象，接下来我们需要将其发送到 Aria2 的 RPC 接口。我们将创建一个 sendRPCRequest 函数来发送 HTTP POST 请求，并将 JSON-RPC 请求作为请求体发送给 Aria2。以下是发送请求到 Aria2 的代码：

go 复制代码 
func sendRPCRequest(method string, params []interface{}, url string) (*http.Response, error) {
    jsonData, err := buildRPCRequest(method, params, "1")
    if err != nil {
        return nil, err
    }

    resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

    return resp, nil
}

处理 Aria2 的响应

最后，我们需要处理 Aria2 的响应。当 Aria2 接收到我们发送的 JSON-RPC 请求后，它会返回一个 JSON 格式的响应。我们需要解码这个响应，并提取出我们需要的信息。以下是处理 Aria2 的响应的代码：

go 复制代码 
func handleResponse(resp *http.Response) error {
    defer resp.Body.Close()

    var response map[string]interface{}
    err := json.NewDecoder(resp.Body).Decode(&response)
    if err != nil {
        return err
    }

    fmt.Println("Response:", response)

    // 处理响应数据...

    return nil
}

在 handleResponse 函数中，我们首先解码响应体，并将其存储在一个 map[string]interface{} 类型的变量中。然后我们可以从这个 map 中提取出我们需要的信息，并进行相应的处理。

现在我们已经完成了在 Go 中集成 Aria2 的所有步骤。我们可以使用以上的代码来构建一个完整的应用程序，通过 JSON-RPC 接口与 Aria2 进行通信，并控制下载任务。

添加下载任务

如何向 Aria2 添加下载任务？

要向 Aria2 添加下载任务，我们需要构建一个特定格式的 JSON-RPC 请求，该请求包含了要添加的下载任务的信息，如下载链接、保存路径等。然后，我们将这个请求发送到 Aria2 的 JSON-RPC 接口，并等待响应，以确认任务是否成功添加。

示例代码解析

让我们通过一个示例来演示如何向 Aria2 添加下载任务，并解析相应的示例代码：

go 复制代码 
func addDownloadTask(url string, savePath string) error {
    // 构建 JSON-RPC 请求
    method := "aria2.addUri"
    params := []interface{}{[]string{url}, map[string]interface{}{"dir": savePath}}
    jsonData, err := buildRPCRequest(method, params, "1")
    if err != nil {
        return err
    }

    // 发送请求到 Aria2
    resp, err := sendRPCRequest(string(jsonData), aria2URL)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // 处理 Aria2 的响应
    var response map[string]interface{}
    err = json.NewDecoder(resp.Body).Decode(&response)
    if err != nil {
        return err
    }

    // 检查是否添加任务成功
    if _, ok := response["result"]; !ok {
        return fmt.Errorf("failed to add download task: %v", response["error"])
    }

    fmt.Println("Download task added successfully!")
    return nil
}

在这段代码中，我们首先使用 aria2.addUri 方法构建了一个 JSON-RPC 请求，该请求包含了要下载的文件的链接和保存路径等参数。然后，我们使用之前编写的 sendRPCRequest 函数将该请求发送到 Aria2，并等待响应。

一旦收到响应，我们将解码响应体，并检查是否成功添加了下载任务。如果响应中包含了 result 字段，则表示任务添加成功，否则我们将从响应中获取错误信息，并返回相应的错误。

通过这段代码，我们可以向 Aria2 添加下载任务，并在任务添加成功或失败时得到相应的反馈。

管理下载任务

在使用 Aria2 进行下载时，管理下载任务是至关重要的。这包括暂停、取消下载任务，获取下载状态和进度，以及设置下载选项等。下面我们将详细介绍如何在 Go 中管理下载任务。

暂停、取消下载任务

要暂停或取消下载任务，我们需要发送相应的 JSON-RPC 请求到 Aria2，并等待响应确认任务已经被暂停或取消。

示例代码解析

下面是一个示例代码，演示了如何暂停或取消下载任务：

go 复制代码 
func pauseDownloadTask(gid string) error {
    // 构建 JSON-RPC 请求
    method := "aria2.pause"
    params := []interface{}{gid}
    jsonData, err := buildRPCRequest(method, params, "1")
    if err != nil {
        return err
    }

    // 发送请求到 Aria2
    resp, err := sendRPCRequest(string(jsonData), aria2URL)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // 处理 Aria2 的响应
    var response map[string]interface{}
    err = json.NewDecoder(resp.Body).Decode(&response)
    if err != nil {
        return err
    }

    // 检查是否暂停任务成功
    if _, ok := response["result"]; !ok {
        return fmt.Errorf("failed to pause download task: %v", response["error"])
    }

    fmt.Println("Download task paused successfully!")
    return nil
}

func cancelDownloadTask(gid string) error {
    // 构建 JSON-RPC 请求
    method := "aria2.remove"
    params := []interface{}{gid}
    jsonData, err := buildRPCRequest(method, params, "1")
    if err != nil {
        return err
    }

    // 发送请求到 Aria2
    resp, err := sendRPCRequest(string(jsonData), aria2URL)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // 处理 Aria2 的响应
    var response map[string]interface{}
    err = json.NewDecoder(resp.Body).Decode(&response)
    if err != nil {
        return err
    }

    // 检查是否取消任务成功
    if _, ok := response["result"]; !ok {
        return fmt.Errorf("failed to cancel download task: %v", response["error"])
    }

    fmt.Println("Download task cancelled successfully!")
    return nil
}

在这段代码中，我们首先构建了两个不同的 JSON-RPC 请求，一个用于暂停任务 (aria2.pause)，另一个用于取消任务 (aria2.remove)。然后，我们发送这些请求到 Aria2，并等待响应。最后，我们解码响应体，并检查是否成功暂停或取消了下载任务。

获取下载状态和进度

要获取下载任务的状态和进度，我们需要发送一个特定的 JSON-RPC 请求到 Aria2，并等待响应以获取相应的信息。

示例代码解析

下面是一个示例代码，演示了如何获取下载任务的状态和进度：

go 复制代码 
func getDownloadStatus(gid string) (map[string]interface{}, error) {
    // 构建 JSON-RPC 请求
    method := "aria2.tellStatus"
    params := []interface{}{gid}
    jsonData, err := buildRPCRequest(method, params, "1")
    if err != nil {
        return nil, err
    }

    // 发送请求到 Aria2
    resp, err := sendRPCRequest(string(jsonData), aria2URL)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    // 处理 Aria2 的响应
    var response map[string]interface{}
    err = json.NewDecoder(resp.Body).Decode(&response)
    if err != nil {
        return nil, err
    }

    // 检查是否获取任务状态成功
    if _, ok := response["result"]; !ok {
        return nil, fmt.Errorf("failed to get download task status: %v", response["error"])
    }

    return response["result"].(map[string]interface{}), nil
}

在这段代码中，我们构建了一个 aria2.tellStatus 的 JSON-RPC 请求，该请求用于获取指定下载任务的状态和进度信息。然后，我们发送这个请求到 Aria2，并等待响应。最后，我们解码响应体，并提取出任务的状态和进度信息。

设置下载选项

要设置下载任务的选项，我们需要发送一个特定的 JSON-RPC 请求到 Aria2，并等待响应以确认设置是否成功。

示例代码解析

下面是一个示例代码，演示了如何设置下载任务的选项：

go 复制代码 
func setDownloadOption(gid string, optionName string, optionValue interface{}) error {
    // 构建 JSON-RPC 请求
    method := "aria2.changeOption"
    params := []interface{}{gid, map[string]interface{}{optionName: optionValue}}
    jsonData, err := buildRPCRequest(method, params, "1")
    if err != nil {
        return err
    }

    // 发送请求到 Aria2
    resp, err := sendRPCRequest(string(jsonData), aria2URL)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // 处理 Aria2 的响应
    var response map[string]interface{}
    err = json.NewDecoder(resp.Body).Decode(&response)
    if err != nil {
        return err
    }

    // 检查是否设置任务选项

成功
    if _, ok := response["result"]; !ok {
        return fmt.Errorf("failed to set download task option: %v", response["error"])
    }

    fmt.Println("Download task option set successfully!")
    return nil
}

在这段代码中，我们构建了一个 aria2.changeOption 的 JSON-RPC 请求，该请求用于设置指定下载任务的选项。然后，我们发送这个请求到 Aria2，并等待响应。最后，我们解码响应体，并检查是否成功设置了下载任务的选项。

通过这些代码，我们可以轻松地管理下载任务，包括暂停、取消下载任务，获取下载状态和进度，以及设置下载选项等。

错误处理

在与 Aria2 进行交互的过程中，可能会遇到各种类型的错误。这些错误可能来自于网络通信问题、JSON-RPC 请求格式错误、Aria2 返回的错误信息等。下面我们将详细介绍可能遇到的错误类型，并提供一些处理这些错误的方法。

可能遇到的错误类型

  1. 网络通信错误: 可能由于网络连接问题或 Aria2 服务器故障等原因导致通信失败。
  2. JSON-RPC 请求格式错误: 可能由于构建 JSON-RPC 请求时参数错误或格式不正确等原因导致请求失败。
  3. Aria2 返回的错误信息: 当 Aria2 处理请求时出现错误，例如任务不存在、参数错误等，会返回相应的错误信息。

如何处理这些错误？

针对不同类型的错误，我们可以采取不同的处理方式：

  1. 网络通信错误: 可以通过检查网络连接状态来确认是否是网络问题，如果是网络问题，可以尝试重新连接或等待一段时间后重试。如果多次重试仍然失败，可以考虑输出错误信息并退出程序，或者尝试使用备用的 Aria2 服务器地址。
  2. JSON-RPC 请求格式错误: 可以通过检查构建 JSON-RPC 请求时的参数是否正确来确认是否是请求格式错误。如果参数错误，可以修正参数并重新发送请求。如果是其他格式错误，可以输出错误信息进行调试。
  3. Aria2 返回的错误信息: 当收到 Aria2 返回的错误信息时，可以根据错误信息的内容来确定错误的原因，并采取相应的措施。例如，如果是任务不存在错误，可以提示用户任务不存在；如果是参数错误，可以检查参数并修正后重新发送请求。

示例代码解析

下面是一个简单的示例代码，演示了如何处理可能遇到的错误：

go 复制代码 
func main() {
    // 尝试添加下载任务
    err := addDownloadTask("https://example.com/file.txt", "/path/to/save")
    if err != nil {
        // 处理网络通信错误
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            fmt.Println("网络超时，请检查网络连接并重试。")
        } else {
            fmt.Println("添加下载任务失败:", err)
        }
        return
    }

    // 尝试获取下载任务状态
    status, err := getDownloadStatus("123456")
    if err != nil {
        // 处理 Aria2 返回的错误信息
        fmt.Println("获取下载任务状态失败:", err)
        return
    }

    // 处理下载任务状态信息
    fmt.Println("下载任务状态:", status)
}

在这段示例代码中，我们尝试添加下载任务和获取下载任务状态，然后根据可能遇到的不同类型的错误进行了处理。如果是网络通信错误，我们首先检查是否是网络超时错误，如果是则提示用户网络超时，请检查网络连接并重试；如果不是网络超时错误，则输出具体的错误信息。如果是 Aria2 返回的错误信息，则直接输出错误信息进行调试。

通过这样的错误处理方式，我们可以有效地应对各种可能遇到的错误，提高程序的健壮性和稳定性。

测试与部署

如何测试集成 Aria2 的 Go 代码？

在测试集成 Aria2 的 Go 代码之前，我们应该确保已经安装并正确配置了 Aria2，并且 Aria2 的 RPC 功能已经启用。接下来，我们可以编写单元测试来测试各个功能函数是否正常工作，例如添加下载任务、暂停任务、取消任务等。我们还可以编写集成测试来模拟与实际 Aria2 服务器的交互，并确保整个流程的正确性。

在编写测试代码时，可以使用 Go 的内置测试框架 testing，结合一些常用的测试工具如 testify 来编写测试用例。在测试代码中，我们可以模拟各种场景，包括正常情况、异常情况、网络故障等，以确保代码的稳定性和健壮性。

部署到生产环境的注意事项

在将集成了 Aria2 的 Go 代码部署到生产环境时，有几个注意事项需要考虑：

  1. 安全性: 确保 Aria2 的 RPC 功能受到适当的安全配置，例如设置访问密码、限制访问 IP 等，以防止未授权的访问。
  2. 性能: 在生产环境中，可能会遇到大量的下载任务和高并发的请求，因此需要确保 Aria2 和 Go 代码的性能足够好，能够应对高负载情况。
  3. 稳定性: 在生产环境中，任何故障都可能影响到用户的使用体验，因此需要确保代码的稳定性和可靠性，及时处理各种异常情况。
  4. 监控和日志: 在部署到生产环境后，需要建立监控系统和日志系统，及时监控和记录系统的运行状态和异常情况，以便及时发现和解决问题。

在部署到生产环境之前，建议先在测试环境进行充分的测试和验证，确保代码的稳定性和可靠性。同时，定期进行代码审查和性能优化，保持代码的质量和性能。

总结

在软件开发中，集成第三方工具或服务是常见的任务。无论是集成下载工具、数据库、API 还是其他服务，都需要一些基本的步骤和技巧。首先，要了解第三方工具或服务的功能和特性，以便正确地使用它。其次，要熟悉与之交互的协议和接口，例如 JSON-RPC、RESTful API 等。然后，需要考虑如何处理各种可能的错误情况，以确保系统的稳定性和可靠性。最后，在部署到生产环境之前，要进行充分的测试和验证，以确保代码的质量和性能。通过遵循这些步骤和技巧，可以有效地集成第三方工具或服务，并构建出高质量和可靠性的软件系统。

相关推荐
秦jh_2 分钟前
【Linux】多线程（概念，控制）
linux·运维·前端
2401_857610033 分钟前
Spring Boot框架：电商系统的技术优势
java·spring boot·后端
蜗牛快跑21315 分钟前
面向对象编程 vs 函数式编程
前端·函数式编程·面向对象编程
Dread_lxy16 分钟前
vue 依赖注入（Provide、Inject ）和混入（mixins）
前端·javascript·vue.js
娅娅梨22 分钟前
C++ 错题本--not found for architecture x86_64 问题
开发语言·c++
汤米粥27 分钟前
小皮PHP连接数据库提示could not find driver
开发语言·php
冰淇淋烤布蕾30 分钟前
EasyExcel使用
java·开发语言·excel
Hacker_Nightrain36 分钟前
网络安全CTF比赛规则
网络·安全·web安全
拾荒的小海螺37 分钟前
JAVA：探索 EasyExcel 的技术指南
java·开发语言
秀儿还能再秀1 小时前
机器学习——简单线性回归、逻辑回归
笔记·python·学习·机器学习
热门推荐
01玄机平台应急响应—webshell查杀02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04新版微信小程序获取用户手机号05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06Windows10安装PCL1.14.0及点云配准07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【软件工程】UML用例图介绍和实例说明