2757 字
14 分钟
数据库引入
2026-07-30Gin 框架ginWeb 开发数据库

本篇为历史笔记，保留用于兼容已有链接。GORM 主线内容已整理到 Gorm/快速开始，包括学习大纲、快速开始模板、数据源配置、CRUD、事务和 Gin 集成。MongoDB 等非 GORM 内容仍保留在本篇历史内容中。

Gorm 引入 MySQL#

初始化#

package main


import (
  "log"
  "os"
  "time"


  "github.com/gin-gonic/gin"


  "gorm.io/driver/mysql"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "gorm.io/gorm/schema"
)


// 全局数据库对象
var DB *gorm.DB


// 示例模型
type User struct {
  ID        uint      `gorm:"primaryKey"`
  Username  string    `gorm:"size:50;unique;not null"`
  Email     string    `gorm:"size:100;unique;not null"`
  Password  string    `gorm:"size:255;not null"`
  Age       int
  CreatedAt time.Time
  UpdatedAt time.Time
}


// 初始化数据库
func InitDB() {


  // MySQL 连接字符串
  dsn := "root:123456@tcp(127.0.0.1:3306)/demo?charset=utf8mb4&parseTime=True&loc=Local"


  // GORM 配置
  config := &gorm.Config{


    // 跳过默认事务（提高性能）
    SkipDefaultTransaction: true,


    // 开启 SQL 预编译
    PrepareStmt: true,


    // 命名策略
    NamingStrategy: schema.NamingStrategy{


      // User -> user
      SingularTable: true,


      // 表名前缀
      TablePrefix: "t_",
    },


    // GORM 日志
    Logger: logger.New(


      log.New(os.Stdout, "\r\n", log.LstdFlags),


      logger.Config{


        // 慢 SQL 阈值
        SlowThreshold: time.Second,


        // 日志级别
        LogLevel: logger.Info,


        // 忽略 RecordNotFound
        IgnoreRecordNotFoundError: true,


        // 彩色输出
        Colorful: true,
      },
    ),
  }


  var err error


  // 建立数据库连接
  DB, err = gorm.Open(mysql.Open(dsn), config)
  if err != nil {
    log.Fatal("数据库连接失败：", err)
  }


  // 获取底层 sql.DB
  sqlDB, err := DB.DB()
  if err != nil {
    log.Fatal(err)
  }


  // 数据库连接池配置
  // 最大空闲连接数
  sqlDB.SetMaxIdleConns(10)


  // 最大打开连接数
  sqlDB.SetMaxOpenConns(100)


  // 连接最大生命周期
  sqlDB.SetConnMaxLifetime(time.Hour)


  // 空闲连接最大生命周期
  sqlDB.SetConnMaxIdleTime(30 * time.Minute)


  // 测试数据库连接
  err = sqlDB.Ping()
  if err != nil {
    log.Fatal("数据库 Ping 失败：", err)
  }


  // 自动迁移
  err = DB.AutoMigrate(&User{})
  if err != nil {
    log.Fatal("自动迁移失败：", err)
  }


  log.Println("MySQL 初始化成功")
}


func main() {


  // 初始化数据库
  InitDB()


  // 初始化 Gin
  r := gin.Default()


  // 测试接口
  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  // 启动服务
  r.Run(":8080")
}

DSN 参数说明#

参数说明
root数据库用户名
123456数据库密码
127.0.0.1数据库地址
3306MySQL 默认端口
demo数据库名称
charset=utf8mb4使用 UTF-8 字符集，支持 Emoji
parseTime=True自动将 MySQL 的时间类型解析为 time.Time
loc=Local使用本地时区

Gorm 引入 SQL Server#

初始化#

package main


import (
  "log"
  "os"
  "time"


  "github.com/gin-gonic/gin"


  "gorm.io/driver/sqlserver"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "gorm.io/gorm/schema"
)


// 全局数据库对象
var DB *gorm.DB


// 示例模型
type User struct {
  ID        uint      `gorm:"primaryKey"`
  Username  string    `gorm:"size:50;unique;not null"`
  Email     string    `gorm:"size:100;unique;not null"`
  Password  string    `gorm:"size:255;not null"`
  Age       int
  CreatedAt time.Time
  UpdatedAt time.Time
}


// 初始化数据库
func InitDB() {


  // SQL Server 连接字符串
  dsn := "sqlserver://sa:123456@127.0.0.1:1433?database=demo"


  // GORM 配置
  config := &gorm.Config{


    // 跳过默认事务（提高性能）
    SkipDefaultTransaction: true,


    // 开启 SQL 预编译
    PrepareStmt: true,


    // 命名策略
    NamingStrategy: schema.NamingStrategy{


      // User -> user
      SingularTable: true,


      // 表名前缀
      TablePrefix: "t_",
    },


    // SQL 日志
    Logger: logger.New(


      log.New(os.Stdout, "\r\n", log.LstdFlags),


      logger.Config{


        // 慢 SQL 阈值
        SlowThreshold: time.Second,


        // 日志级别
        LogLevel: logger.Info,


        // 忽略 RecordNotFound
        IgnoreRecordNotFoundError: true,


        // 彩色日志
        Colorful: true,
      },
    ),
  }


  var err error


  // 建立数据库连接
  DB, err = gorm.Open(sqlserver.Open(dsn), config)
  if err != nil {
    log.Fatal("数据库连接失败：", err)
  }


  // 获取底层 sql.DB
  sqlDB, err := DB.DB()
  if err != nil {
    log.Fatal(err)
  }


  // 数据库连接池配置
  // 最大空闲连接数
  sqlDB.SetMaxIdleConns(10)


  // 最大打开连接数
  sqlDB.SetMaxOpenConns(100)


  // 连接最大生命周期
  sqlDB.SetConnMaxLifetime(time.Hour)


  // 空闲连接最大生命周期
  sqlDB.SetConnMaxIdleTime(30 * time.Minute)


  // 测试数据库连接
  err = sqlDB.Ping()
  if err != nil {
    log.Fatal("数据库 Ping 失败：", err)
  }


  // 自动迁移
  err = DB.AutoMigrate(&User{})
  if err != nil {
    log.Fatal("自动迁移失败：", err)
  }


  log.Println("SQL Server 初始化成功")
}


func main() {


  // 初始化数据库
  InitDB()


  // 初始化 Gin
  r := gin.Default()


  // 测试接口
  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  // 启动服务
  r.Run(":8080")
}

DSN 参数说明#

参数说明
sa数据库用户名
123456数据库密码
127.0.0.1SQL Server 地址
1433SQL Server 默认端口
database数据库名称

Gorm 引入 PostgreSQL#

初始化#

package main


import (
  "log"
  "os"
  "time"


  "github.com/gin-gonic/gin"


  "gorm.io/driver/postgres"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "gorm.io/gorm/schema"
)


// 全局数据库对象
var DB *gorm.DB


// 示例模型
type User struct {
  ID       uint      `gorm:"primaryKey"`
  Username string    `gorm:"size:50;unique;not null"`
  Email    string    `gorm:"size:100;unique;not null"`
  Password string    `gorm:"size:255;not null"`
  Age      int
  CreatedAt time.Time
  UpdatedAt time.Time
}


// 初始化数据库
func InitDB() {


  // PostgreSQL 连接字符串
  dsn := "host=127.0.0.1 user=postgres password=123456 dbname=demo port=5432 sslmode=disable TimeZone=Asia/Shanghai"


  // GORM 配置
  config := &gorm.Config{


    // 跳过默认事务（提高性能）
    SkipDefaultTransaction: true,


    // 开启预编译 SQL
    PrepareStmt: true,


    // 命名策略
    NamingStrategy: schema.NamingStrategy{


      // User -> user
      SingularTable: true,


      // 表名前缀
      TablePrefix: "t_",
    },


    // GORM 日志
    Logger: logger.New(


      log.New(os.Stdout, "\r\n", log.LstdFlags),


      logger.Config{


        // 慢 SQL 阈值
        SlowThreshold: time.Second,


        // 日志级别
        LogLevel: logger.Info,


        // 忽略 RecordNotFound
        IgnoreRecordNotFoundError: true,


        // 彩色输出
        Colorful: true,
      },
    ),
  }


  var err error


  // 建立数据库连接
  DB, err = gorm.Open(postgres.Open(dsn), config)
  if err != nil {
    log.Fatal("数据库连接失败：", err)
  }


  // 获取底层 sql.DB
  sqlDB, err := DB.DB()
  if err != nil {
    log.Fatal(err)
  }


  // 数据库连接池配置
  // 最大空闲连接数
  sqlDB.SetMaxIdleConns(10)


  // 最大打开连接数
  sqlDB.SetMaxOpenConns(100)


  // 连接最大生命周期
  sqlDB.SetConnMaxLifetime(time.Hour)


  // 空闲连接最大生命周期
  sqlDB.SetConnMaxIdleTime(30 * time.Minute)


  // 测试数据库连接
  err = sqlDB.Ping()
  if err != nil {
    log.Fatal("数据库 Ping 失败：", err)
  }


  // 自动迁移
  err = DB.AutoMigrate(&User{})
  if err != nil {
    log.Fatal("自动迁移失败：", err)
  }


  log.Println("PostgreSQL 初始化成功")
}


func main() {


  // 初始化数据库
  InitDB()


  // 初始化 Gin
  r := gin.Default()


  // 测试接口
  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  // 启动服务
  r.Run(":8080")
}

DSN 参数说明#

参数说明
host数据库地址
user用户名
password密码
dbname数据库名称
portPostgreSQL 默认端口（5432）
sslmode是否启用 SSL（开发环境一般使用 disable）
TimeZone数据库时区

Gorm 引入 SQLite#

初始化#

package main


import (
  "log"
  "os"
  "time"


  "github.com/gin-gonic/gin"


  "gorm.io/driver/sqlite"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "gorm.io/gorm/schema"
)


// 全局数据库对象
var DB *gorm.DB


// 示例模型
type User struct {
  ID        uint      `gorm:"primaryKey"`
  Username  string    `gorm:"size:50;unique;not null"`
  Email     string    `gorm:"size:100;unique;not null"`
  Password  string    `gorm:"size:255;not null"`
  Age       int
  CreatedAt time.Time
  UpdatedAt time.Time
}


// 初始化数据库
func InitDB() {


  // SQLite 数据库文件
  dsn := "demo.db"


  // GORM 配置
  config := &gorm.Config{


    // 跳过默认事务（提高性能）
    SkipDefaultTransaction: true,


    // 开启 SQL 预编译
    PrepareStmt: true,


    // 命名策略
    NamingStrategy: schema.NamingStrategy{


      // User -> user
      SingularTable: true,


      // 表名前缀
      TablePrefix: "t_",
    },


    // SQL 日志
    Logger: logger.New(


      log.New(os.Stdout, "\r\n", log.LstdFlags),


      logger.Config{


        // 慢 SQL 阈值
        SlowThreshold: time.Second,


        // 日志级别
        LogLevel: logger.Info,


        // 忽略 RecordNotFound
        IgnoreRecordNotFoundError: true,


        // 彩色输出
        Colorful: true,
      },
    ),
  }


  var err error


  // 建立数据库连接
  DB, err = gorm.Open(sqlite.Open(dsn), config)
  if err != nil {
    log.Fatal("数据库连接失败：", err)
  }


  // 获取底层 sql.DB
  sqlDB, err := DB.DB()
  if err != nil {
    log.Fatal(err)
  }


  // SQLite 连接配置
  // SQLite 一般建议保持较少连接
  sqlDB.SetMaxIdleConns(1)


  sqlDB.SetMaxOpenConns(1)


  sqlDB.SetConnMaxLifetime(time.Hour)


  sqlDB.SetConnMaxIdleTime(30 * time.Minute)


  // 测试数据库连接
  err = sqlDB.Ping()
  if err != nil {
    log.Fatal("数据库 Ping 失败：", err)
  }


  // 自动迁移
  err = DB.AutoMigrate(&User{})
  if err != nil {
    log.Fatal("自动迁移失败：", err)
  }


  log.Println("SQLite 初始化成功")
}


func main() {


  // 初始化数据库
  InitDB()


  // 初始化 Gin
  r := gin.Default()


  // 测试接口
  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  // 启动服务
  r.Run(":8080")
}

DSN 参数说明#

DSN 就是数据库文件路径

dsn := "demo.db"

第三方驱动 gorm-oracle 引入 Oracle#

初始化#

package main


import (
  "log"
  "os"
  "time"


  "github.com/gin-gonic/gin"


  oracle "github.com/godoes/gorm-oracle"


  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "gorm.io/gorm/schema"
)


// 全局数据库对象
var DB *gorm.DB


// 示例模型
type User struct {
  ID        uint      `gorm:"primaryKey"`
  Username  string    `gorm:"size:50;unique;not null"`
  Email     string    `gorm:"size:100;unique;not null"`
  Password  string    `gorm:"size:255;not null"`
  Age       int
  CreatedAt time.Time
  UpdatedAt time.Time
}


// 初始化数据库
func InitDB() {


  // Oracle 连接字符串
  dsn := "oracle://system:123456@127.0.0.1:1521/XEPDB1"


  // GORM 配置
  config := &gorm.Config{


    // 跳过默认事务
    SkipDefaultTransaction: true,


    // 开启 SQL 预编译
    PrepareStmt: true,


    // 命名策略
    NamingStrategy: schema.NamingStrategy{


      // User -> user
      SingularTable: true,


      // 表名前缀
      TablePrefix: "t_",
    },


    // SQL 日志
    Logger: logger.New(


      log.New(os.Stdout, "\r\n", log.LstdFlags),


      logger.Config{


        SlowThreshold: time.Second,


        LogLevel: logger.Info,


        IgnoreRecordNotFoundError: true,


        Colorful: true,
      },
    ),
  }


  var err error


  // 建立数据库连接
  DB, err = gorm.Open(oracle.Open(dsn), config)
  if err != nil {
    log.Fatal("数据库连接失败：", err)
  }


  // 获取底层 sql.DB
  sqlDB, err := DB.DB()
  if err != nil {
    log.Fatal(err)
  }


  // 数据库连接池配置
  // 最大空闲连接数
  sqlDB.SetMaxIdleConns(10)


  // 最大打开连接数
  sqlDB.SetMaxOpenConns(100)


  // 连接最大生命周期
  sqlDB.SetConnMaxLifetime(time.Hour)


  // 空闲连接最大生命周期
  sqlDB.SetConnMaxIdleTime(30 * time.Minute)


  // 检测数据库连接
  err = sqlDB.Ping()
  if err != nil {
    log.Fatal("数据库 Ping 失败：", err)
  }


  // 自动迁移
  err = DB.AutoMigrate(&User{})
  if err != nil {
    log.Fatal("自动迁移失败：", err)
  }


  log.Println("Oracle 初始化成功")
}


func main() {


  // 初始化数据库
  InitDB()


  // 初始化 Gin
  r := gin.Default()


  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  r.Run(":8080")
}

DSN 参数说明#

参数说明
system数据库用户名
123456数据库密码
127.0.0.1Oracle 服务器地址
1521Oracle 默认端口
XEPDB1Oracle 服务名（Service Name）

官方驱动 godror 引入 Oracle#

初始化#

package main


import (
  "database/sql"
  "log"
  "time"


  "github.com/gin-gonic/gin"


  _ "github.com/godror/godror"
)


// 全局数据库对象
var DB *sql.DB


// 初始化数据库
func InitDB() {


  // Oracle DSN
  dsn := `user="system" password="123456" connectString="127.0.0.1:1521/XEPDB1"`


  var err error


  // 建立数据库连接
  DB, err = sql.Open("godror", dsn)
  if err != nil {
    log.Fatal("数据库连接失败：", err)
  }


  // 数据库连接池配置
  // 最大空闲连接数
  DB.SetMaxIdleConns(10)


  // 最大打开连接数
  DB.SetMaxOpenConns(100)


  // 连接最大生命周期
  DB.SetConnMaxLifetime(time.Hour)


  // 空闲连接最大生命周期
  DB.SetConnMaxIdleTime(30 * time.Minute)


  // 测试数据库连接
  err = DB.Ping()
  if err != nil {
    log.Fatal("数据库 Ping 失败：", err)
  }


  log.Println("Oracle 初始化成功")
}


func main() {


  // 初始化数据库
  InitDB()


  // 初始化 Gin
  r := gin.Default()


  // 测试接口
  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  // 启动服务
  r.Run(":8080")
}

DSN 参数说明#

参数说明
userOracle 用户名
passwordOracle 密码
connectString数据库地址 + 端口 + Service Name

官方驱动 clickhouse-go/v2 引入 ClickHouse#

初始化#

package main


import (
  "database/sql"
  "log"
  "time"


  "github.com/ClickHouse/clickhouse-go/v2"
  "github.com/gin-gonic/gin"
)


var DB *sql.DB


// 初始化数据库
func InitDB() {


  var err error


  // 建立数据库连接
  DB = clickhouse.OpenDB(&clickhouse.Options{


    // 支持多个节点，官方驱动会自动进行负载均衡和故障切换
    Addr: []string{
        "192.168.1.10:9000",
        "192.168.1.11:9000",
        "192.168.1.12:9000",
    }


    Auth: clickhouse.Auth{
      Database: "default",
      Username: "default",
      Password: "",
    },


    Settings: clickhouse.Settings{
      "max_execution_time": 60,
    },


    DialTimeout: 5 * time.Second,


    Compression: &clickhouse.Compression{
      Method: clickhouse.CompressionLZ4,
    },
  })


  // 数据库连接池配置
  DB.SetMaxIdleConns(10)


  DB.SetMaxOpenConns(100)


  DB.SetConnMaxLifetime(time.Hour)


  DB.SetConnMaxIdleTime(30 * time.Minute)


  // 测试数据库连接
  err = DB.Ping()
  if err != nil {
    log.Fatal("数据库 Ping 失败：", err)
  }


  log.Println("ClickHouse 初始化成功")
}


func main() {


  InitDB()


  r := gin.Default()


  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  r.Run(":8080")
}

配置说明#

配置说明
AddrClickHouse 服务地址
Database数据库名称
Username用户名
Password密码
Auth用户认证
DialTimeout建立连接超时时间
Compression数据压缩
SettingsSession 参数
TLSTLS 配置
ProtocolTCP / HTTP 协议
Debug是否开启调试日志

官方驱动 mongo-driver 引入 MongoDB#

初始化#

package main


import (
  "context"
  "log"
  "time"


  "github.com/gin-gonic/gin"


  "go.mongodb.org/mongo-driver/v2/mongo"
  "go.mongodb.org/mongo-driver/v2/mongo/options"
)


var (
  Client *mongo.Client
  DB     *mongo.Database
)


// 初始化 MongoDB
func InitMongo() {


  // 创建 Context
  ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
  defer cancel()


  // MongoDB URI
  uri := "mongodb://root:123456@127.0.0.1:27017"


  // 创建 Client 配置
  opts := options.Client().
    ApplyURI(uri).
    SetMaxPoolSize(100).
    SetMinPoolSize(10).
    SetMaxConnIdleTime(30 * time.Minute)


  var err error


  // 建立连接
  Client, err = mongo.Connect(opts)
  if err != nil {
    log.Fatal("MongoDB 连接失败：", err)
  }


  // 测试连接
  err = Client.Ping(ctx, nil)
  if err != nil {
    log.Fatal("MongoDB Ping 失败：", err)
  }


  // 获取数据库
  DB = Client.Database("demo")


  log.Println("MongoDB 初始化成功")
}


func main() {


  InitMongo()


  r := gin.Default()


  r.GET("/ping", func(c *gin.Context) {


    c.JSON(200, gin.H{
      "message": "pong",
    })


  })


  r.Run(":8080")
}

URI 说明#

参数说明
root用户名
123456密码
127.0.0.1MongoDB 地址
27017MongoDB 默认端口
ApplyURI设置连接地址
SetMaxPoolSize最大连接池大小
SetMinPoolSize最小连接池大小
SetMaxConnIdleTime最大空闲连接时间
SetConnectTimeout建立连接超时时间
SetServerSelectionTimeout服务发现超时时间
SetRetryWrites是否开启重试写
SetRetryReads是否开启重试读
数据库引入
https://shirone.mysqil.com/posts/gin/数据库引入/
作者
HikariTish
发布于
2026-07-30
许可协议
CC BY-NC-SA 4.0

分享文章

生成精美分享图或复制链接，与更多人分享本文。

继续阅读

沿着主题读

基于共同的标签与分类

换条路线

从其他文章中稳定抽取

GoLand 调优
CRUD查询