連接數據庫
下面演示如果連接數據庫，使用gorm.Open()方法可以初始化並返回一個gorm.DB結構體，這個結構體封裝了GORM框架所有的數據庫操作方法，下面是gorm.Open()方法的定義：
func Open(dialect string, args ...interface{}) (db *DB, err error)
示例代碼：
package main
import "github.com/jinzhu/gorm"
import _ "github.com/jinzhu/gorm/dialects/mysql"//導入連接MySQL數據庫的驅動包
//DSN
const DSN = "root:123456@tcp(localhost:3306)/test?charset=utf8&parseTime=True&loc=Local"
//指定驅動
const DRIVER = "mysql"
var db *gorm.DB
func init() {
var err error
db,err = gorm.Open(DRIVER,DSN)
if err != nil{
panic(err)
}
}
func main(){
defer db.Close()//退出前執行關閉
//調用db執行具體的邏輯
}
在上面的例子中，我們在init方法中初始化gorm.DB結構體，這樣在下面的例子可以直接使用變量db直接進行數據庫操作。
基本操作
使用gorm.Open()函數返回一個gorm.DB結構體后，我們可以使用gorm.DB結構體提供的方法操作數據庫，下面我們演示如何使用gorm.DB進行創建、查詢、更新、刪除等最基本的操作。
其實gorm.DB是在Go語言的database/sql庫中的sql.DB結構體上再封裝，因為gorm.DB提供許多和sql.DB一樣的方法，如下所示：
func (s *DB) Exec(sql string, values ...interface{}) *DB func (s *DB) Row() *sql.Row func (s *DB) Rows() (*sql.Rows, error) func (s *DB) Scan(dest interface{}) *DB
另外，使用gorm.DB結構體中的DB()方法，可以返回一個sql.DB對象，如下：
func (s *DB) DB() *sql.DB
下面演示的是使用gorm.DB結構體中一些更簡便的方法進行數據庫基本操作，不過，在演示之前，我們需要先定義一個模型，如下:
type User struct { Id int //對應數據表的自增id Username string Password string Email string Phone string }
我們定義了一個名稱為User的結構體，GROM支持將結構體按規則映射為某個數據表的一行，結構體的每個字段表示數據表的列，結構體的字段首字母必須是大寫的。
創建
使用gorm.DB中的Create()方法，GORM會根據傳給Create()方法的模型，向數據表插入一行。
func (s *DB) Create(value interface{}) *DB //創建一行 func (s *DB) NewRecord(value interface{}) bool //根據自增id判斷主鍵是否存在
func main() {
defer db.Close()
//具體的邏輯
u := &User{Username: "test_one", Password: "testOne123456", Email: "test_one@163.com", Phone: "13711112222"}
db.Create(u)
if db.NewRecord(u){
fmt.Println("寫入失敗")
}else{
fmt.Println("寫入成功")
}
查詢
GROM框架在sql/database包的原生基礎上封裝了簡便的方法，可以直接調用便將數據映射到對應的結構體模型中，用起來非常簡單，如下面這幾個方法：
//返回第一條
func (s *DB) First(out interface{}, where ...interface{}) *DB
//返回最后一條
func (s *DB) Last(out interface{}, where ...interface{}) *DB
//返回符合條件的內容
func (s *DB) Find(out interface{}, where ...interface{}) *DB
//返回Count(*)結果
func (s *DB) Count(value interface{}) *DB
復制代碼
示例代碼
//Find方法示例
func find() {
var users = make([]*User, 0)
db.Model(&User2{}).Find(&users)
fmt.Println(users)
}
//First方法示例
func first() {
var user1,user2 User
db.First(&user1)
fmt.Println(user1)
db.First(&user2,"id = ?",20)
fmt.Println(user2)
}
//Last方法示例
func last() {
var user1,user2 User
db.Last(&user1)
fmt.Println(user1)
db.First(&user2,"id = ?",19)
fmt.Println(user2)
}
//Count方法示例
func count() {
var count int
db.Model(&User{}).Count(&count)
fmt.Println(count)
}
更新
更新數據可以使用gorm.DB的Save()或Update(),UpdateColumn(),UpdateColumns(),Updates()等方法，后面這四個方法需要與Model()方法一起使用。
func (s *DB) Save(value interface{}) *DB
func (s *DB) Model(value interface{}) *DB
//下面的方法需要與Model方法一起使用，通過Model方法指定更新數據的條件
func (s *DB) Update(attrs ...interface{}) *DB
func (s *DB) UpdateColumn(attrs ...interface{}) *DB
func (s *DB) UpdateColumns(values interface{}) *DB
func (s *DB) Updates(values interface{}, ignoreProtectedAttrs ...bool) *DB
代碼示例
//Save()方法示例
func save(){
u := &User{}
db.First(u)
u.Email = "test@163.com"
db.Save(u)
fmt.Println(u)
}
//Update方法示例
func update() {
u := &User{}
db.First(u)
db.Model(u).Update("username", "hello")
}
//Updates方法示例
func updates() {
u := &User{}
db.First(u)
db.Model(&u).Updates(map[string]interface{}{"username": "hello2"})
}
刪除
使用gorm.DB的Delete()方法可以很簡單地刪除滿足條件的記錄，下面是Delete()方法的定義：
//value如果有主鍵id，則包含在判斷條件內，通過where可以指定其他條件
func (s *DB) Delete(value interface{}, where ...interface{}) *DB
示例代碼
func delete(){
defer db.Close()
u := &User{Id: 16}
db.Delete(u)//根據id
db.Delete(&User{},"username = ? ","test_one")//根據額外條件刪除
}
綜合使用
創建 main.go
go get github.com/go-sql-driver/mysql go get github.com/jinzhu/gorm
代碼
package main
import (
_ "github.com/go-sql-driver/mysql"//加載mysql
"github.com/jinzhu/gorm"//gorm 擴展包
"fmt"
)
//注意如果 定義成小寫username 引用時 無法調用
type User struct {
ID int64 // 列名為 `id`
Username string // 列名為 `username`
Password string // 列名為 `password`
}
//設置表名
func (User) TableName() string {
return "users"
}
func main() {
db, err := gorm.Open("mysql", "數據庫用戶名:數據庫密碼@tcp(ip地址:端口號)/數據庫名? charset=utf8&parseTime=True&loc=Local&timeout=10ms")
defer db.Close()
if err != nil {
fmt.Printf("mysql connect error %v", err)
}
//執行遷移文件 生成數據表：如果數據庫表已經存在，可以不做這一步
db.CreateTable(&User{})
//添加數據
user := User{Username: "root", Password: "root"}
result := db.Create(&user)
if result.Error != nil {
fmt.Printf("insert row err %v", result.Error)
return
}
fmt.Println(user.ID) //返回id
//查詢單條數據
getUser := User{}
//SELECT id, first FROM users WHERE id = 1 LIMIT 1;
db.Select([]string{"id", "username"}).First(&getUser, 1)
fmt.Println(getUser) //打印查詢數據
//修改數據
user.Username = "update username"
user.Password = "update password"
db.Save(&user)
//查詢列表數據
users := []User{}
db.Find(&users)
fmt.Println(&users)//獲取所有數據
//刪除數據
db.Delete(&user)
}
執行
go run main.go
gin+gorm+router 快速搭建 crud restful API 接口
├──api │ ├── apis │ │ └── user.go │ ├── database │ │ └── mysql.go │ ├── models │ │ └── user.go │ └── router │ └── router.go └──main.go
apis/apis/user.go
package apis import ( "github.com/gin-gonic/gin" model "api/models" "net/http" "strconv" ) //列表數據 func Users(c *gin.Context) { var user model.User user.Username = c.Request.FormValue("username") user.Password = c.Request.FormValue("password") result, err := user.Users() if err != nil { c.JSON(http.StatusOK, gin.H{ "code": -1, "message": "抱歉未找到相關信息", }) return } c.JSON(http.StatusOK, gin.H{ "code": 1, "data": result, }) } //添加數據 func Store(c *gin.Context) { var user model.User user.Username = c.Request.FormValue("username") user.Password = c.Request.FormValue("password") id, err := user.Insert() if err != nil { c.JSON(http.StatusOK, gin.H{ "code": -1, "message": "添加失敗", }) return } c.JSON(http.StatusOK, gin.H{ "code": 1, "message": "添加成功", "data": id, }) } //修改數據 func Update(c *gin.Context) { var user model.User id, err := strconv.ParseInt(c.Param("id"), 10, 64) user.Password = c.Request.FormValue("password") result, err := user.Update(id) if err != nil || result.ID == 0 { c.JSON(http.StatusOK, gin.H{ "code": -1, "message": "修改失敗", }) return } c.JSON(http.StatusOK, gin.H{ "code": 1, "message": "修改成功", }) } //刪除數據 func Destroy(c *gin.Context) { var user model.User id, err := strconv.ParseInt(c.Param("id"), 10, 64) result, err := user.Destroy(id) if err != nil || result.ID == 0 { c.JSON(http.StatusOK, gin.H{ "code": -1, "message": "刪除失敗", }) return } c.JSON(http.StatusOK, gin.H{ "code": 1, "message": "刪除成功", }) }
database/mysql.go
package database
import (
_ "github.com/go-sql-driver/mysql" //加載mysql
"github.com/jinzhu/gorm"
"fmt"
)
var Eloquent *gorm.DB
func init() {
var err error
Eloquent, err = gorm.Open("mysql", "root:root@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local&timeout=10ms")
if err != nil {
fmt.Printf("mysql connect error %v", err)
}
if Eloquent.Error != nil {
fmt.Printf("database error %v", Eloquent.Error)
}
}
models/user.go
package models
import (
orm "api/database"
)
type User struct {
ID int64 `json:"id"` // 列名為 `id`
Username string `json:"username"` // 列名為 `username`
Password string `json:"password"` // 列名為 `password`
}
var Users []User
//添加
func (user User) Insert() (id int64, err error) {
//添加數據
result := orm.Eloquent.Create(&user)
id =user.ID
if result.Error != nil {
err = result.Error
return
}
return
}
//列表
func (user *User) Users() (users []User, err error) {
if err = orm.Eloquent.Find(&users).Error; err != nil {
return
}
return
}
//修改
func (user *User) Update(id int64) (updateUser User, err error) {
if err = orm.Eloquent.Select([]string{"id", "username"}).First(&updateUser, id).Error; err != nil {
return
}
//參數1:是要修改的數據
//參數2:是修改的數據
if err = orm.Eloquent.Model(&updateUser).Updates(&user).Error; err != nil {
return
}
return
}
//刪除數據
func (user *User) Destroy(id int64) (Result User, err error) {
if err = orm.Eloquent.Select([]string{"id"}).First(&user, id).Error; err != nil {
return
}
if err = orm.Eloquent.Delete(&user).Error; err != nil {
return
}
Result = *user
return
}
router/router.go
package router
import (
"github.com/gin-gonic/gin"
. "api/apis"
)
func InitRouter() *gin.Engine {
router := gin.Default()
router.GET("/users", Users)
router.POST("/user", Store)
router.PUT("/user/:id", Update)
router.DELETE("/user/:id", Destroy)
return router
}
main.go
package main
import (
_ "api/database"
"api/router"
orm "api/database"
)
func main() {
defer orm.Eloquent.Close()
router := router.InitRouter()
router.Run(":8000")
}
執行 go run main.go
訪問地址
POST localhost:8006/user 添加 GET localhost:8006/users 列表 DELETE localhost:8006/user/id 刪除 PUT localhost:8006/user/id 修改
原文作者：yourself
轉自鏈接：https://learnku.com/articles/23548/gingormrouter-quickly-build-crud-restful-api-interface