由于整个博客是前后端分离的，并且接口规范主要使用的是 graphql（对于前端的界面不会有什么侵入性）。所以我这先把服务端的接口给实现了。
一、实体类实现
在做服务端——数据库表结构设计时，已经实现完了。
二、实体查询、删除、创建的数据库访问代码实现
由于所有维度数据访问接口约定为：全部支持分页。因此服务端无须做访问单条数据的代码实现。（即使是单条数据，也返回一个列表）（也是为了简化考虑）。
1. 创建
函数实现：
func CreateEntity(detail interface{}) (err error) {
err = DB.Debug().Create(detail).Error
return err
}
测试用例：
func TestCreateEntity(t *testing.T) {
type args struct {
detail User
}
tests := []struct {
name string
args args
wantI interface{}
wantErr bool
}{
// TODO: Add test cases.
{
name: "test1",
args: args{detail: User{
Account: "test2",
Password: "test1",
}},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := CreateEntity(&tt.args.detail)
if err != nil {
t.Errorf("CreateEntity() error = %v, wantErr %v", err, tt.wantErr)
return
}
})
}
}
测试结果：
- 传进来的参数为结构体的引用
- 该方法可以实现所有实体的创建，是一个抽象构建
2. 删除
函数实现：
func DeleteEntity(detail interface{}) (err error) {
err = DB.Debug().Unscoped().Delete(detail).Error
return err
}
- 传进来的参数为结构体的引用
- 该方法可以实现所有实体的删除（结构体必须包含主键），是一个抽象构建
测试用例：
func TestDeleteEntity(t *testing.T) {
err := DeleteEntity(&User{base: base{ID: "532dce46-82aa-11ed-9202-b025aa395669"}})
if err != nil {
t.Error(err)
}
}
测试结果：
3. 查询
查询比较麻烦，这里先说下和查询相关的需求：
- 支持关键词检索全博客网站的维度（比如说检索全博客的文章，摘录的好词句）
- 支持关键词检索当个账号内部所有的文章（比如说从账号a写的文章里检索出关键词带“七镜”的文章）
- 支持分页
- 支持排序
- 支持按列检索（比如说，查找 column1=value1 and column2=value2 的表里的所有数据）
a. 数据库表结构约定
- 所有表与表之间的关系都采用多对多（ManyToMany）
- 所有表与表之间连结的中间表名都采用“__” 双下划线连接。比如 user__comment 表示是user表和comment表的中间表
-
所有表与表之间连结的中间表名双下划线左边的表名是主表，右边的表明是客表。即客表的实体由主表的实体创建。比如账号表是主表，评论表是客表，因为账号创建评论。
b. 入参结构设计
表结构的约定是为了方便逻辑呈现，减少代码量。入参结构设计是为了实现具体的查询需求。具体入参结构设计如下：
type CondGetDetails struct {
PageAfter int `json:"pageAfter"` // 支持分页
PageSize int `json:"pageSize"` // 支持分页
OrderBy string `json:"orderBy"` // 支持排序
SortBy string `json:"sortBy"` // 支持排序
Detail interface{} `json:"detail"` // 支持按列检索
Keyword Keyword `json:"keyword"` // 支持关键字检索 // 20221222
TableName string `json:"table_name"` // 支持关键字检索 ，主实体名 // 20221222
JoinTables []CondJoinObject `json:"joinTables"` // 支持账号内维度检索 Join Table
}
type Keyword map[string]string // 统一规定关键词结构
type CondJoinObject struct {
TableName string `json:"table_name"` // 需要join 表名
IsMain bool `json:"is_main"` // 主表是靠左的
IsInner bool `json:"is_inner"` // 是否 inner join
IsLeft bool `json:"is_left"` // 是否 left join
IsRight bool `json:"is_right"` // 是否 right join
Keyword Keyword `json:"keyword"` // 要 join 的表里的关键词 like 查询
}
c. 代码实现
函数实现：
func GetEntities(cond CondGetDetails) (db *gorm.DB, err error) {
detail := cond.Detail.(map[string]interface{})
var tx *gorm.DB
if cond.Keyword != nil {
for k, v := range cond.Keyword {
delete(detail, k)
tx = DB.Where(k+" like @"+k, sql.NamedArg{
Name: k,
Value: "%" + v + "%",
}).Where(detail)
}
} else {
tx = DB.Where(detail)
}
for _, joinTable := range cond.JoinTables {
mainTableSplit := cond.TableName
main := cond.TableName
sub := joinTable.TableName
subTableSplit := joinTable.TableName
if joinTable.IsMain {
mainTableSplit = joinTable.TableName
subTableSplit = cond.TableName
main = cond.TableName
sub = joinTable.TableName
}
if joinTable.IsInner {
tx.Joins("LEFT JOIN " + mainTableSplit + "__" + subTableSplit + " on " + main + ".id = " + mainTableSplit + "__" + subTableSplit + "." + main + "_id")
likeSplit := ""
for k, v := range joinTable.Keyword {
likeSplitSplit := " and " + sub + "." + k + " like '%" + v + "%'"
likeSplit += likeSplitSplit
}
tx.Joins("INNER JOIN " + sub + " on " + sub + ".id = " + mainTableSplit + "__" + subTableSplit + "." + sub + "_id" + likeSplit)
} else {
return nil, errors.New("unimplemented join except for `INNER JOIN`")
}
}
tx = tx.Debug().Preload(clause.Associations).Limit(cond.PageSize).Offset(cond.PageAfter).Order(cond.OrderBy + " " + cond.SortBy)
return tx, err
}
测试用例：
func TestGetEntities2(t *testing.T) {
type args struct {
cond CondGetDetails
}
tests := []struct {
name string
args args
}{
// TODO: Add test cases.
{
name: "test2",
args: args{
cond: CondGetDetails{
PageAfter: 0,
PageSize: 10,
OrderBy: "created_at",
SortBy: "desc",
Detail: map[string]interface{}{},
Keyword: map[string]string{"content": "文件名中加上"},
TableName: "dimension_reading",
JoinTables: []CondJoinObject{
{
TableName: "user",
IsMain: true,
IsInner: true,
IsLeft: false,
IsRight: false,
Keyword: map[string]string{
"account": "min",
},
},
},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
gotDb, err := GetEntities(tt.args.cond)
if err != nil {
t.Error(err)
}
var dim []DimensionReading
var count int64
if err := gotDb.Debug().Find(&dim).Count(&count).Error; err != nil {
t.Error(err)
}
t.Log(dim)
t.Log(len(dim))
t.Log(count)
})
}
}
测试结果：
4. 修改
函数实现：
func UpdateEntity(detail map[string]interface{}, entity interface{}) (i interface{}, err error) {
id, idOk := detail["id"].(string)
if !idOk || id == "" {
return nil, errors.New("unknown entity.id")
}
if err != nil {
return nil, err
}
err = DB.Transaction(func(tx *gorm.DB) error {
result := DB.Debug().Model(entity).Where("id = @id", sql.Named("id", id)).Omit("id", "created_at", "created").Updates(&detail)
if result.RowsAffected <= 0 {
return errors.New("更新0条数据")
}
return nil
})
if err != nil {
return nil, err
}
return nil, err
}
测试用例：
func TestUpdateEntity(t *testing.T) {
type args struct {
detail map[string]interface{}
entity interface{}
}
tests := []struct {
name string
args args
}{
// TODO: Add test cases.
{
name: "test1",
args: args{
detail: map[string]interface{}{
"id": "3778e25e-82ac-11ed-8162-b025aa395669",
"account": "七镜",
},
entity: User{},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := UpdateEntity(tt.args.detail, tt.args.entity)
if err != nil {
t.Error(err)
}
})
}
}
测试结果：
OK，至此，所有的数据库访问基本已经完成。整个数据库访问的实现，体现了约定的价值。以上4个函数，实现了所有实体的数据库访问操作，无需再为每一个实体单独实现数据库访问函数了。
