Go框架三件套Gorm Kitex Hertz基本用法與常見API講解

2023-02-06 06:01:23

三件套介紹

Gorm、Kitex、Hertz的基本用法與常見的API講解

Gorm

gorm是Golang語言中一個已經迭代數十年且功能強大、效能極好的ORM框架

ORM：Object Relational Mapping(物件關係對映)，其主要作用是在程式設計中，把物件導向的概念跟資料庫中表的概念對應起來，

簡單來說，在golang中，自定義的一個結構體對應著一張表，結構體的範例則對應著表中的一條記錄。

Kitex

Kitex是位元組內部Golang微服務RPC框架具有高效能、強可延伸的主要特點支援多協定並且擁有豐富的開源擴充套件

Hertz

Hertz是位元組內部的Http框架參考了其他開源框架的優勢結合位元組跳動內部的需求具有高可用、高效能、高擴充套件性的特點

三件套使用

Gorm

該部分筆記主要參考：gorm.io/zh_CN/docs

宣告模型

模型定義

模型是標準的 struct，由 Go 的基本資料型別、實現了 Scanner 和 Valuer 介面的自定義型別及其指標或別名組成

type User struct {
  ID           uint
  Name         string
  Email        *string
  Age          uint8
  Birthday     *time.Time
  MemberNumber sql.NullString
  ActivatedAt  sql.NullTime
  CreatedAt    time.Time
  UpdatedAt    time.Time
}

約定

GORM 傾向於約定優於設定

預設情況下，GORM 使用 ID 作為主鍵，使用結構體名的 蛇形複數 作為表名，欄位名的 蛇形 作為列名，並使用 CreatedAt、UpdatedAt 欄位追蹤建立、更新時間

gorm.Model

GORM 定義一個 gorm.Model 結構體，其包括欄位 ID、CreatedAt、UpdatedAt、DeletedAt

// gorm.Model 的定義
type Model struct {
  ID        uint           `gorm:"primaryKey"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt gorm.DeletedAt `gorm:"index"`
}

還可以將它嵌入到結構體中，以包含這幾個欄位，例如：

type User struct {
  gorm.Model
  Name string
}
// 等效於
type User struct {
  ID        uint           `gorm:"primaryKey"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt gorm.DeletedAt `gorm:"index"`
  Name string
}

連線到資料庫

GORM 官方支援的資料庫型別有： MySQL, PostgreSQL, SQlite, SQL Server

MySQL

import (
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
)
func main() {
  // 參考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 獲取詳情
  dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
}

注意： 想要正確的處理 time.Time ，您需要帶上 parseTime 引數，要支援完整的 UTF-8 編碼，您需要將 charset=utf8 更改為 charset=utf8mb4

使用現有資料庫連線

GORM 允許通過一個現有的資料庫連線來初始化 *gorm.DB

import (
  "database/sql"
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
)
sqlDB, err := sql.Open("mysql", "mydb_dsn")
gormDB, err := gorm.Open(mysql.New(mysql.Config{
  Conn: sqlDB,
}), &gorm.Config{})

CRUD介面

建立記錄

user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}
result := db.Create(&amp;user) // 通過資料的指標來建立
user.ID &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // 返回插入資料的主鍵
result.Error &nbsp; &nbsp; &nbsp; &nbsp;// 返回 error
result.RowsAffected // 返回插入記錄的條數

批次插入

將切片資料傳遞給 Create 方法，GORM 將生成一個單一的 SQL 語句來插入所有資料，並回填主鍵的值，勾點方法也會被呼叫。

var users = []User{{Name: "jinzhu1"}, {Name: "jinzhu2"}, {Name: "jinzhu3"}}
DB.Create(&amp;users)
for _, user := range users {
 &nbsp;user.ID // 1,2,3
}

通過Map資料型別建立記錄

GORM 支援根據 map[string]interface{} 和 []map[string]interface{}{} 建立記錄

DB.Model(&amp;User{}).Create(map[string]interface{}{
 &nbsp;"Name": "jinzhu", "Age": 18,
})
// 根據 `[]map[string]interface{}{}` 批次插入
DB.Model(&amp;User{}).Create([]map[string]interface{}{
  {"Name": "jinzhu_1", "Age": 18},
  {"Name": "jinzhu_2", "Age": 20},
})

查詢

檢索單個物件

GORM 提供了 First、Take、Last 方法，以便從資料庫中檢索單個物件。當查詢資料庫時它新增了 LIMIT 1 條件，且沒有找到記錄時，它會返回 ErrRecordNotFound 錯誤

// 獲取第一條記錄（主鍵升序）
db.First(&amp;user)
// SELECT * FROM users ORDER BY id LIMIT 1;
// 獲取一條記錄，沒有指定排序欄位
db.Take(&amp;user)
// SELECT * FROM users LIMIT 1;
// 獲取最後一條記錄（主鍵降序）
db.Last(&amp;user)
// SELECT * FROM users ORDER BY id DESC LIMIT 1;
result := db.First(&amp;user)
result.RowsAffected // 返回找到的記錄數
result.Error &nbsp; &nbsp; &nbsp; &nbsp;// returns error
// 檢查 ErrRecordNotFound 錯誤
errors.Is(result.Error, gorm.ErrRecordNotFound)

First、Last 方法會根據主鍵查詢到第一個、最後一個記錄，它僅在通過 struct 或提供 model 值進行查詢時才起作用。如果 model 型別沒有定義主鍵，則按第一個欄位排序

var user User
// 可以
DB.First(&amp;user)
// SELECT * FROM `users` ORDER BY `users`.`id` LIMIT 1
// 可以
result := map[string]interface{}{}
DB.Model(&amp;User{}).First(&amp;result)
// SELECT * FROM `users` ORDER BY `users`.`id` LIMIT 1
// 不行
result := map[string]interface{}{}
DB.Table("users").First(&amp;result)
// 但可以配合 Take 使用
result := map[string]interface{}{}
DB.Table("users").Take(&amp;result)
// 根據第一個欄位排序
type Language struct {
 &nbsp;Code string
 &nbsp;Name string
}
DB.First(&amp;Language{})
// SELECT * FROM `languages` ORDER BY `languages`.`code` LIMIT 1

檢索物件

// 獲取全部記錄
result := db.Find(&amp;users)
// SELECT * FROM users;
result.RowsAffected // 返回找到的記錄數，相當於 `len(users)`
result.Error &nbsp; &nbsp; &nbsp; &nbsp;// returns error

條件查詢

String條件

// 獲取第一條匹配的記錄
db.Where("name = ?", "jinzhu").First(&amp;user)
// SELECT * FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;
// 獲取全部匹配的記錄
db.Where("name &lt;&gt; ?", "jinzhu").Find(&amp;users)
// SELECT * FROM users WHERE name &lt;&gt; 'jinzhu';
// IN
db.Where("name IN ?", []string{"jinzhu", "jinzhu 2"}).Find(&amp;users)
// SELECT * FROM users WHERE name IN ('jinzhu','jinzhu 2');
// LIKE
db.Where("name LIKE ?", "%jin%").Find(&amp;users)
// SELECT * FROM users WHERE name LIKE '%jin%';
// AND
db.Where("name = ? AND age &gt;= ?", "jinzhu", "22").Find(&amp;users)
// SELECT * FROM users WHERE name = 'jinzhu' AND age &gt;= 22;
// Time
db.Where("updated_at &gt; ?", lastWeek).Find(&amp;users)
// SELECT * FROM users WHERE updated_at &gt; '2000-01-01 00:00:00';
// BETWEEN
db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&amp;users)
// SELECT * FROM users WHERE created_at BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

Struct & Map 條件

// Struct
db.Where(&amp;User{Name: "jinzhu", Age: 20}).First(&amp;user)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20 ORDER BY id LIMIT 1;
// Map
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&amp;users)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20;
// 主鍵切片條件
db.Where([]int64{20, 21, 22}).Find(&amp;users)
// SELECT * FROM users WHERE id IN (20, 21, 22);

注意當使用結構作為條件查詢時，GORM 只會查詢非零值欄位。這意味著如果您的欄位值為 0、''、false 或其他零值，該欄位不會被用於構建查詢條件

Not 條件

構建NOT條件，用法與 Where 類似

db.Not("name = ?", "jinzhu").First(&amp;user)
// SELECT * FROM users WHERE NOT name = "jinzhu" ORDER BY id LIMIT 1;
// Not In
db.Not(map[string]interface{}{"name": []string{"jinzhu", "jinzhu 2"}}).Find(&amp;users)
// SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");
// Struct
db.Not(User{Name: "jinzhu", Age: 18}).First(&amp;user)
// SELECT * FROM users WHERE name &lt;&gt; "jinzhu" AND age &lt;&gt; 18 ORDER BY id LIMIT 1;
// 不在主鍵切片中的記錄
db.Not([]int64{1,2,3}).First(&amp;user)
// SELECT * FROM users WHERE id NOT IN (1,2,3) ORDER BY id LIMIT 1;

Or條件

db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&amp;users)
// SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';
// Struct
db.Where("name = 'jinzhu'").Or(User{Name: "jinzhu 2", Age: 18}).Find(&amp;users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);
// Map
db.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2", "age": 18}).Find(&amp;users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);

選擇特定欄位

選擇想從資料庫中檢索的欄位，預設情況下會選擇全部欄位

db.Select("name", "age").Find(&amp;users)
// SELECT name, age FROM users;
db.Select([]string{"name", "age"}).Find(&amp;users)
// SELECT name, age FROM users;
db.Table("users").Select("COALESCE(age,?)", 42).Rows()
// SELECT COALESCE(age,'42') FROM users;

Order查詢

指定從資料庫檢索記錄時的排序方式

db.Order("age desc, name").Find(&amp;users)
// SELECT * FROM users ORDER BY age desc, name;
// Multiple orders
db.Order("age desc").Order("name").Find(&amp;users)
// SELECT * FROM users ORDER BY age desc, name;

Limit & Offset查詢

Limit 指定獲取記錄的最大數量 Offset 指定在開始返回記錄之前要跳過的記錄數量

db.Limit(3).Find(&users)
// SELECT * FROM users LIMIT 3;
// 通過 -1 消除 Limit 條件
db.Limit(10).Find(&users1).Limit(-1).Find(&users2)
// SELECT * FROM users LIMIT 10; (users1)
// SELECT * FROM users; (users2)
db.Offset(3).Find(&users)
// SELECT * FROM users OFFSET 3;
db.Limit(10).Offset(5).Find(&users)
// SELECT * FROM users OFFSET 5 LIMIT 10;
// 通過 -1 消除 Offset 條件
db.Offset(10).Find(&users1).Offset(-1).Find(&users2)
// SELECT * FROM users OFFSET 10; (users1)
// SELECT * FROM users; (users2)

Group & Having查詢

type result struct {
  Date  time.Time
  Total int
}
db.Model(&User{}).Select("name, sum(age) as total").Where("name LIKE ?", "group%").Group("name").First(&result)
// SELECT name, sum(age) as total FROM `users` WHERE name LIKE "group%" GROUP BY `name`
db.Model(&User{}).Select("name, sum(age) as total").Group("name").Having("name = ?", "group").Find(&result)
// SELECT name, sum(age) as total FROM `users` GROUP BY `name` HAVING name = "group"
rows, err := db.Table("orders").Select("date(created_at) as date, sum(amount) as total").Group("date(created_at)").Rows()
for rows.Next() {
  ...
}
rows, err := db.Table("orders").Select("date(created_at) as date, sum(amount) as total").Group("date(created_at)").Having("sum(amount) > ?", 100).Rows()
for rows.Next() {
  ...
}
type Result struct {
  Date  time.Time
  Total int64
}
db.Table("orders").Select("date(created_at) as date, sum(amount) as total").Group("date(created_at)").Having("sum(amount) > ?", 100).Scan(&results)

Distinct查詢

從模型中選擇不相同的值

db.Distinct("name", "age").Order("name, age desc").Find(&results)

高階查詢

智慧選擇欄位

GORM 允許通過 Select 方法選擇特定的欄位，如果您在應用程式中經常使用此功能，你也可以定義一個較小的結構體，以實現呼叫 API 時自動選擇特定的欄位

type User struct {
  ID     uint
  Name   string
  Age    int
  Gender string
  // 假設後面還有幾百個欄位...
}
type APIUser struct {
  ID   uint
  Name string
}
// 查詢時會自動選擇 `id`, `name` 欄位
db.Model(&User{}).Limit(10).Find(&APIUser{})
// SELECT `id`, `name` FROM `users` LIMIT 10

子查詢

子查詢可以巢狀在查詢中，GORM 允許在使用 *gorm.DB 物件作為引數時生成子查詢

db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)
// SELECT * FROM "orders" WHERE amount > (SELECT AVG(amount) FROM "orders");
subQuery := db.Select("AVG(age)").Where("name LIKE ?", "name%").Table("users")
db.Select("AVG(age) as avgage").Group("name").Having("AVG(age) > (?)", subQuery).Find(&results)
// SELECT AVG(age) as avgage FROM `users` GROUP BY `name` HAVING AVG(age) > (SELECT AVG(age) FROM `users` WHERE name LIKE "name%")

From子查詢

GORM 允許您在 Table 方法中通過 FROM 子句使用子查詢

db.Table("(?) as u", db.Model(&User{}).Select("name", "age")).Where("age = ?", 18).Find(&User{})
// SELECT * FROM (SELECT `name`,`age` FROM `users`) as u WHERE `age` = 18
subQuery1 := db.Model(&User{}).Select("name")
subQuery2 := db.Model(&Pet{}).Select("name")
db.Table("(?) as u, (?) as p", subQuery1, subQuery2).Find(&User{})
// SELECT * FROM (SELECT `name` FROM `users`) as u, (SELECT `name` FROM `pets`) as p

Group條件

使用 Group 條件可以更輕鬆的編寫複雜 SQL

db.Where(
    db.Where("pizza = ?", "pepperoni").Where(db.Where("size = ?", "small").Or("size = ?", "medium")),
).Or(
    db.Where("pizza = ?", "hawaiian").Where("size = ?", "xlarge"),
).Find(&Pizza{}).Statement
// SELECT * FROM `pizzas` WHERE (pizza = "pepperoni" AND (size = "small" OR size = "medium")) OR (pizza = "hawaiian" AND size = "xlarge")

更新

儲存所有欄位

Save 會儲存所有的欄位，即使欄位是零值

db.First(&user)
user.Name = "jinzhu 2"
user.Age = 100
db.Save(&user)
// UPDATE users SET name='jinzhu 2', age=100, birthday='2016-01-01', updated_at = '2013-11-17 21:34:10' WHERE id=111;

更新單個列

當使用 Update 更新單列時，需要有一些條件，否則將會引起錯誤 ErrMissingWhereClause 。當使用 Model 方法，並且值中有主鍵值時，主鍵將會被用於構建條件

// 條件更新
db.Model(&User{}).Where("active = ?", true).Update("name", "hello")
// UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE active=true;
// User 的 ID 是 `111`
db.Model(&user).Update("name", "hello")
// UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;
// 根據條件和 model 的值進行更新
db.Model(&user).Where("active = ?", true).Update("name", "hello")
// UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111 AND active=true;

更新多列

Updates 方法支援 struct 和 map[string]interface{} 引數。當使用 struct 更新時，預設情況下，GORM 只會更新非零值的欄位

// 根據 `struct` 更新屬性，只會更新非零值的欄位
db.Model(&user).Updates(User{Name: "hello", Age: 18, Active: false})
// UPDATE users SET name='hello', age=18, updated_at = '2013-11-17 21:34:10' WHERE id = 111;
// 根據 `map` 更新屬性
db.Model(&user).Updates(map[string]interface{}{"name": "hello", "age": 18, "active": false})
// UPDATE users SET name='hello', age=18, active=false, updated_at='2013-11-17 21:34:10' WHERE id=111;

更新選定欄位

如果想要在更新時選定、忽略某些欄位，您可以使用 Select、Omit

// Select with Map
// User's ID is `111`:
db.Model(&user).Select("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "active": false})
// UPDATE users SET name='hello' WHERE id=111;
db.Model(&user).Omit("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "active": false})
// UPDATE users SET age=18, active=false, updated_at='2013-11-17 21:34:10' WHERE id=111;
// Select with Struct (select zero value fields)
db.Model(&user).Select("Name", "Age").Updates(User{Name: "new_name", Age: 0})
// UPDATE users SET name='new_name', age=0 WHERE id=111;
// Select all fields (select all fields include zero value fields)
db.Model(&user).Select("*").Updates(User{Name: "jinzhu", Role: "admin", Age: 0})
// Select all fields but omit Role (select all fields include zero value fields)
db.Model(&user).Select("*").Omit("Role").Updates(User{Name: "jinzhu", Role: "admin", Age: 0})

批次更新

如果尚未通過 Model 指定記錄的主鍵，則 GORM 會執行批次更新

// 根據 struct 更新
db.Model(User{}).Where("role = ?", "admin").Updates(User{Name: "hello", Age: 18})
// UPDATE users SET name='hello', age=18 WHERE role = 'admin';
// 根據 map 更新
db.Table("users").Where("id IN ?", []int{10, 11}).Updates(map[string]interface{}{"name": "hello", "age": 18})
// UPDATE users SET name='hello', age=18 WHERE id IN (10, 11);

獲取更新的記錄數

// 通過 `RowsAffected` 得到更新的記錄數
result := db.Model(User{}).Where("role = ?", "admin").Updates(User{Name: "hello", Age: 18})
// UPDATE users SET name='hello', age=18 WHERE role = 'admin';
result.RowsAffected // 更新的記錄數
result.Error        // 更新的錯誤

刪除

刪除一條記錄

刪除一條記錄時，刪除物件需要指定主鍵，否則會觸發批次 Delete

// Email 的 ID 是 `10`
db.Delete(&email)
// DELETE from emails where id = 10;
// 帶額外條件的刪除
db.Where("name = ?", "jinzhu").Delete(&email)
// DELETE from emails where id = 10 AND name = "jinzhu";

根據主鍵刪除

GORM 允許通過主鍵(可以是複合主鍵)和內聯條件來刪除物件，它可以使用數位（如以下例子。也可以使用字串——譯者注）

db.Delete(&User{}, 10)
// DELETE FROM users WHERE id = 10;
db.Delete(&User{}, "10")
// DELETE FROM users WHERE id = 10;
db.Delete(&users, []int{1,2,3})
// DELETE FROM users WHERE id IN (1,2,3);

批次刪除

如果指定的值不包括主屬性，那麼 GORM 會執行批次刪除，它將刪除所有匹配的記錄

db.Where("email LIKE ?", "%jinzhu%").Delete(&Email{})
// DELETE from emails where email LIKE "%jinzhu%";
db.Delete(&Email{}, "email LIKE ?", "%jinzhu%")
// DELETE from emails where email LIKE "%jinzhu%";

返回刪除行的資料

// 返回所有列
var users []User
DB.Clauses(clause.Returning{}).Where("role = ?", "admin").Delete(&users)
// DELETE FROM `users` WHERE role = "admin" RETURNING *
// users => []User{{ID: 1, Name: "jinzhu", Role: "admin", Salary: 100}, {ID: 2, Name: "jinzhu.2", Role: "admin", Salary: 1000}}
// 返回指定的列
DB.Clauses(clause.Returning{Columns: []clause.Column{{Name: "name"}, {Name: "salary"}}}).Where("role = ?", "admin").Delete(&users)
// DELETE FROM `users` WHERE role = "admin" RETURNING `name`, `salary`
// users => []User{{ID: 0, Name: "jinzhu", Role: "", Salary: 100}, {ID: 0, Name: "jinzhu.2", Role: "", Salary: 1000}}

軟刪除

如果模型包含了一個 gorm.deletedat 欄位（gorm.Model 已經包含了該欄位)，它將自動獲得軟刪除的能力！

擁有軟刪除能力的模型呼叫 Delete 時，記錄不會從資料庫中被真正刪除。但 GORM 會將 DeletedAt 置為當前時間，並且你不能再通過普通的查詢方法找到該記錄。

// user 的 ID 是 `111`
db.Delete(&user)
// UPDATE users SET deleted_at="2013-10-29 10:23" WHERE id = 111;
// 批次刪除
db.Where("age = ?", 20).Delete(&User{})
// UPDATE users SET deleted_at="2013-10-29 10:23" WHERE age = 20;
// 在查詢時會忽略被軟刪除的記錄
db.Where("age = 20").Find(&user)
// SELECT * FROM users WHERE age = 20 AND deleted_at IS NULL;

查詢被軟刪除的記錄

可以使用 Unscoped 找到被軟刪除的記錄

db.Unscoped().Where("age = 20").Find(&users)
// SELECT * FROM users WHERE age = 20;

事務

禁用預設事務

為了確保資料一致性，GORM 會在事務裡執行寫入操作（建立、更新、刪除）。如果沒有這方面的要求，可以在初始化時禁用它，這將獲得大約 30%+ 效能提升。

// 全域性禁用
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{
  SkipDefaultTransaction: true,
})
// 持續對談模式
tx := db.Session(&Session{SkipDefaultTransaction: true})
tx.First(&user, 1)
tx.Find(&users)
tx.Model(&user).Update("Age", 18)

事務開啟

要在事務中執行一系列操作，一般流程如下

db.Transaction(func(tx *gorm.DB) error {
  // 在事務中執行一些 db 操作（從這裡開始，您應該使用 'tx' 而不是 'db'）
  if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
    // 返回任何錯誤都會回滾事務
    return err
  }
  if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
    return err
  }
  // 返回 nil 提交事務
  return nil
})

巢狀事務

GORM 支援巢狀事務，您可以回滾較大事務內執行的一部分操作

db.Transaction(func(tx *gorm.DB) error {
  tx.Create(&user1)
  tx.Transaction(func(tx2 *gorm.DB) error {
    tx2.Create(&user2)
    return errors.New("rollback user2") // Rollback user2
  })
  tx.Transaction(func(tx2 *gorm.DB) error {
    tx2.Create(&user3)
    return nil
  })
  return nil
})

手動事務

Gorm 支援直接呼叫事務控制方法（commit、rollback）

// 開始事務
tx := db.Begin()
// 在事務中執行一些 db 操作（從這裡開始，您應該使用 'tx' 而不是 'db'）
tx.Create(...)
// ...
// 遇到錯誤時回滾事務
tx.Rollback()
// 否則，提交事務
tx.Commit()

Gorm效能提高

使用PrepareStmt快取預編譯語句可以提高後續呼叫的速度，提高大約35%左右。

db , err := gorm.Open(mysql.Open("username:password@tcp(localhost:9910)/database?charset=utf8"),&gorm.Config{
                          PrepareStmt: true}

Kitex

安裝

Kitex目前對Windows的支援不完善，建議使用虛擬機器器或WSL2

安裝程式碼生成工具

go install github.com/cloudwego/tool/cmd/kitex@latest
go install github.com/cloudwego/thriftgo@latest

使用

kitex 是 Kitex 框架提供的用於生成程式碼的一個命令列工具。目前，kitex 支援 thrift 和 protobuf 的 IDL，並支援生成一個伺服器端專案的骨架。

編寫IDL

IDL是什麼：IDL 全稱是 Interface Definition Language，介面定義語言

為什麼使用IDL：要進行 RPC，就需要知道對方的介面是什麼，需要傳什麼引數，同時也需要知道返回值是什麼樣的，就好比兩個人之間交流，需要保證在說的是同一個語言、同一件事。這時候，就需要通過 IDL 來約定雙方的協定，就像在寫程式碼的時候需要呼叫某個函數，我們需要知道函數簽名一樣。

首先我們需要編寫一個 IDL，這裡以 thrift IDL 為例。

首先建立一個名為 echo.thrift 的 thrift IDL 檔案。

然後在裡面定義我們的服務

namespace go api
struct Request {
  1: string message
}
struct Response {
  1: string message
}
service Echo {
    Response echo(1: Request req)
}

生成echo服務程式碼

有了 IDL 以後我們便可以通過 kitex 工具生成專案程式碼了，執行如下命令：

$ kitex -module example -service example echo.thrift

上述命令中，-module 表示生成的該專案的 go module 名，-service 表明我們要生成一個伺服器端專案，後面緊跟的 example 為該服務的名字。最後一個引數則為該服務的 IDL 檔案。

生成後的專案結構如下：

.
|-- build.sh
|-- echo.thrift
|-- handler.go
|-- kitex_gen
|   `-- api
|       |-- echo
|       |   |-- client.go
|       |   |-- echo.go
|       |   |-- invoker.go
|       |   `-- server.go
|       |-- echo.go
|       `-- k-echo.go
|-- main.go
`-- script
    |-- bootstrap.sh
    `-- settings.py

編寫echo服務邏輯

需要編寫的伺服器端邏輯都在 handler.go 這個檔案中

package main
import (
  "context"
  "example/kitex_gen/api"
)
// EchoImpl implements the last service interface defined in the IDL.
type EchoImpl struct{}
// Echo implements the EchoImpl interface.
func (s *EchoImpl) Echo(ctx context.Context, req *api.Request) (resp *api.Response, err error) {
  // TODO: Your code here...
  return
}

這裡的 Echo 函數就對應了我們之前在 IDL 中定義的 echo 方法。

現在讓我們修改一下伺服器端邏輯，讓 Echo 服務起到作用。

func (s *EchoImpl) Echo(ctx context.Context, req *api.Request) (resp *api.Response, err error) {
  return &api.Response{Message: req.Message}, nil
}

編譯執行

kitex 工具已經幫我們生成好了編譯和執行所需的指令碼：

編譯：

$ sh build.sh

執行上述命令後，會生成一個 output 目錄，裡面含有我們的編譯產物。

執行：

$ sh output/bootstrap.sh

執行上述命令後，Echo 服務就開始執行了。

編寫使用者端

有了伺服器端後，接下來就編寫一個使用者端用於呼叫剛剛執行起來的伺服器端。

首先，同樣的，先建立一個目錄用於存放我們的使用者端程式碼：

$ mkdir client

進入目錄：

$ cd client

建立一個 main.go 檔案，然後就開始編寫使用者端程式碼了。

首先讓我們建立一個呼叫所需的 client：

import "example/kitex_gen/api/echo"
import "github.com/cloudwego/kitex/client"
...
c, err := echo.NewClient("example", client.WithHostPorts("0.0.0.0:8888"))
if err != nil {
  log.Fatal(err)
}

上述程式碼中，echo.NewClient 用於建立 client，其第一個引數為呼叫的服務名（用於微服務中的服務發現），第二個引數為 options，用於傳入引數，此處的 client.WithHostPorts 用於指定伺服器端的地址。

發起呼叫

import "example/kitex_gen/api"
...
req := &api.Request{Message: "my request"}
resp, err := c.Echo(context.Background(), req, callopt.WithRPCTimeout(3*time.Second))
if err != nil {
  log.Fatal(err)
}
log.Println(resp)

上述程式碼中，我們首先建立了一個請求 req , 然後通過 c.Echo 發起了呼叫。

其第一個引數為 context.Context，通過通常用其傳遞資訊或者控制本次呼叫的一些行為，你可以在後續章節中找到如何使用它。

其第二個引數為本次呼叫的請求。

其第三個引數為本次呼叫的 options ，Kitex 提供了一種 callopt 機制，顧名思義——呼叫引數，有別於建立 client 時傳入的引數，這裡傳入的引數僅對此次生效。此處的 callopt.WithRPCTimeout 用於指定此次呼叫的超時（通常不需要指定，此處僅作演示之用）。

在編寫完一個簡單的使用者端後，我們終於可以發起呼叫了。

可以通過下述命令來完成這一步驟：

$ go run main.go

如果不出意外，可以看到類似如下輸出：

2023/01/26 07:23:35 Response({Message:my request})

至此成功編寫了一個 Kitex 的伺服器端和使用者端，並完成了一次呼叫！

Hertz

安裝命令列工具hz

首先，我們需要安裝使用demo所需要的命令列工具 hz：

確保 GOPATH 環境變數已經被正確地定義（例如 export GOPATH=~/go）並且將$GOPATH/bin新增到 PATH 環境變數之中(例如 export PATH=$GOPATH/bin:$PATH)；請勿將 GOPATH 設定為當前使用者沒有讀寫許可權的目錄

安裝 hz：go install github.com/cloudwego/hertz/cmd/hz@latest

確定程式碼放置位置

若將程式碼放置於$GOPATH/src下，需在$GOPATH/src下建立額外目錄，進入該目錄後再獲取程式碼：

  $ mkdir -p $(go env GOPATH)/src/github.com/cloudwego
  $ cd $(go env GOPATH)/src/github.com/cloudwego

若將程式碼放置於 GOPATH 之外，可直接獲取

編寫範例程式碼

在當前目錄下建立 hertz_demo 資料夾，進入該目錄中
建立 main.go 檔案
在 main.go 檔案中新增以下程式碼

package main
import (
    "context"
    "github.com/cloudwego/hertz/pkg/app"
    "github.com/cloudwego/hertz/pkg/app/server"
    "github.com/cloudwego/hertz/pkg/common/utils"
    "github.com/cloudwego/hertz/pkg/protocol/consts"
)
func main() {
    h := server.Default()
    h.GET("/ping", func(c context.Context, ctx *app.RequestContext) {
            ctx.JSON(consts.StatusOK, utils.H{"message": "pong"})
    })
    h.Spin()
}

生成go.mod 檔案

$ go mod init hertz_demo

整理 & 拉取依賴

$ go mod tidy

執行範例程式碼

完成以上操作後，我們可以直接編譯並啟動 Server

$ go build -o hertz_demo && ./hertz_demo

如果成功啟動，將看到以下資訊

2023/01/26 07:23:35 Response({Message:my request})

接下來，我們可以對介面進行測試

$ curl http://127.0.0.1:8888/ping

如果不出意外，可以看到類似如下輸出

$ {"message":"pong"}

到現在，我們已經成功啟動了 Hertz Server，並完成了一次呼叫！

Hertz路由優先順序

Hertz提供了引數路由和通配路由，路由的優先順序為：靜態路由>命名路由>通配路由

Hertz中介軟體

Hertz中介軟體的種類是多種多樣的，簡單分為兩大類：

伺服器端中介軟體
使用者端中介軟體

伺服器端中介軟體

中介軟體可以在請求更深入地傳遞到業務邏輯之前或之後執行：

中介軟體可以在請求到達業務邏輯之前執行，比如執行身份認證和許可權認證，當中介軟體只有初始化（pre-handle）相關邏輯，且沒有和 real handler 在一個函數呼叫棧中的需求時，中介軟體中可以省略掉最後的.Next，如圖中的中介軟體 B。
中介軟體也可以在執行過業務邏輯之後執行，比如記錄響應時間和從異常中恢復。如果在業務 handler 處理之後有其它處理邏輯（ post-handle ），或對函數呼叫鏈（棧）有強需求，則必須顯式呼叫.Next，如圖中的中介軟體 C。

實現一箇中介軟體

// 方式一
func MyMiddleware() app.HandlerFunc {
  return func(ctx context.Context, c *app.RequestContext) {
    // pre-handle
    // ...
    c.Next(ctx)
  }
}
// 方式二
func MyMiddleware() app.HandlerFunc {
  return func(ctx context.Context, c *app.RequestContext) {
    c.Next(ctx) // call the next middleware(handler)
    // post-handle
    // ...
  }
}

中介軟體會按定義的先後順序依次執行，如果想快速終止中介軟體呼叫，可以使用以下方法，注意當前中介軟體仍將執行。

Abort()：終止後續呼叫
AbortWithMsg(msg string, statusCode int)：終止後續呼叫，並設定 response中body，和狀態碼
AbortWithStatus(code int)：終止後續呼叫，並設定狀態碼

Server級別中介軟體

Server級別中介軟體會對整個server的路由生效

h := server.Default()
h.Use(GlobalMiddleware())

路由組級別中介軟體

路由組級別中介軟體對當前路由組下的路徑生效

h := server.Default()
group := h.Group("/group")
group.Use(GroupMiddleware())

或者

package main
import (
    "context"
    "fmt"
    "github.com/cloudwego/hertz/pkg/app"
    "github.com/cloudwego/hertz/pkg/app/server"
)
func GroupMiddleware() []app.HandlerFunc {
    return []app.HandlerFunc{func(ctx context.Context, c *app.RequestContext) {
        fmt.Println("group middleware")
        c.Next(ctx)
    }}
}
func main() {
    h := server.Default(server.WithHostPorts("127.0.0.1:8888"))
    group := h.Group("/group", append(GroupMiddleware(),
        func(ctx context.Context, c *app.RequestContext) {
            fmt.Println("group middleware 2")
            c.Next(ctx)
        })...)
    // ...
    h.Spin()
}

使用預設中介軟體

Hertz 框架已經預置了常用的 recover 中介軟體，使用 server.Default() 預設可以註冊該中介軟體

使用者端中介軟體

使用者端中介軟體可以在請求發出之前或獲取響應之後執行：

中介軟體可以在請求發出之前執行，比如統一為請求新增簽名或其他欄位。
中介軟體也可以在收到響應之後執行，比如統一修改響應結果適配業務邏輯。

實現一箇中介軟體

使用者端中介軟體實現和伺服器端中介軟體不同。Client 側無法拿到中介軟體 index 實現遞增，因此 Client 中介軟體採用提前構建巢狀函數的形式實現，在實現一箇中介軟體時，可以參考下面的程式碼。

func MyMiddleware(next client.Endpoint) client.Endpoint {
  return func(ctx context.Context, req *protocol.Request, resp *protocol.Response) (err error) {
    // pre-handle
    // ...
    err = next(ctx, req, resp)
    if err != nil {
      return
    }
    // post-handle
    // ...
  }
}

註冊一箇中介軟體

package main
import (
    "context"
    "fmt"
    "github.com/cloudwego/hertz/pkg/app/client"
    "github.com/cloudwego/hertz/pkg/protocol"
)
func MyMiddleware(next client.Endpoint) client.Endpoint {
    return func(ctx context.Context, req *protocol.Request, resp *protocol.Response) (err error) {
        // pre-handle
        // ...
        fmt.Println("before request")
        req.AppendBodyString("k1=v1&")
        err = next(ctx, req, resp)
        if err != nil {
            return
        }
        // post-handle
        // ...
        fmt.Println("after request")
        return nil
    }
}
func main() {
    client, _ := client.NewClient()
    client.Use(MyMiddleware)
    statusCode, body, err := client.Post(context.Background(),
        []byte{},
        "http://httpbin.org/redirect-to?url=http%3A%2F%2Fhttpbin.org%2Fpost&status_code=302",
        &protocol.Args{})
    fmt.Printf("%d, %s, %s", statusCode, body, err)
}

總結

瞭解Gorm/Kitex/Hertz是什麼
熟悉Gorm/Kitex/Hertz的基礎使用
通過實戰案例分析將三個框架的使用串聯起來

以上就是Go框架三件套Gorm Kitex Hertz基本用法與常見API講解的詳細內容，更多關於Go框架Gorm Kitex Hertz的資料請關注it145.com其它相關文章！

Go框架三件套Gorm Kitex Hertz基本用法與常見API講解

目錄

三件套介紹

Gorm

Kitex

Hertz

三件套使用

Gorm

宣告模型

模型定義

約定

gorm.Model

連線到資料庫

MySQL

使用現有資料庫連線

CRUD介面

建立記錄

批次插入

通過Map資料型別建立記錄

查詢

檢索單個物件

檢索物件

條件查詢

選擇特定欄位

Order查詢

Limit & Offset查詢

Group & Having查詢

Distinct查詢

高階查詢

智慧選擇欄位

子查詢

From子查詢

Group條件

更新

儲存所有欄位

更新單個列

更新多列

更新選定欄位

批次更新

獲取更新的記錄數

刪除

刪除一條記錄

根據主鍵刪除

批次刪除

返回刪除行的資料

軟刪除

事務

禁用預設事務

事務開啟

巢狀事務

手動事務

Gorm效能提高

Kitex

安裝

使用

編寫IDL

生成echo服務程式碼

編寫echo服務邏輯

編譯執行

編寫使用者端

發起呼叫

Hertz

安裝命令列工具hz

確定程式碼放置位置

編寫範例程式碼

執行範例程式碼

Hertz路由優先順序

Hertz中介軟體

伺服器端中介軟體

實現一箇中介軟體

Server級別中介軟體

路由組級別中介軟體

使用預設中介軟體

使用者端中介軟體

實現一箇中介軟體

註冊一箇中介軟體

總結

熱門文章