1. 首页
  2. 作者
  3. System
使用 Lua 协程模拟 Golang 的 go defer 编程模式
System
2024-08-09
所有,golang

在Lua中没有直接的defer关键字，但是可以通过协程（coroutine）模拟出类似defer的行为。以下是一个简单的示例，展示了如何使用Lua协程来模拟defer的功能：




function defer_queue()
    local defer_queue = {}
 
    local function defer(fn)
        table.insert(defer_queue, fn)
    end
 
    local function run_defer()
        for i = #defer_queue, 1, -1 do
            local fn = table.remove(defer_queue)
            fn()
        end
    end
 
    return defer, run_defer
end
 
local defer, run_defer = defer_queue()
 
defer(function() print("第一个defer的函数") end)
defer(function() print("第二个defer的函数") end)
 
-- 正常的业务逻辑
print("正常的业务逻辑")
 
-- 执行defer队列中的函数
run_defer()

在这个例子中，defer_queue函数返回了defer函数和run_defer函数。defer函数接收一个函数作为参数，并将其插入到defer_queue中。当你想要执行这些被defer的函数时，调用run_defer函数，它会按照倒序执行defer_queue中的函数。这个模式类似于Golang中的defer关键字，但请注意，在Lua中并没有提供类似Golang那样的defer关键字，这只是一种模拟实现。

- 阅读更多 -
【Golang】gin框架如何在中间件中捕获响应并修改后返回
System
2024-08-09
所有,golang

在Gin框架中，你可以通过自定义中间件来捕获响应并进行修改。以下是一个示例代码，展示了如何在Gin中间件中捕获响应并修改：




package main
 
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
 
func main() {
    r := gin.Default()
 
    // 添加自定义中间件
    r.Use(ModifyResponseMiddleware())
 
    r.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "Original response")
    })
 
    r.Run()
}
 
func ModifyResponseMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 在响应写入前，捕获响应内容
        origWriter := c.Writer
        buf := bytes.NewBufferString("")
        multiWriter := io.MultiWriter(buf, origWriter)
        c.Writer = &myCustomResponseWriter{
            ResponseWriter: origWriter,
            body:           multiWriter,
        }
 
        // 继续处理请求
        c.Next()
 
        // 在这里可以修改响应内容
        modifiedBody := "Modified response: " + buf.String()
        origWriter.Header().Set("Content-Length", strconv.Itoa(len(modifiedBody)))
        origWriter.WriteHeader(http.StatusOK)
        _, _ = origWriter.Write([]byte(modifiedBody))
    }
}
 
type myCustomResponseWriter struct {
    http.ResponseWriter
    body io.Writer
}
 
func (w *myCustomResponseWriter) Write(b []byte) (int, error) {
    return w.body.Write(b)
}

在这个示例中，ModifyResponseMiddleware 函数创建了一个自定义的中间件，它捕获原始的响应体，并允许你在响应被写入客户端之前对其进行修改。这里使用了 io.MultiWriter 来同时写入原始响应体和修改后的响应体。

请注意，这只是一个简化的示例，实际应用中可能需要更复杂的逻辑来处理不同的情况，例如状态码、响应头等。

- 阅读更多 -
CSS技巧：实现两个div在同一行显示的方法
System
2024-08-09
所有,css

要使两个div元素在同一行显示，可以使用CSS的display属性或者flex布局。以下是两种方法的示例代码：

方法1：使用display: inline或display: inline-block




<!DOCTYPE html>
<html>
<head>
<style>
.div-inline {
  display: inline-block; /* 或者 display: inline; */
  width: 50%;
}
</style>
</head>
<body>
 
<div class="div-inline">Div 1</div>
<div class="div-inline">Div 2</div>
 
</body>
</html>

方法2：使用flex布局




<!DOCTYPE html>
<html>
<head>
<style>
.container {
  display: flex;
}
.div-flex {
  flex: 1; /* 或者指定具体的宽度 */
}
</style>
</head>
<body>
 
<div class="container">
  <div class="div-flex">Div 1</div>
  <div class="div-flex">Div 2</div>
</div>
 
</body>
</html>

在flex容器中，flex: 1确保两个div平分容器的空间，从而显示在同一行。如果你想要固定宽度，可以给div设置具体的宽度值。

- 阅读更多 -
Go语言---面向对象编程-匿名字段、同名字段、方法、方法集、方法的继承与重写、方法值与方法表达式
System
2024-08-09
所有,golang

在Go语言中，并没有传统意义上的面向对象编程，因为它支持结构体和接口，但不支持类和继承。不过，Go提供了很多模仿面向对象编程特性的方法，例如匿名字段、内嵌结构体、接口等。

  1. 匿名字段：可以让一个结构体嵌入到另一个结构体中，无需给嵌入的结构体命名。



type Person struct {
    Name string
    Age  int
}
 
type Student struct {
    Person // 匿名字段
    School string
}
 
func main() {
    s := Student{Person{"Bob", 20}, "MIT"}
    fmt.Println(s.Name, s.Age, s.School) // 输出 Bob 20 MIT
}
  1. 方法：可以给结构体类型添加方法，但不能像其他语言那样重写。



type Person struct {
    Name string
    Age  int
}
 
func (p Person) String() string {
    return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}
 
func main() {
    p := Person{"Bob", 20}
    fmt.Println(p.String()) // 输出 Bob (20 years)
}
  1. 接口：Go语言中的接口类似于其他语言中的协议或接口，可以被结构体类型实现。



type Person struct {
    Name string
    Age  int
}
 
type Speaker interface {
    Speak() string
}
 
func (p Person) Speak() string {
    return fmt.Sprintf("I am %v", p.Name)
}
 
func main() {
    p := Person{"Bob", 20}
    var s Speaker = p
    fmt.Println(s.Speak()) // 输出 I am Bob
}
  1. 继承和重写：Go不支持类似其他语言中的类继承，但可以通过内嵌结构体和接口来实现类似效果。



type Parent struct {
    Name string
}
 
type Child struct {
    Parent
    Age int
}
 
func (p Parent) ShowName() string {
    return p.Name
}
 
func (c Child) ShowName() string {
    return c.Name // 重写了
}
 
func main() {
    p := Parent{"Bob"}
    c := Child{Parent{"Alice"}, 10}
    fmt.Println(p.ShowName()) // 输出 Bob
    fmt.Println(c.ShowName()) // 输出 Alice，重写后的行为
}

以上代码展示了Go语言中的一些与面向对象编程相关的概念和用法。虽然没有传统意义上的面向对象编程，但Go提供的组合（结构体）和接口能够实现很多面向对象编程的特性。

- 阅读更多 -
golang使用nacos配置中心
System
2024-08-09
所有,golang

在Go语言中使用Nacos配置中心，你可以使用nacos-sdk-go客户端库。以下是一个简单的例子，展示如何使用Nacos配置中心来获取配置信息。

首先，通过以下命令安装Nacos SDK：




go get github.com/nacos-group/nacos-sdk-go

然后，你可以使用以下Go代码来获取Nacos配置中心的配置信息：




package main
 
import (
    "fmt"
    "github.com/nacos-group/nacos-sdk-go/clients"
    "github.com/nacos-group/nacos-sdk-go/common/constant"
    "github.com/nacos-group/nacos-sdk-go/vo"
)
 
func main() {
    // 创建Nacos客户端配置
    config := constant.ClientConfig{
        NamespaceId:   "命名空间ID", // 如果使用命名空间，请替换为实际的命名空间ID
        TimeoutMs:     5000,
        ListenInterval: 30 * 1000,
        LogDir:        "/tmp/log",
        CacheDir:      "/tmp/cache",
        ConfigType:    "yaml",
    }
 
    // 创建Nacos客户端
    client, err := clients.CreateConfigClient(config)
    if err != nil {
        panic(err)
    }
 
    // 获取配置
    content, err := client.GetConfig(vo.ConfigParam{
        DataId: "你的配置ID",
        Group:  "你的配置分组",
    })
    if err != nil {
        panic(err)
    }
 
    fmt.Println("获取到的配置内容:", content)
}

确保替换命名空间ID和你的配置ID、你的配置分组为实际的值。

这段代码首先配置了Nacos客户端，然后创建客户端并尝试获取配置中心的配置信息。如果配置存在，它将被打印出来。

请注意，你需要在你的Nacos服务器上正确配置你的配置信息，并确保网络连接和权限设置允许客户端访问。

- 阅读更多 -
go升级后 编译的exe在win7上无法正常运行
System
2024-08-09
所有,golang

报错问题：Go语言升级后编译的exe在Windows 7上无法正常运行。

可能原因及解决方法：

  1. 兼容性问题：

    • 解决方法：尝试以兼容模式运行exe文件，右键exe文件选择“属性”，在“兼容性”标签下，选择以兼容模式运行此程序，如Windows 7。

  2. 运行时依赖丢失：

    • 解决方法：确保目标系统上安装了所有必要的运行时依赖，如Visual C++可再发行组件等。

  3. 系统更新：

    • 解决方法：确保Windows 7系统已安装所有重要的更新。

  4. Go版本不兼容：

    • 解决方法：检查Go的新版本是否有与之相关的变更，导致与Windows 7不兼容，可以尝试安装旧版本的Go。

  5. 编译选项问题：

    • 解决方法：重新编译程序，确保编译选项与目标系统兼容，例如使用GOOS和GOARCH环境变量指定正确的目标操作系统和架构。

  6. 安全软件阻止：

    • 解决方法：检查安全软件（如杀毒软件）是否阻止了exe文件的运行。

  7. 路径问题：

    • 解决方法：确保exe文件路径没有特殊字符，且没有超过系统长度限制。

  8. 权限问题：

    • 解决方法：以管理员权限运行exe文件。

如果上述方法都不能解决问题，建议查看Windows 7系统的事件查看器，获取更具体的错误信息，进一步诊断问题。

- 阅读更多 -
不看后悔，一文入门Go云原生微服务
System
2024-08-09
所有,golang

Go语言是一种现代的编程语言，特别是在云原生和微服务领域，它的并发特性使其成为构建高效系统的理想选择。以下是一个简单的Go微服务示例，使用Go的标准库net/http来创建一个简单的HTTP服务。




package main
 
import (
    "log"
    "net/http"
)
 
func helloHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, World!"))
}
 
func main() {
    http.HandleFunc("/hello", helloHandler)
 
    log.Println("Starting server on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

这个微服务只有一个路由/hello，当访问这个路由时，它会简单地返回“Hello, World!”。这个例子展示了Go语言构建微服务的基本方法，并且是学习任何云原生Go微服务架构的基础。

要运行这个微服务，你需要安装Go环境，并保存上面的代码到一个.go文件中，比如main.go，然后运行以下命令：




go run main.go

服务将启动在8080端口。你可以通过访问http://localhost:8080/hello来测试它。

这个微服务示例是入门级别的，但它展示了构建生产级别微服务所需的基本要素，包括HTTP服务的启动和路由处理。随着学习的深入，你可以开始引入依赖注入、中间件、分布式跟踪等先进的云原生特性。

- 阅读更多 -
GO-创建TUN/TAP接口并实现报文的收发
System
2024-08-09
所有,golang



package main
 
import (
    "fmt"
    "golang.org/x/net/ipv4"
    "golang.org/x/sys/unix"
    "net"
    "os"
)
 
func main() {
    // 创建TUN/TAP接口
    tun, err := ipv4.NewTUN("tun0", ipv4.Config{
        Mode:    ipv4.TUNMode,
        MTU:     1500,
        Address: net.ParseIP("10.0.0.2"),
        Netmask: net.ParseIP("255.255.255.0"),
    })
    if err != nil {
        fmt.Println("创建TUN/TAP接口失败:", err)
        os.Exit(1)
    }
    defer tun.Close()
 
    // 设置接口为活动状态
    iferr := ipv4.SetLinkUp(tun.Fd()); err != nil {
        fmt.Println("设置接口为活动状态失败:", err)
        os.Exit(1)
    }
 
    // 创建一个goroutine来收取数据
    go func() {
        buf := make([]byte, 4096)
        for {
            n, err := tun.Read(buf)
            if err != nil {
                fmt.Println("读取TUN/TAP接口数据失败:", err)
                continue
            }
            // 处理收到的数据
            fmt.Printf("收到数据: %x\n", buf[:n])
        }
    }()
 
    // 模拟发送数据到TUN/TAP接口
    data := []byte{0x01, 0x02, 0x03, 0x04}
    if _, err := tun.Write(data, new(net.IPAddr)); err != nil {
        fmt.Println("写入TUN/TAP接口数据失败:", err)
        os.Exit(1)
    }
 
    fmt.Println("按任意键退出...")
    var b byte
    _, _ = fmt.Scanf("%c", &b)
}

这段代码首先导入必要的包，然后创建一个TUN接口，并设置其为活动状态。接着，它在一个goroutine中不断读取接收到的数据，并打印出来。最后，它向TUN接口发送了一个数据包，并等待用户输入来退出程序。这个例子展示了如何在Go语言中使用TUN/TAP设备，并处理网络数据包。

- 阅读更多 -
「GO基础」在Windows上安装Go编译器并配置Golang开发环境
System
2024-08-09
所有,golang

在Windows上安装Go编译器并配置Golang开发环境的步骤如下：

  1. 下载Go编译器安装包：

    访问Go官方下载页面（https://golang.org/dl/），选择Windows系统对应的安装包下载。

  2. 安装Go编译器：

    下载完成后，运行安装包开始安装，选择安装路径后一直点击"下一步"直至安装完成。

  3. 配置环境变量：

    • 打开"控制面板" -> "系统和安全" -> "系统" -> "高级系统设置" -> "环境变量"。
    • 在"系统变量"中找到并选择"Path"变量，点击"编辑"。
    • 点击"新建"，添加Go的安装目录下的bin文件夹路径，例如C:\Go\bin。
    • 点击"确定"保存环境变量设置。

  4. 验证安装是否成功：

    打开命令提示符（cmd）或PowerShell，输入以下命令：

    


go version

    如果显示了Go的版本信息，则表示安装成功。

以下是相关的命令行操作示例：




# 下载Go编译器安装包（请替换为最新的下载链接）
curl -O https://dl.google.com/go/go1.15.6.windows-amd64.msi

# 安装Go编译器
start go1.15.6.windows-amd64.msi

# 配置环境变量（手动添加到系统的Path变量中）
# 例如：C:\Go\bin

# 验证安装
go version
- 阅读更多 -
【Go语言精进之路】构建高效Go程序：了解map实现原理并高效使用
System
2024-08-09
所有,golang



// 定义一个简单的map
var countryCapitalMap map[string]string
 
func init() {
    countryCapitalMap = make(map[string]string)
    countryCapitalMap["France"] = "Paris"
    countryCapitalMap["Italy"] = "Rome"
    countryCapitalMap["China"] = "Beijing"
    countryCapitalMap["Spain"] = "Madrid"
    countryCapitalMap["USA"] = "Washington D.C."
}
 
// 获取国家的首都
func getCapital(country string) string {
    if capital, ok := countryCapitalMap[country]; ok {
        return capital
    }
    return "Capital not found"
}
 
func main() {
    // 示例使用
    fmt.Println(getCapital("France")) // 输出: Paris
}

这段代码首先定义了一个map来存储国家和它们对应的首都，然后初始化了这个map。getCapital函数用于检索指定国家的首都，如果国家存在于map中，则返回对应的首都，否则返回"Capital not found"。在main函数中，我们调用getCapital来获取法国的首都并打印输出。这个例子展示了如何有效地使用map数据结构来存储和检索键值对数据。

- 阅读更多 -
Copyright © 2026 Tech Blog
All Right Reserved | 京ICP备19053165号