Go 语言中的构造器模式：从 NewT() 到单例

package matrix

import "fmt"

// Matrix 表示一个二维矩阵
type Matrix struct {
    rows  int
    cols  int
    elems []float64
}

// NewMatrix 是 Matrix 结构体的构造函数，用于创建并初始化一个指定行数和列数的矩阵。
// 它返回一个指向新创建 Matrix 实例的指针。
func NewMatrix(rows, cols int) (*Matrix, error) {
    if rows <= 0 || cols <= 0 {
        return nil, fmt.Errorf("行数和列数必须大于0")
    }
    m := &Matrix{
        rows:  rows,
        cols:  cols,
        elems: make([]float64, rows*cols),
    }
    // 可以在这里进行其他初始化逻辑，例如填充默认值
    return m, nil
}

// SetValue 设置矩阵指定位置的值
func (m *Matrix) SetValue(r, c int, val float64) error {
    if r >= m.rows || c >= m.cols || r < 0 || c < 0 {
        return fmt.Errorf("索引超出矩阵范围")
    }
    m.elems[r*m.cols+c] = val
    return nil
}

// GetValue 获取矩阵指定位置的值
func (m *Matrix) GetValue(r, c int) (float64, error) {
    if r >= m.rows || c >= m.cols || r < 0 || c < 0 {
        return 0, fmt.Errorf("索引超出矩阵范围")
    }
    return m.elems[r*m.cols+c], nil
}

// Print 打印矩阵
func (m *Matrix) Print() {
    for i := 0; i < m.rows; i++ {
        for j := 0; j < m.cols; j++ {
            val, _ := m.GetValue(i, j)
            fmt.Printf("%.2f ", val)
        }
        fmt.Println()
    }
}

func main() {
    // 使用 NewMatrix 创建一个 2x3 的矩阵
    myMatrix, err := NewMatrix(2, 3)
    if err != nil {
        fmt.Println("创建矩阵失败:", err)
        return
    }

    // 设置值
    myMatrix.SetValue(0, 0, 1.1)
    myMatrix.SetValue(0, 1, 2.2)
    myMatrix.SetValue(0, 2, 3.3)
    myMatrix.SetValue(1, 0, 4.4)
    myMatrix.SetValue(1, 1, 5.5)
    myMatrix.SetValue(1, 2, 6.6)

    // 打印矩阵
    myMatrix.Print()
}

package main

import (
    "fmt"
    "net/http"
    "log"
)

// myOwnRouter 结构体实现了 http.Handler 接口
type myOwnRouter struct {
    // 可以在这里添加路由相关的字段，例如路由规则、中间件等
}

// ServeHTTP 是 http.Handler 接口的方法，处理传入的 HTTP 请求
func (mor *myOwnRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from my own Router! Request Path: %s\n", r.URL.Path)
}

// NewMyOwnRouter 是 myOwnRouter 结构体的构造函数。
// 它返回一个指向 myOwnRouter 实例的指针。
func NewMyOwnRouter() *myOwnRouter {
    // 在这里可以执行任何初始化逻辑，例如加载配置、设置默认值等
    fmt.Println("NewMyOwnRouter 被调用，创建了一个新的路由器实例。")
    return &myOwnRouter{}
}

func main() {
    // 使用 NewMyOwnRouter 函数创建路由器实例，并将其注册到 HTTP 服务器
    http.Handle("/", NewMyOwnRouter())

    fmt.Println("服务器已启动，监听端口 :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "fmt"
    "net/http"
    "log"
    "sync" // 引入 sync 包用于实现线程安全
)

// myOwnRouter 结构体，作为单例的例子
type myOwnRouter struct {
    // 可以包含一些全局共享的配置或状态
    config string
}

// ServeHTTP 实现了 http.Handler 接口
func (mor *myOwnRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from the Singleton Router! Config: %s, Path: %s\n", mor.config, r.URL.Path)
}

// 声明一个私有的实例变量，用于存储唯一的路由器实例
var singletonRouter *myOwnRouter

// 使用 sync.Once 确保初始化操作只执行一次，即使在并发环境下
var once sync.Once

// GetMyOwnRouter 返回 myOwnRouter 的单例实例。
// 这是一个线程安全的函数。
func GetMyOwnRouter() *myOwnRouter {
    // once.Do 方法接收一个函数作为参数，并确保这个函数只会被执行一次。
    // 这解决了并发初始化的问题。
    once.Do(func() {
        singletonRouter = &myOwnRouter{
            config: "Default Router Config", // 初始化单例的字段
        }
        fmt.Println("myOwnRouter 单例已初始化。")
    })
    return singletonRouter
}

func main() {
    // 获取单例路由器实例并注册到 HTTP 服务器
    http.Handle("/", GetMyOwnRouter())

    // 再次获取单例实例，会发现返回的是同一个实例
    router1 := GetMyOwnRouter()
    router2 := GetMyOwnRouter()
    fmt.Printf("Router 1 地址: %p\n", router1)
    fmt.Printf("Router 2 地址: %p\n", router2) // 应该与 Router 1 地址相同

    fmt.Println("服务器已启动，监听端口 :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}