在Golang中使用MySQL的最佳方法是什麼？

使用database/sql 包配合go-sql-driver/mysql 驅動，通過空白導入註冊驅動；2. 初始化單個*sql.DB 實例並複用，合理配置連接池參數以避免資源耗盡；3. 使用預處理語句和參數化查詢防止SQL 注入；4. 通過sql.Rows 將查詢結果安全掃描到結構體中，注意處理單行和多行數據；5. 可選使用GORM 等ORM 工具，但需權衡複雜性與性能；6. 仔細處理數據庫錯誤和NULL 值，使用sql.NullString 等類型或自定義掃描器；總結：推薦採用標準庫與驅動結合的方式，合理管理連接，使用參數化查詢，安全映射數據，僅在必要時引入ORM，以確保應用的高效、安全與可維護性。

The best way to work with MySQL in Golang is to use the database/sql package in combination with a MySQL driver like go-sql-driver/mysql (also known as mysql ), along with good practices around connection handling, query structuring, and error management.

Here's a breakdown of the recommended approach:

1. Use database/sql with go-sql-driver/mysql

Go's standard database/sql package provides a clean interface for working with SQL databases. Paired with the widely-used MySQL driver, it gives you full control and good performance.

First, install the driver:

 go get -u github.com/go-sql-driver/mysql

Then, import and use it:

 import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

Note the blank import ( _ ) — it registers the MySQL driver so sql.Open can use it.

2. Properly Initialize and Configure the Database Connection

Avoid calling sql.Open every time you need a connection. Instead, create a single *sql.DB instance and reuse it (it's safe for concurrent use).

 db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

// Test the connection
if err := db.Ping(); err != nil {
    log.Fatal(err)
}

Tune connection pooling to avoid resource exhaustion:

 db.SetMaxOpenConns(25)
db.SetMaxIdleConns(25)
db.SetConnMaxLifetime(5 * time.Minute)

These settings help manage connection reuse and prevent timeouts or leaks in production.

3. Use Prepared Statements and Parameterized Queries

Never concatenate user input into SQL strings. Use Prepare or Query/Exec with placeholders to avoid SQL injection.

 stmt, err := db.Prepare("INSERT INTO users(name, email) VALUES(?, ?)")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

_, err = stmt.Exec("John Doe", "john@example.com")
if err != nil {
    log.Fatal(err)
}

Alternatively, use db.Query or db.Exec directly with parameters — Go will prepare and cache the statement internally in many cases.

4. Map Rows to Structs Safely

Use sql.Rows and scan into structs. For simple cases, sql.Row works well:

 type User struct {
    ID int
    Name string
    Email string
}

var user User
err := db.QueryRow("SELECT id, name, email FROM users WHERE id = ?", 1).Scan(&user.ID, &user.Name, &user.Email)
if err != nil {
    if err == sql.ErrNoRows {
        // handle not found
    } else {
        log.Fatal(err)
    }
}

For multiple rows:

 rows, err := db.Query("SELECT id, name, email FROM users")
if err != nil {
    log.Fatal(err)
}
defer rows.Close()

var users []User
for rows.Next() {
    var u User
    if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
        log.Fatal(err)
    }
    users = append(users, u)
}
if err = rows.Err(); err != nil {
    log.Fatal(err)
}

5. Consider Using an ORM (Optional)

For larger projects, you might want to use an ORM or query builder like:

• GORM – Most popular Go ORM, supports associations, hooks, migrations.
• SQLBoiler – Generates type-safe code from your schema.
• Soda (from Pop) – Lightweight toolkit.

GORM example:

 import "gorm.io/gorm"

var user User
db.Where("id = ?", 1).First(&user)

But be cautious: ORMs can hide complexity and sometimes hurt performance. For many applications, raw database/sql with helper functions is simpler and more predictable.

6. Handle Errors and Nulls Carefully

MySQL allows NULL values. Use sql.NullString , sql.NullInt64 , etc., or define custom scanner types:

 var email sql.NullString
err := db.QueryRow("SELECT email FROM users WHERE id = ?", 1).Scan(&email)
if email.Valid {
    fmt.Println(email.String)
} else {
    fmt.Println("No email")
}

Or use structs with pointers or custom types that implement sql.Scanner .

In summary , the best way is:

• Stick with database/sql go-sql-driver/mysql
• Reuse the *sql.DB with proper pooling
• Use parameterized queries
• Scan into structs carefully
• Add an ORM only if the project complexity justifies it

It's not flashy, but it's fast, safe, and maintainable.基本上就這些。

以上是在Golang中使用MySQL的最佳方法是什麼？的詳細內容。更多資訊請關注PHP中文網其他相關文章！