分类 golang 下的文章

内网穿透篇五：通过 ddns-go 动态域名解析实现公网访问内网服务

2024-08-08




package main
 
import (
    "fmt"
    "log"
    "net/http"
 
    "github.com/gorilla/mux"
    "github.com/phayes/freeport"
    "github.com/qiniu/http-go-sdk/v7/hack"
)
 
func main() {
    // 获取一个可用的端口号
    port, err := freeport.GetFreePort()
    if err != nil {
        log.Fatal(err)
    }
 
    // 创建一个 HTTP 服务器
    server := &http.Server{
        Addr:    fmt.Sprintf(":%d", port),
        Handler: mux.NewRouter(),
    }
 
    // 使用 hack.HijackHttpListenAndServe 方法来监听并服务于上述端口
    hack.HijackHttpListenAndServe(server)
}

这段代码使用了hack.HijackHttpListenAndServe函数替换了标准库中的http.ListenAndServe函数。它首先获取一个可用的端口号，然后创建一个http.Server实例并设置其监听地址。最后，它使用hack.HijackHttpListenAndServe函数来启动服务，而不会阻塞主线程。这样做可以让服务在后台持续运行，并且能够处理外部的HTTP请求。

推荐项目：go-blog —— 一款高效且灵活的个人博客系统

2024-08-08

项目名称：go-blog

项目描述：

go-blog 是一个使用 Go 语言开发的高效、灵活且易于使用的个人博客系统。它提供了一个简洁的管理面板，允许用户通过网页进行内容管理，同时也包含了强大的命令行工具，用于部署和管理博客。

特性：

易于使用的管理面板
支持 Markdown 格式的博客文章
实时预览功能，方便写作
完善的命令行工具
自动化的部署流程
高效的性能，适合个人使用

安装与使用：




# 克隆仓库
git clone https://github.com/rainybowe/go-blog.git
 
# 进入目录
cd go-blog
 
# 构建项目
go build
 
# 运行项目
./go-blog
 
# 访问博客，默认地址为 http://localhost:8080/admin

项目地址：https://github.com/rainybowe/go-blog

深入go泛型特性之comparable「附案例」

2024-08-08




package main
 
import (
    "fmt"
)
 
// 定义一个泛型结构体，用于比较
type Comparable[T comparable] struct {
    value T
}
 
// 定义一个泛型函数，用于比较两个Comparable实例
func Equal[T comparable](a, b Comparable[T])ool {
    return a.value == b.value
}
 
func main() {
    // 创建两个整型的Comparable实例
    a := Comparable[int]{value: 10}
    b := Comparable[int]{value: 20}
    c := Comparable[int]{value: 10}
 
    // 使用泛型函数进行比较
    fmt.Printf("a == b: %v\n", Equal(a, b)) // 输出: a == b: false
    fmt.Printf("a == c: %v\n", Equal(a, c)) // 输出: a == c: true
}

这段代码定义了一个泛型结构体Comparable和一个泛型函数Equal，用于比较两个值是否相等。在main函数中，我们创建了三个Comparable[int]实例，并使用Equal函数来展示它们之间的相等性。这个例子简单直观地展示了泛型在Go语言中的应用，有助于理解和学习泛型编程。

项目中关于GO语言的bug与总结

2024-08-08

由于问题描述不具体，我将提供一个针对Go语言常见错误的简要概述和修复方法。

编译错误：
- 缺少导入路径或包名：确保所有依赖项都已导入并正确编写包名。
- 语法错误：检查代码是否符合Go语法规范。
- 类型不匹配：确保变量赋值与声明类型一致。
- 函数参数不匹配：检查函数调用是否提供了正确类型和数量的参数。
运行时错误：
- 空指针引用：在使用指针前进行nil检查，或使用指针前进行正确的初始化。
- 数组索引越界：确保在访问数组时索引在有效范围内。
- 切片操作越界：类似数组索引越界，但需要注意append操作后的切片长度。
- 并发错误：确保使用锁来同步访问共享资源，避免数据竞争。
性能问题：
- 内存泄漏：确保所有分配的内存都有对应的释放操作。
- 死锁：避免在并发代码中出现死锁情况。
- 过度优化：在保证代码正确性和可读性的前提下进行优化。
逻辑错误：
- 逻辑缺陷：检查代码逻辑是否有错误或未考虑到的边界情况。
- 错误的循环逻辑：修正循环的初始化、迭代条件和终止条件。
测试不足：
- 缺少单元测试：编写足够的测试用例来覆盖代码的不同分支和功能。
- 边界条件测试不足：确保测试用例覆盖了输入的边界值和异常情况。
包管理问题：
- 依赖版本不匹配：确保go.mod文件中指定的依赖版本与项目需求一致。
- 缺少依赖项：运行go mod tidy来清理未使用的依赖，并添加缺失的依赖。
代码风格问题：
- 不符合社区规范：遵循Go的代码规范和最佳实践，如命名约定、组织结构等。
文档不足：
- 缺少注释或文档：添加必要的注释或文档来解释代码的复杂部分。

针对这些常见错误，修复方法通常涉及检查代码、运行测试、审查依赖关系和格式化，以及遵循最佳实践。对于编译器报告的错误，通常可以通过编辑代码来解决。对于运行时错误，需要调试和修复代码中的逻辑问题。性能问题通常需要分析和优化代码。测试不足可以通过增加测试覆盖来解决。包管理问题可以通过管理go.mod文件来解决。风格问题可以通过go fmt和其他linter工具来自动格式化和检查。文档不足可以通过添加或更新注释和文档字符串来解决。

沉浸式go-cache源码阅读！

2024-08-08

go-cache 是一个 Go 语言的缓存库，用于简单的内存缓存。以下是一个简单的示例，展示如何使用 go-cache 来缓存数据。

首先，你需要安装 go-cache 包：




go get -u github.com/patrickmn/go-cache

下面是使用 go-cache 的一个简单示例：




package main
 
import (
    "fmt"
    "time"
 
    "github.com/patrickmn/go-cache"
)
 
func main() {
    // 创建一个新的缓存实例，设置默认的过期时间和清理间隔
    c := cache.New(5*time.Minute, 10*time.Minute)
 
    // 添加一个键值对到缓存中
    c.Set("key", "value", cache.DefaultExpiration)
 
    // 从缓存中获取键对应的值
    value, found := c.Get("key")
    if found {
        fmt.Println(value) // 输出: value
    }
 
    // 使用一个无限循环模拟长时间运行的应用程序
    for {
        // 每隔一段时间检查和清理过期的键
        time.Sleep(1 * time.Minute)
    }
}

在这个例子中，我们创建了一个缓存实例，并向其中添加了一个键值对。然后我们获取并打印了这个键对应的值。最后，我们使用一个无限循环来模拟长时间运行的应用程序，以便于我们可以观察缓存的过期和清理机制。

要深入阅读和理解 go-cache 的实现细节，你可以查看其 GitHub 仓库中的源代码，阅读 cache.go 文件，了解缓存的数据结构和基本操作，比如 Set、Get 和 Delete 等。

Golang内存、指针逃逸、垃圾回收机制概览

2024-08-08




package main
 
import (
    "fmt"
    "runtime"
    "runtime/debug"
)
 
func main() {
    // 设置GCPercent为100，确保每次垃圾回收都会打印信息
    debug.SetGCPercent(100)
 
    // 初始化内存分配统计信息
    m1 := new(runtime.MemStats)
    runtime.ReadMemStats(m1)
 
    // 分配内存
    a := make([]*byte, 1000000)
    for i := 0; i < len(a); i++ {
        b := new(byte)
        a[i] = b
    }
 
    // 再次读取内存统计信息并打印
    runtime.ReadMemStats(m1)
    fmt.Printf("分配内存后的统计信息: %+v\n", *m1)
 
    // 强制进行垃圾回收并打印回收结果
    runtime.GC()
    debug.FreeOSMemory()
 
    // 读取最终的内存统计信息并打印
    m2 := new(runtime.MemStats)
    runtime.ReadMemStats(m2)
    fmt.Printf("垃圾回收后的统计信息: %+v\n", *m2)
}

这段代码首先设置了GC百分比为100，确保每次垃圾回收都会打印信息。然后初始化了内存分配的统计信息并读取当前的内存状态。接下来，代码创建了一个包含100万个指针的切片，每个指针指向一个新分配的字节类型的内存地址。之后再次读取内存统计信息并打印。接着代码强制进行垃圾回收，并释放未使用的内存。最后，代码读取回收后的内存统计信息并打印。这个过程可以帮助理解Go语言的内存分配和垃圾回收机制。

Go每日一库之rotatelogs

2024-08-08

rotatelogs是一个用于日志轮转的库，通常在处理日志时使用，它可以按照设定的频率或大小对日志文件进行轮转，生成新的日志文件。在Go语言中，rotatelogs并不是一个标准库的一部分，它需要通过第三方库来使用。

以下是一个使用rotatelogs的例子：

首先，你需要安装rotatelogs库，可以通过以下命令进行安装：




go get github.com/lestrrat-go/file-rotatelogs

然后，你可以在Go代码中这样使用rotatelogs：




package main
 
import (
    "github.com/lestrrat-go/file-rotatelogs"
    "io"
    "log"
    "time"
)
 
func main() {
    // 创建rotatelogs，日志文件名会以log.2006-01-02.15-04-05为格式进行命名，并且每天轮转一次
    writer, err := rotatelogs.New(
        "log.%Y-%m-%d.%H-%M-%S",
        rotatelogs.WithLinkName("./current.log"),  // 生成软链接指向最新日志文件
        rotatelogs.WithMaxAge(24*time.Hour),      // 文件最大保存时间
        rotatelogs.WithRotationTime(24*time.Hour), // 日志轮转的时间间隔
    )
    if err != nil {
        log.Fatalf("can't create rotatelogs: %s", err)
    }
 
    // 使用log.New()创建一个日志对象，writer设置为rotatelogs实例
    log.SetOutput(writer)
 
    // 进行日志记录
    log.Print("hello world")
 
    // 关闭writer，这里会关闭文件句柄
    if closer, ok := writer.(io.Closer); ok {
        closer.Close()
    }
}

在这个例子中，我们创建了一个每天轮转一次的日志文件，并且保存了24小时。同时，我们创建了一个软链接current.log指向最新的日志文件。这样，无论你通过log标准库记录信息还是通过writer记录信息，日志都会被记录到指定的文件中。最后，我们在程序结束时关闭了writer，确保文件句柄被正确关闭。

利用Golang实现高性能的并发编程

2024-08-08




package main
 
import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)
 
var (
    wg           sync.WaitGroup
    counter int32
)
 
func main() {
    start := time.Now()
 
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go incrementCounter()
    }
 
    wg.Wait() // Wait for all goroutines to finish
    elapsed := time.Since(start)
 
    fmt.Printf("Counter: %d\n", counter)
    fmt.Printf("Time taken: %s\n", elapsed)
}
 
func incrementCounter() {
    defer wg.Done()
    atomic.AddInt32(&counter, 1)
}

这段代码使用了sync和sync/atomic包来处理并发。wg.Add(1)为等待组添加一个计数，每个并发执行的任务会调用incrementCounter函数，它通过atomic.AddInt32(&counter, 1)以原子方式递增全局计数器counter。使用sync.WaitGroup确保主函数等待所有goroutine完成后再打印结果和耗时。这是一个简单的并发编程示例，展示了Go语言中的高效原子操作和并发处理。

go语言并发实战——日志收集系统利用tail包实现对日志文件的实时监控

2024-08-08




package main
 
import (
    "fmt"
    "github.com/hpcloud/tail"
    "os"
    "os/signal"
    "syscall"
)
 
func main() {
    // 创建一个tail.Config结构体实例，并设置配置
    cfg := tail.Config{
        ReOpen:    true,        // 当文件被删除或重命名后，自动尝试重新打开
        Follow:    true,        // 实时监控文件新增内容
        Location: &tail.SeekInfo{Offset: 0, Whence: os.SEEK_END}, // 从文件末尾开始读取
        MustExist: false,       // 如果文件不存在，不会返回错误
    }
 
    // 创建tail.Tail实例，并开始监控日志文件
    t, err := tail.TailFile("/path/to/your/logfile.log", cfg)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
 
    // 监听系统信号，如果接收到SIGINT或SIGTERM，则退出程序
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 
    go func() {
        <-sigs
        t.Stop()
    }()
 
    // 循环读取文件内容
    for line := range t.Lines {
        fmt.Println(line.Text)
    }
 
    fmt.Println("Exiting...")
}

这段代码使用了tail包来实现对日志文件的实时监控。它首先配置了tail.Config，然后使用tail.TailFile函数来创建一个监控实例。接着，它设置了一个系统信号监听，以便在程序接收到SIGINT或SIGTERM信号时优雅地退出程序。最后，它在一个goroutine中循环读取文件的新内容，并将每行输出到控制台。