AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Go 项目必备：Wire 依赖注入工具的深度解析与实战应用

2024-02-24 601
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 在现代软件开发中，依赖注入（Dependency Injection，简称 DI）已经成为一种广泛采用的设计模式。它的核心思想是通过外部定义的方式，将组件之间的依赖关系解耦，从而提高代码的可维护性、可扩展性和可测试性。然而，随着项目规模的增长，手动管理复杂的依赖关系变得日益困难。这时，依赖注入代码生成工具就显得尤为重要。在众多工具中，Wire 以其简洁、强大和易用性脱颖而出，成为 Go 语言项目中的宠儿。本文将带你深入了解 Wire 的安装、基本使用、核心概念以及高级用法，并通过一个实际的 web 博客项目示例，展示如何利用 Wire 简化依赖注入的实现。准备好了吗？让我们开始这场代码解耦的奇
在现代软件开发中，依赖注入（Dependency Injection，简称 DI）已经成为一种广泛采用的设计模式。它的核心思想是通过外部定义的方式，将组件之间的依赖关系解耦，从而提高代码的可维护性、可扩展性和可测试性。然而，随着项目规模的增长，手动管理复杂的依赖关系变得日益困难。这时，依赖注入代码生成工具就显得尤为重要。在众多工具中，Wire 以其简洁、强大和易用性脱颖而出，成为 Go 语言项目中的宠儿。本文将带你深入了解 Wire 的安装、基本使用、核心概念以及高级用法，并通过一个实际的 web 博客项目示例，展示如何利用 Wire 简化依赖注入的实现。准备好了吗？让我们开始这场代码解耦的奇妙之旅。

Wire 的安装与基本使用

安装 Wire

　　首先，我们需要安装 Wire。在 Go 环境中，安装过程非常简单：

go install github.com/google/wire/cmd/wire@latest

　　请确保你的 $GOPATH/bin​ 已经添加到了环境变量 $PATH​ 中。

前置代码准备

　　在开始使用 Wire 之前，我们需要准备一些前置代码。这通常包括定义项目中所需的类型、接口以及初始化函数。以下是一个简单的 web 博客项目的代码示例：

// handler.go
package handler

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

type PostHandler struct {
    serv service.IPostService
}

func (h *PostHandler) RegisterRoutes(engine *gin.Engine) {
    engine.GET("/post/:id", h.GetPostById)
}

func (h *PostHandler) GetPostById(ctx *gin.Context) {
    content := h.serv.GetPostById(ctx, ctx.Param("id"))
    ctx.String(http.StatusOK, content)
}

func NewPostHandler(serv service.IPostService) *PostHandler {
    return &PostHandler{serv: serv}
}
// service.go
package service

import "context"

type IPostService interface {
    GetPostById(ctx context.Context, id string) string
}

type PostService struct{}

func (s *PostService) GetPostById(ctx context.Context, id string) string {
    return "欢迎关注本掘金号，作者：陈明勇"
}

func NewPostService() IPostService {
    return &PostService{}
}
// ioc.go
package ioc

import (
    "github.com/gin-gonic/gin"
    "chenmingyong0423/blog/tutorial-code/wire/internal/post/handler"
    "chenmingyong0423/blog/tutorial-code/wire/internal/post/service"
)

func NewGinEngineAndRegisterRoute(postHandler *handler.PostHandler) *gin.Engine {
    engine := gin.Default()
    postHandler.RegisterRoutes(engine)
    return engine
}

使用 Wire 生成代码

　　在准备好前置代码后，我们需要创建一个名为 wire.go​ 的配置文件。在这个文件中，我们将定义注入器函数，用于指引 Wire 生成依赖注入代码。

// wire.go
//go:build wireinject
// +build wireinject

package wire

import (
    "chenmingyong0423/blog/tutorial-code/wire/internal/post/handler"
    "chenmingyong0423/blog/tutorial-code/wire/internal/post/service"
    "chenmingyong0423/blog/tutorial-code/wire/internal/post/ioc"
)

func InitializeApp() (*gin.Engine, func() error) {
    wire.Build(
        handler.NewPostHandler,
        service.NewPostService,
        ioc.NewGinEngineAndRegisterRoute,
    )
}

　　在 wire.go​ 文件的首行，我们使用了 //go:build wireinject​ 注释，这告诉 Go 编译器只有在使用 Wire 工具时才编译这部分代码。

　　接下来，在 wire.go​ 文件所在目录下执行以下命令，Wire 将自动生成 wire_gen.go​ 文件，其中包含了依赖注入的代码。

go run github.com/google/wire/cmd/wire

Wire 的核心概念

　　Wire 的核心概念包括提供者（Providers）和注入器（Injectors）。提供者是能够产生值的函数，而注入器则负责将所有提供者连接起来，完成依赖注入。

Wire 提供者（Providers）

　　提供者是一个有返回值的函数。在 Wire 中，我们可以通过 wire.NewSet​ 函数将多个提供者进行分组。例如，我们可以将与文章相关的提供者进行组合：

PostSet := wire.NewSet(NewPostHandler, service.NewPostService)

Wire 注入器（Injectors）

　　注入器的作用是连接所有的提供者。在之前的 InitializeApp​ 函数中，我们定义了一个注入器，它通过 wire.Build​ 方法连接了所有的提供者。

Wire 的高级用法

　　Wire 提供了多种高级用法，包括绑定接口、结构体提供者、绑定值、使用结构体字段作为提供者、清理函数等。

绑定接口

　　在 Wire 中，我们可以通过 wire.Bind​ 建立接口类型和具体实现类型之间的绑定关系。这在处理接口依赖时非常有用。

wire.Build(
    service.NewPostServiceV2,
    wire.Bind(new(service.IPostService), (*service.PostService)),
)

结构体提供者（Struct Providers）

　　Wire 的 wire.Struct​ 函数可以根据现有的类型构造结构体。这在需要根据类型字段进行依赖注入时非常有用。

user := &User{
    MyName:         name,
    MyPublicAccount: publicAccount,
}
wire.Struct(user, "MyName", "MyPublicAccount")

绑定值

　　有时候，我们可能需要直接在注入器中为一个类型赋值，而不是依赖提供者。这时，我们可以使用 wire.Value​ 来实现。

InjectUser := wire.Value(User{MyName: "陈明勇"})

使用结构体字段作为提供者

　　在某些情况下，我们可以使用结构体的某个字段作为提供者，从而生成一个类似 GetXXX​ 的函数。

wire.FieldsOf(&user, "MyName")

清理函数

　　如果一个提供者创建了需要清理的资源，它可以返回一个闭包来清理资源。注入器会用它来给调用者返回一个聚合的清理函数。

func provideFile(log Logger, path Path) (*os.File, func() error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, func() error { return err }
    }
    cleanup := func() error {
        return f.Close()
    }
    return f, cleanup
}

备用注入器语法

　　Wire 还提供了备用注入器语法，允许我们以更简洁的方式编写注入器函数。

InitializeGin := wire.Build(
    /* ... */
)

实战应用：构建一个简单的 Web 博客项目

　　为了更好地理解 Wire 的实际应用，我们将通过构建一个简单的 Web 博客项目来展示 Wire 的强大功能。这个项目将包括文章的获取、展示以及依赖注入的实现。

项目结构

　　首先，我们需要规划项目的结构。一个典型的 Go 项目结构可能如下所示：

/my-blog-project
    /cmd
        /main.go
    /internal
        /post
            handler.go
            service.go
            ioc.go
       /user
            // 其他模块...
    /config
        // 配置文件...
    /wire
        wire.go
    // 其他目录...

定义服务接口和实现

　　在 /internal/post/service.go​ 中，我们定义了 IPostService​ 接口及其实现：

package service

type IPostService interface {
    GetPostById(id string) (string, error)
}

type PostService struct{}

func (s *PostService) GetPostById(id string) (string, error) {
    // 实现获取文章的逻辑
    return "文章内容", nil
}

创建 HTTP 处理程序

　　在 /internal/post/handler.go​ 中，我们创建了 PostHandler​ 结构体，它包含了处理 HTTP 请求的方法：

package handler

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

type PostHandler struct {
    postService IPostService
}

func (h *PostHandler) GetPost(w http.ResponseWriter, r *http.Request) {
    id := r.URL.Query().Get("id")
    post, err := h.postService.GetPostById(id)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.Write([]byte(post))
}

func NewPostHandler(postService IPostService) *PostHandler {
    return &PostHandler{postService: postService}
}

初始化 Gin 引擎并注册路由

　　在 /internal/post/ioc.go​ 中，我们初始化 Gin 引擎并注册路由：

package ioc

import (
    "github.com/gin-gonic/gin"
    "my-blog-project/internal/post/handler"
)

func NewGinEngine() *gin.Engine {
    engine := gin.Default()
    postHandler := NewPostHandler(&service.PostService{})
    engine.GET("/posts/:id", postHandler.GetPost)
    return engine
}

使用 Wire 生成依赖注入代码

　　现在，我们可以在 wire.go​ 中定义注入器函数，并使用 Wire 生成依赖注入代码：

// wire.go
//go:build wireinject
// +build wireinject

package wire

import (
    "my-blog-project/cmd"
    "my-blog-project/internal/post/handler"
    "my-blog-project/internal/post/service"
    "my-blog-project/internal/post/ioc"
)

func InitializeApp() (*cmd.Server, error) {
    wire.Build(
        ioc.NewGinEngine,
        cmd.NewServer,
    )
}

　　运行 Wire 命令生成依赖注入代码：

go run github.com/google/wire/cmd/wire

启动服务器

　　最后，在 /cmd/main.go​ 中，我们启动服务器：

package cmd

import (
    "log"
    "net/http"

    "my-blog-project/internal/post/ioc"
)

func main() {
    server, err := NewServer()
    if err != nil {
        log.Fatalf("failed to initialize server: %v", err)
    }
    log.Fatal(server.Listen(":8080"))
}

测试我们的应用

　　现在，我们的 Web 博客项目已经准备好了。我们可以通过访问 http://localhost:8080/posts/1​ 来测试我们的应用是否能够正确地获取并展示文章内容。

高级特性：接口绑定与结构体注入

　　在 Go 项目中，我们经常会遇到需要绑定接口和结构体的场景。Wire 提供了强大的功能来处理这些情况，使得依赖注入更加灵活和强大。

接口绑定

　　在之前的示例中，我们看到了如何通过 wire.Bind​ 来绑定接口和具体的实现。这种方式在处理多个实现共享同一个接口时非常有用。例如，我们可能有多个服务实现了同一个接口，我们想要在注入时指定使用哪一个实现。

// 假设我们有两个服务实现了 IPostService 接口
type IPostService interface {
    GetPostById(id string) (string, error)
}

type PostServiceA struct{}
type PostServiceB struct{}

func (a *PostServiceA) GetPostById(id string) (string, error) {
    // 实现 A
}

func (b *PostServiceB) GetPostById(id string) (string, error) {
    // 实现 B
}

// 在 wire.go 中绑定接口和实现
wire.Build(
    service.NewPostServiceA,
    service.NewPostServiceB,
    wire.Bind(new(IPostService), new(*PostServiceA)),
    wire.Bind(new(IPostService), new(*PostServiceB)),
)

结构体注入

　　Wire 还允许我们直接在结构体中注入依赖。这意味着我们可以在结构体的字段上直接指定依赖，而不需要通过构造函数来传递。

type MyStruct struct {
    DB *Database // 假设 Database 是一个接口
}

func NewMyStruct(db *Database) *MyStruct {
    return &MyStruct{DB: db}
}

// 在 wire.go 中使用 wire.Struct 来注入依赖
wire.Build(
    NewMyStruct,
    wire.Struct(new(MyStruct), "DB"),
)

　　这种方式简化了结构体的创建过程，使得依赖注入更加直观。

错误处理与资源清理

　　在实际应用中，我们经常需要处理错误和资源清理。Wire 提供了优雅的方式来处理这些问题。

错误处理

　　在 Wire 的注入器中，我们可以返回错误，以便在初始化过程中捕获和处理错误。

func InitializeApp() (*gin.Engine, error) {
    engine, err := wire.Build(
        ioc.NewGinEngine,
    )
    if err != nil {
        return nil, err
    }
    return engine, nil
}

资源清理

　　对于需要清理的资源，我们可以在提供者中返回一个清理函数。Wire 会确保在资源不再需要时调用这个函数。

func provideDatabase() (*Database, func() error) {
    db, err := OpenDatabase()
    if err != nil {
        return nil, err
    }
    return db, func() error { return db.Close() }
}

// 在 wire.go 中使用
wire.Build(
    provideDatabase,
    // ...
)

测试与调试

　　在开发过程中，测试和调试是不可或缺的部分。Wire 提供了一些工具来帮助我们进行这些工作。

测试

　　Wire 支持测试模式，这允许我们在测试时模拟依赖，而不是使用真实的依赖。这在单元测试和集成测试中非常有用。

func TestInitializeApp(t *testing.T) {
    wire.Build(
        mock.NewPostService, // 使用模拟服务
        // ...
    )
}

调试

　　Wire 提供了调试模式，这可以帮助我们理解依赖注入的图谱。在调试模式下，Wire 会打印出所有的依赖关系，这对于理解复杂的依赖结构非常有用。

wire.Build(
    // ...
    wire.DebugPrint,
)

性能优化与并发处理

　　在构建大型应用时，性能和并发处理是两个关键的考虑因素。Wire 不仅能够简化依赖注入，还能帮助我们在这些方面进行优化。

性能优化

　　Wire 在生成依赖注入代码时，会尽量减少运行时的开销。通过预先计算依赖图，Wire 能够在启动时就确定所有依赖关系，从而减少运行时的反射调用。

　　此外，Wire 支持并发安全的操作，这意味着在多线程环境中，依赖注入的初始化过程不会成为性能瓶颈。这对于那些需要处理大量并发请求的应用来说尤为重要。

并发处理

　　在 Go 中，goroutine​ 是处理并发的基本单元。Wire 可以与 goroutine​ 配合使用，以确保依赖注入在并发环境中的正确性和效率。

　　例如，我们可能需要在不同的 goroutine​ 中创建不同的依赖实例。Wire 提供了 wire.Once​ 功能，它确保每个依赖只被创建一次，即使在多个 goroutine​ 中被请求。

var once wire.Once
once.Do(func() {
    // 在这里创建依赖实例
})

　　这种方式避免了在并发环境中重复创建依赖实例，从而提高了应用的性能。

微服务架构中的 Wire

　　随着微服务架构的流行，服务之间的依赖管理变得更加复杂。Wire 同样适用于微服务架构，它可以帮助我们管理服务间的依赖关系。

　　在微服务架构中，我们通常需要通过远程调用（如 gRPC）来与其它服务交互。Wire 可以与这些远程调用机制结合，自动处理服务间依赖的注入和初始化。

　　例如，我们可以在 Wire 的注入器中注入一个远程服务的客户端，然后在应用启动时初始化这个客户端。

func InitializeApp() (*gin.Engine, error) {
    wire.Build(
        service.NewRemoteServiceClient,
        // ...
    )
}

　　这样，我们就可以在应用的任何地方使用远程服务，而无需关心客户端的创建和初始化细节。

结语

　　 在本文中，我们深入探讨了 Wire 依赖注入工具在 Go 语言项目中的应用。从基本的安装和使用，到高级特性的掌握，再到性能优化和微服务架构中的实践，我们全面地展示了 Wire 如何帮助开发者构建更加健壮、可维护的系统。

　　Wire 的设计理念在于简化依赖注入的复杂性，它通过自动生成代码来管理依赖关系，从而减轻了开发者的负担。它的高级特性，如接口绑定、结构体注入、错误处理、资源清理，以及对并发和微服务架构的支持，进一步增强了其在现代软件开发中的价值。

　　随着 Go 语言在系统编程和云原生应用中的日益流行，Wire 作为一个强大的工具，将继续在提高开发效率和代码质量方面发挥重要作用。我们鼓励开发者在他们的 Go 项目中尝试使用 Wire，以体验其带来的便利和效率。

　　最后，感谢您的阅读，希望本文能够为您在使用 Wire 或探索 Go 语言依赖注入方面提供有价值的指导。如果您有任何疑问或想要了解更多信息，请随时提问，我在这里随时准备帮助您。

参考资料

文章标签：
云解析DNS
Go
微服务
开发者
设计模式
测试技术
关键词：
Go实战
Go应用
工具云解析DNS
云解析DNS go
Go解析
游客eg2mpb57glrj6
目录
相关文章
思通聚宝
|
3月前
|
机器学习/深度学习 文字识别 监控
安全监控系统：技术架构与应用解析
该系统采用模块化设计，集成了行为识别、视频监控、人脸识别、危险区域检测、异常事件检测、日志追溯及消息推送等功能，并可选配OCR识别模块。基于深度学习与开源技术栈（如TensorFlow、OpenCV），系统具备高精度、低延迟特点，支持实时分析儿童行为、监测危险区域、识别异常事件，并将结果推送给教师或家长。同时兼容主流硬件，支持本地化推理与分布式处理，确保可靠性与扩展性，为幼儿园安全管理提供全面解决方案。
思通聚宝
152 3
bruce_xiaowei
|
4月前
|
人工智能 API 开发者
HarmonyOS Next～鸿蒙应用框架开发实战：Ability Kit与Accessibility Kit深度解析
本书深入解析HarmonyOS应用框架开发，聚焦Ability Kit与Accessibility Kit两大核心组件。Ability Kit通过FA/PA双引擎架构实现跨设备协同，支持分布式能力开发；Accessibility Kit提供无障碍服务构建方案，优化用户体验。内容涵盖设计理念、实践案例、调试优化及未来演进方向，助力开发者打造高效、包容的分布式应用，体现HarmonyOS生态价值。
bruce_xiaowei
190 27
游客mass6jalwg5qm
|
3月前
|
存储 人工智能 API
离线VS强制登录？Apipost与Apifox的API工具理念差异深度解析
在代码开发中，工具是助手还是枷锁？本文通过对比Apipost和Apifox在断网环境下的表现，探讨API工具的选择对开发自由度的影响。Apifox强制登录限制了离线使用，而Apipost支持游客模式与本地存储，尊重开发者数据主权。文章从登录策略、离线能力、协作模式等方面深入分析，揭示工具背后的设计理念与行业趋势，帮助开发者明智选择，掌握数据控制权并提升工作效率。
游客mass6jalwg5qm
323 19
弹性计算小冉
|
4月前
|
存储 弹性计算 安全
阿里云服务器ECS通用型规格族解析：实例规格、性能基准与场景化应用指南
作为ECS产品矩阵中的核心序列，通用型规格族以均衡的计算、内存、网络和存储性能著称，覆盖从基础应用到高性能计算的广泛场景。通用型规格族属于独享型云服务器，实例采用固定CPU调度模式，实例的每个CPU绑定到一个物理CPU超线程，实例间无CPU资源争抢，实例计算性能稳定且有严格的SLA保证，在性能上会更加稳定，高负载情况下也不会出现资源争夺现象。本文将深度解析阿里云ECS通用型规格族的技术架构、实例规格特性、最新价格政策及典型应用场景，为云计算选型提供参考。
弹性计算小冉
220 2
Echo_Wish
|
4月前
|
数据采集 机器学习/深度学习 存储
可穿戴设备如何重塑医疗健康：技术解析与应用实战
可穿戴设备如何重塑医疗健康：技术解析与应用实战
Echo_Wish
150 4
游客mass6jalwg5qm
|
4月前
|
数据可视化 测试技术 API
前后端分离开发：如何高效调试API？有工具 vs 无工具全解析
在前后端分离开发中，API调试至关重要。本文探讨有无调试工具时如何高效调试API，重点分析Postman、Swagger等工具优势及无工具代码调试方法。通过实际场景如用户登录接口，对比两者特性。同时介绍Apipost-Hepler（IDEA插件），将可视化与代码调试结合，提供全局请求头配置、历史记录保存等功能，优化团队协作与开发效率，助力API调试进入全新阶段。
游客mass6jalwg5qm
178 11
喜欢猪猪
|
4月前
|
机器学习/深度学习 人工智能 Java
Java机器学习实战：基于DJL框架的手写数字识别全解析
在人工智能蓬勃发展的今天，Python凭借丰富的生态库（如TensorFlow、PyTorch）成为AI开发的首选语言。但Java作为企业级应用的基石，其在生产环境部署、性能优化和工程化方面的优势不容忽视。DJL（Deep Java Library）的出现完美填补了Java在深度学习领域的空白，它提供了一套统一的API，允许开发者无缝对接主流深度学习框架，将AI模型高效部署到Java生态中。本文将通过手写数字识别的完整流程，深入解析DJL框架的核心机制与应用实践。
喜欢猪猪
214 3
WBKJ_Noah18870292986
|
4月前
|
缓存 监控 搜索推荐
【实战解析】smallredbook.item_get_video API：小红书视频数据获取与电商应用指南
本文介绍小红书官方API——`smallredbook.item_get_video`的功能与使用方法。该接口可获取笔记视频详情，包括无水印直链、封面图、时长、文本描述、标签及互动数据等，并支持电商场景分析。调用需提供`key`、`secret`和`num_iid`参数，返回字段涵盖视频链接、标题、标签及用户信息等。同时，文章提供了电商实战技巧，如竞品监控与个性化推荐，并列出合规注意事项及替代方案对比。最后解答了常见问题，如笔记ID获取与视频链接时效性等。
WBKJ_Noah18870292986
138 0
游客udi3kxrk2deqo
|
NoSQL Java 测试技术
Go应用单元测试实践
Go应用单元测试搭建
游客udi3kxrk2deqo
1223 2
Go应用单元测试实践
游客kehwsvh7b7a2i
|
5月前
|
编译器 Go
揭秘 Go 语言中空结构体的强大用法
Go 语言中的空结构体 `struct{}` 不包含任何字段，不占用内存空间。它在实际编程中有多种典型用法：1) 结合 map 实现集合（set）类型；2) 与 channel 搭配用于信号通知；3) 申请超大容量的 Slice 和 Array 以节省内存；4) 作为接口实现时明确表示不关注值。此外，需要注意的是，空结构体作为字段时可能会因内存对齐原因占用额外空间。建议将空结构体放在外层结构体的第一个字段以优化内存使用。
游客kehwsvh7b7a2i
129 2

热门文章

最新文章

  • 1
    Go 网络编程：HTTP服务与客户端开发
  • 2
    Go语言Web开发框架实践：使用 Gin 快速构建 Web 服务
  • 3
    MCP 官方开源 Registry 注册服务：基于 Go 和 MongoDB 构建
  • 4
    Go语言Web开发框架实践：路由、中间件、参数校验
  • 5
    Go网络编程：基于TCP的网络服务端与客户端
  • 6
    Go语言网络编程：使用 net/http 构建 RESTful API
  • 7
    DNS+：互联网的下一个十年，为什么域名系统正在重新定义数字生态？ ——解读《“DNS+”发展白皮书（2023）》
  • 8
    go defer性能测试
  • 9
    Go并发之CSP并发模型、协程并发
  • 10
    【go语言】wait，wait for me
  • 1
    DNS+：互联网的下一个十年，为什么域名系统正在重新定义数字生态？ ——解读《“DNS+”发展白皮书（2023）》
    69
  • 2
    SSL证书验证全攻略：DNS/HTTP/手动解析怎么选？
    339
  • 3
    Infoblox DDI (NIOS) 9.0 - DNS、DHCP 和 IPAM (DDI) 核心网络服务管理
    70
  • 4
    使用nps配置内网穿透加域名解析
    379
  • 5
    阿里云服务器国际站dns服务器不可用怎么办?dns可以随便改吗?
    504
  • 6
    为何UDP协议不可靠？DNS为何选择UDP？
    152
  • 7
    域名解析的终极指南：从基础到进阶，彻底搞懂 DNS 记录
    614
  • 8
    离线VS强制登录？Apipost与Apifox的API工具理念差异深度解析
    325
  • 9
    DNS服务器地址大全
    3595
  • 10
    安全监控系统：技术架构与应用解析
    152

    • 相关课程

    更多
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • gohbase ：HBase go客户端
  • 云解析DNS在安全容灾场景下的应用分享
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 通过云拨测对指定服务器进行Ping/DNS监测

    • 推荐镜像

    更多
  • DNS
    • 下一篇
    【案例实战】SpringBoot整合阿里云文件上传OSS