模板定制化

概述

goctl 代码生成是基于 go 的模板去实现数据驱动的，虽然目前 goctl 的代码生成可以满足一部分代码生成功能，但是模板的自定义可以更加丰富代码生成。

模板指令可参考 goctl template

示例

场景

实现统一格式的 body 响应，格式如下：

{
  "code": 0,
  "msg": "OK",
  "data": {}
  // ①
}

① 实际响应数据

tip

go-zero生成的代码没有对其进行处理

准备工作

我们提前在 module 为 greet 的工程下的 response 包中写一个 Response 方法，目录树类似如下：

greet
├── response
│   └── response.go
└── xxx...

代码如下

package response
import (
    "net/http"
    "github.com/zeromicro/go-zero/rest/httpx"
)
type Body struct {
    Code int         `json:"code"`
    Msg  string      `json:"msg"`
    Data interface{} `json:"data,omitempty"`
}
func Response(w http.ResponseWriter, resp interface{}, err error) {
    var body Body
    if err != nil {
        body.Code = -1
        body.Msg = err.Error()
    } else {
        body.Msg = "OK"
        body.Data = resp
    }
    httpx.OkJson(w, body)
}

修改 handler 模板

$ vim ~/.goctl/${goctl版本号}/api/handler.tpl

将模板替换为以下内容

package handler
import (
    "net/http"
    "greet/response"// ①
    {{.ImportPackages}}
)
func {{.HandlerName}}(svcCtx *svc.ServiceContext) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        {{if .HasRequest}}var req types.{{.RequestType}}
        if err := httpx.Parse(r, &req); err != nil {
            httpx.Error(w, err)
            return
        }{{end}}
        l := {{.LogicName}}.New{{.LogicType}}(r.Context(), svcCtx)
        {{if .HasResp}}resp, {{end}}err := l.{{.Call}}({{if .HasRequest}}&req{{end}})
        {{if .HasResp}}response.Response(w, resp, err){{else}}response.Response(w, nil, err){{end}}//②
    }
}

① 替换为你真实的response包名，仅供参考

② 自定义模板内容

1.如果本地没有~/.goctl/${goctl版本号}/api/handler.tpl文件，可以通过模板初始化命令goctl template init进行初始化

修改模板前后对比

• 修改前

func GreetHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        var req types.Request
        if err := httpx.Parse(r, &req); err != nil {
            httpx.Error(w, err)
            return
        }
        l := logic.NewGreetLogic(r.Context(), svcCtx)
        resp, err := l.Greet(&req)
        // 以下内容将被自定义模板替换
        if err != nil {
            httpx.Error(w, err)
        } else {
            httpx.OkJson(w, resp)
        }
    }
}

• 修改后

func GreetHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        var req types.Request
        if err := httpx.Parse(r, &req); err != nil {
            httpx.Error(w, err)
            return
        }
        l := logic.NewGreetLogic(r.Context(), svcCtx)
        resp, err := l.Greet(&req)
        response.Response(w, resp, err)
    }
}

修改模板前后响应体对比

• 修改前

{
  "message": "Hello go-zero!"
}

• 修改后

{
  "code": 0,
  "msg": "OK",
  "data": {
    "message": "Hello go-zero!"
  }
}

模板自定义规则

1. 在 goctl 提供的有效数据范围内修改，即不支持外部变量
2. 不支持新增模板文件
3. 不支持变量修改

模板变量

goctl api -o 代码生成模板

模板默认目录 ~/.goctl/${goctl-version}/newapi

api.tpl

syntax = "v1"
info (
    title: // TODO: add title
    desc: // TODO: add description
    author: "{{.gitUser}}"
    email: "{{.gitEmail}}"
)
type request {
    // TODO: add members here and delete this comment
}
type response {
    // TODO: add members here and delete this comment
}
service {{.serviceName}} {
    @handler GetUser // TODO: set handler name and delete this comment
    get /users/id/:userId(request) returns(response)
    @handler CreateUser // TODO: set handler name and delete this comment
    post /users/create(request)
}

对应指令 goctl api -o

模板注入对象为 map[string]string

map[string]string{
    "gitUser":     getGitName(),
    "gitEmail":    getGitEmail(),
    "serviceName": baseName + "-api",
}

goctl api go 代码生成模板

对应指令 goctl api go ...

模板默认目录 ~/.goctl/${goctl-version}/api

config.tpl

package config
import {{.authImport}}
type Config struct {
    rest.RestConf
    {{.auth}}
    {{.jwtTrans}}
}

模板注入对象为 map[string]string

map[string]string{
    "authImport": authImportStr,
    "auth":       strings.Join(auths, "\n"),
    "jwtTrans":   strings.Join(jwtTransList, "\n"),
}

etc.tpl

Name: {{.serviceName}}
Host: {{.host}}
Port: {{.port}}

模板注入对象为 map[string]string

map[string]string{
    "serviceName": service.Name,
    "host":        host,
    "port":        port,
}

handler.tpl

package {{.PkgName}}
import (
    "net/http"
    "github.com/zeromicro/go-zero/rest/httpx"
    {{.ImportPackages}}
)
{{if .HasDoc}}{{.Doc}}{{end}}
func {{.HandlerName}}(svcCtx *svc.ServiceContext) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        {{if .HasRequest}}var req types.{{.RequestType}}
        if err := httpx.Parse(r, &req); err != nil {
            httpx.ErrorCtx(r.Context(), w, err)
            return
        }
        {{end}}l := {{.LogicName}}.New{{.LogicType}}(r.Context(), svcCtx)
        {{if .HasResp}}resp, {{end}}err := l.{{.Call}}({{if .HasRequest}}&req{{end}})
        if err != nil {
            httpx.ErrorCtx(r.Context(), w, err)
        } else {
            {{if .HasResp}}httpx.OkJsonCtx(r.Context(), w, resp){{else}}httpx.Ok(w){{end}}
        }
    }
}

模板注入对象为 map[string]any

map[string]any{
    "PkgName":        pkgName,
    "ImportPackages": genHandlerImports(group, route, rootPkg),
    "HandlerName":    handler,
    "RequestType":    util.Title(route.RequestTypeName()),
    "LogicName":      logicName,
    "LogicType":      strings.Title(getLogicName(route)),
    "Call":           strings.Title(strings.TrimSuffix(handler, "Handler")),
    "HasResp":        len(route.ResponseTypeName()) > 0,
    "HasRequest":     len(route.RequestTypeName()) > 0,
    "HasDoc":         len(route.JoinedDoc()) > 0,
    "Doc":            getDoc(route.JoinedDoc()),
}

logic.tpl

package {{.pkgName}}
import (
    {{.imports}}
)
type {{.logic}} struct {
    logx.Logger
    ctx    context.Context
    svcCtx *svc.ServiceContext
}
{{if .hasDoc}}{{.doc}}{{end}}
func New{{.logic}}(ctx context.Context, svcCtx *svc.ServiceContext) *{{.logic}} {
    return &{{.logic}}{
        Logger: logx.WithContext(ctx),
        ctx:    ctx,
        svcCtx: svcCtx,
    }
}
func (l *{{.logic}}) {{.function}}({{.request}}) {{.responseType}} {
    // todo: add your logic here and delete this line
    {{.returnString}}
}

模板注入对象为 map[string]any

map[string]any{
    "pkgName":      subDir[strings.LastIndex(subDir, "/")+1:],
    "imports":      imports,
    "logic":        strings.Title(logic),
    "function":     strings.Title(strings.TrimSuffix(logic, "Logic")),
    "responseType": responseString,
    "returnString": returnString,
    "request":      requestString,
    "hasDoc":       len(route.JoinedDoc()) > 0,
    "doc":          getDoc(route.JoinedDoc()),
}

main.tpl

package main
import (
    "flag"
    "fmt"
    {{.importPackages}}
)
var configFile = flag.String("f", "etc/{{.serviceName}}.yaml", "the config file")
func main() {
    flag.Parse()
    var c config.Config
    conf.MustLoad(*configFile, &c)
    server := rest.MustNewServer(c.RestConf)
    defer server.Stop()
    ctx := svc.NewServiceContext(c)
    handler.RegisterHandlers(server, ctx)
    fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
    server.Start()
}

模板注入对象为 map[string]string

map[string]string{
    "importPackages": genMainImports(rootPkg),
    "serviceName":    configName,
}

middleware.tpl

package middleware
import "net/http"
type {{.name}} struct {
}
func New{{.name}}() *{{.name}} {
    return &{{.name}}{}
}
func (m *{{.name}})Handle(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // TODO generate middleware implement function, delete after code implementation
        // Passthrough to next handler if need
        next(w, r)
    }
}

模板注入对象为 map[string]string

map[string]string{
    "name": strings.Title(name),
}

svc.tpl

package svc
import (
    {{.configImport}}
)
type ServiceContext struct {
    Config {{.config}}
    {{.middleware}}
}
func NewServiceContext(c {{.config}}) *ServiceContext {
    return &ServiceContext{
        Config: c,
        {{.middlewareAssignment}}
    }
}

模板注入对象为 map[string]string

map[string]string{
    "configImport":         configImport,
    "config":               "config.Config",
    "middleware":           middlewareStr,
    "middlewareAssignment": middlewareAssignment,
}

type.tpl

// Code generated by goctl. DO NOT EDIT.
package types{{if .containsTime}}
import (
    "time"
){{end}}
{{.types}}

模板注入对象为 map[string]any

map[string]any{
    "types":        val,
    "containsTime": false,
}

goctl api new 代码生成模板

对应指令为 goctl api new ...

模板默认目录 ~/.goctl/${goctl-version}/newapi

api.tpl

syntax = "v1"
type Request {
  Name string `path:"name,options=you|me"`
}
type Response {
  Message string `json:"message"`
}
service {{.name}}-api {
  @handler {{.handler}}Handler
  get /from/:name(Request) returns (Response)
}

模板注入对象 map[string]string

map[string]string{
    "name":    dirName,
    "handler": strings.Title(dirName),
}

mongo 代码生成模板

模板默认目录 ~/.goctl/${goctl-version}/mongo

error.tpl

package model
import (
    "errors"
    "github.com/zeromicro/go-zero/core/stores/mon"
)
var (
    ErrNotFound        = mon.ErrNotFound
    ErrInvalidObjectId = errors.New("invalid objectId")
)

model.tpl

// Code generated by goctl. DO NOT EDIT.
package model
import (
    "context"
    "time"
    {{if .Cache}}"github.com/zeromicro/go-zero/core/stores/monc"{{else}}"github.com/zeromicro/go-zero/core/stores/mon"{{end}}
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
)
{{if .Cache}}var prefix{{.Type}}CacheKey = "cache:{{.lowerType}}:"{{end}}
type {{.lowerType}}Model interface{
    Insert(ctx context.Context,data *{{.Type}}) error
    FindOne(ctx context.Context,id string) (*{{.Type}}, error)
    Update(ctx context.Context,data *{{.Type}}) (*mongo.UpdateResult, error)
    Delete(ctx context.Context,id string) (int64, error)
}
type default{{.Type}}Model struct {
    conn {{if .Cache}}*monc.Model{{else}}*mon.Model{{end}}
}
func newDefault{{.Type}}Model(conn {{if .Cache}}*monc.Model{{else}}*mon.Model{{end}}) *default{{.Type}}Model {
    return &default{{.Type}}Model{conn: conn}
}
func (m *default{{.Type}}Model) Insert(ctx context.Context, data *{{.Type}}) error {
    if data.ID.IsZero() {
        data.ID = primitive.NewObjectID()
        data.CreateAt = time.Now()
        data.UpdateAt = time.Now()
    }
    {{if .Cache}}key := prefix{{.Type}}CacheKey + data.ID.Hex(){{end}}
    _, err := m.conn.InsertOne(ctx, {{if .Cache}}key, {{end}} data)
    return err
}
func (m *default{{.Type}}Model) FindOne(ctx context.Context, id string) (*{{.Type}}, error) {
    oid, err := primitive.ObjectIDFromHex(id)
    if err != nil {
        return nil, ErrInvalidObjectId
    }
    var data {{.Type}}
    {{if .Cache}}key := prefix{{.Type}}CacheKey + id{{end}}
    err = m.conn.FindOne(ctx, {{if .Cache}}key, {{end}}&data, bson.M{"_id": oid})
    switch err {
    case nil:
        return &data, nil
    case {{if .Cache}}monc{{else}}mon{{end}}.ErrNotFound:
        return nil, ErrNotFound
    default:
        return nil, err
    }
}
func (m *default{{.Type}}Model) Update(ctx context.Context, data *{{.Type}}) (*mongo.UpdateResult, error) {
    data.UpdateAt = time.Now()
    {{if .Cache}}key := prefix{{.Type}}CacheKey + data.ID.Hex(){{end}}
    res, err := m.conn.UpdateOne(ctx, {{if .Cache}}key, {{end}}bson.M{"_id": data.ID}, bson.M{"$set": data})
    return res, err
}
func (m *default{{.Type}}Model) Delete(ctx context.Context, id string) (int64, error) {
    oid, err := primitive.ObjectIDFromHex(id)
    if err != nil {
        return 0, ErrInvalidObjectId
    }
    {{if .Cache}}key := prefix{{.Type}}CacheKey +id{{end}}
    res, err := m.conn.DeleteOne(ctx, {{if .Cache}}key, {{end}}bson.M{"_id": oid})
    return res, err
}

模板注入对象为 map[string]any

map[string]any{
    "Type":      stringx.From(t).Title(),
    "lowerType": stringx.From(t).Untitle(),
    "Cache":     ctx.Cache,
}

model_custom.tpl

package model
{{if .Cache}}import (
    "github.com/zeromicro/go-zero/core/stores/cache"
    "github.com/zeromicro/go-zero/core/stores/monc"
){{else}}import "github.com/zeromicro/go-zero/core/stores/mon"{{end}}
{{if .Easy}}
const {{.Type}}CollectionName = "{{.snakeType}}"
{{end}}
var _ {{.Type}}Model = (*custom{{.Type}}Model)(nil)
type (
    // {{.Type}}Model is an interface to be customized, add more methods here,
    // and implement the added methods in custom{{.Type}}Model.
    {{.Type}}Model interface {
        {{.lowerType}}Model
    }
    custom{{.Type}}Model struct {
        *default{{.Type}}Model
    }
)
// New{{.Type}}Model returns a model for the mongo.
{{if .Easy}}func New{{.Type}}Model(url, db string{{if .Cache}}, c cache.CacheConf{{end}}) {{.Type}}Model {
    conn := {{if .Cache}}monc{{else}}mon{{end}}.MustNewModel(url, db, {{.Type}}CollectionName{{if .Cache}}, c{{end}})
    return &custom{{.Type}}Model{
        default{{.Type}}Model: newDefault{{.Type}}Model(conn),
    }
}{{else}}func New{{.Type}}Model(url, db, collection string{{if .Cache}}, c cache.CacheConf{{end}}) {{.Type}}Model {
    conn := {{if .Cache}}monc{{else}}mon{{end}}.MustNewModel(url, db, collection{{if .Cache}}, c{{end}})
    return &custom{{.Type}}Model{
        default{{.Type}}Model: newDefault{{.Type}}Model(conn),
    }
}{{end}}

模板注入对象为 map[string]any

map[string]any{
    "Type":      stringx.From(t).Title(),
    "lowerType": stringx.From(t).Untitle(),
    "snakeType": stringx.From(t).ToSnake(),
    "Cache":     ctx.Cache,
    "Easy":      ctx.Easy,
}

types.tpl

package model
import (
    "time"
    "go.mongodb.org/mongo-driver/bson/primitive"
)
type {{.Type}} struct {
    ID primitive.ObjectID `bson:"_id,omitempty" json:"id,omitempty"`
    // TODO: Fill your own fields
    UpdateAt time.Time `bson:"updateAt,omitempty" json:"updateAt,omitempty"`
    CreateAt time.Time `bson:"createAt,omitempty" json:"createAt,omitempty"`
}

模板注入对象为 map[string]any

map[string]any{
    "Type": stringx.From(t).Title(),
}

mysql 代码生成模板

模板默认目录 ~/.goctl/${goctl-version}/model

customized.tpl

空模板，方便自定义

模板注入对象 map[string]any

mmap[string]any{
    "withCache":                 withCache,
    "containsIndexCache":        table.ContainsUniqueCacheKey,
    "upperStartCamelObject":     camel,
    "lowerStartCamelObject":     stringx.From(camel).Untitle(),
    "lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
    "upperStartCamelPrimaryKey": table.PrimaryKey.Name.ToCamel(),
    "primaryKeyDataType":        table.PrimaryKey.DataType,
    "originalPrimaryKey":        wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
    "primaryCacheKey":           table.PrimaryCacheKey.DataKeyExpression,
    "primaryKeyVariable":        table.PrimaryCacheKey.KeyLeft,
    "keys":                      strings.Join(keys, "\n"),
    "keyValues":                 strings.Join(keyVars, ", "),
    "expression":                strings.Join(expressions, ", "),
    "expressionValues":          strings.Join(expressionValues, ", "),
    "postgreSql":                postgreSql,
    "fields":                    fields,
    "data":                      table,
}

delete.tpl

func (m *default{{.upperStartCamelObject}}Model) Delete(ctx context.Context, {{.lowerStartCamelPrimaryKey}} {{.dataType}}) error {
    {{if .withCache}}{{if .containsIndexCache}}data, err:=m.FindOne(ctx, {{.lowerStartCamelPrimaryKey}})
    if err!=nil{
        return err
    }
{{end}} {{.keys}}
    _, err {{if .containsIndexCache}}={{else}}:={{end}} m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
        query := fmt.Sprintf("delete from %s where {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}}", m.table)
        return conn.ExecCtx(ctx, query, {{.lowerStartCamelPrimaryKey}})
    }, {{.keyValues}}){{else}}query := fmt.Sprintf("delete from %s where {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}}", m.table)
        _,err:=m.conn.ExecCtx(ctx, query, {{.lowerStartCamelPrimaryKey}}){{end}}
    return err
}

模板注入对象为 map[string]any

map[string]any{
    "upperStartCamelObject":     camel,
    "withCache":                 withCache,
    "containsIndexCache":        table.ContainsUniqueCacheKey,
    "lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
    "dataType":                  table.PrimaryKey.DataType,
    "keys":                      strings.Join(keys, "\n"),
    "originalPrimaryKey":        wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
    "keyValues":                 strings.Join(keyVars, ", "),
    "postgreSql":                postgreSql,
    "data":                      table,
}

err.tpl

package {{.pkg}}
import "github.com/zeromicro/go-zero/core/stores/sqlx"
var ErrNotFound = sqlx.ErrNotFound

模板注入对象为 map[string]any

map[string]any{
    "pkg": g.pkg,
}

field.tpl

{{.name}} {{.type}} {{.tag}} {{if .hasComment}}// {{.comment}}{{end}}

模板注入对象为 map[string]any

map[string]any{
    "name":       util.SafeString(field.Name.ToCamel()),
    "type":       field.DataType,
    "tag":        tag,
    "hasComment": field.Comment != "",
    "comment":    field.Comment,
    "data":       table,
}

find-one.tpl

func (m *default{{.upperStartCamelObject}}Model) FindOne(ctx context.Context, {{.lowerStartCamelPrimaryKey}} {{.dataType}}) (*{{.upperStartCamelObject}}, error) {
    {{if .withCache}}{{.cacheKey}}
    var resp {{.upperStartCamelObject}}
    err := m.QueryRowCtx(ctx, &resp, {{.cacheKeyVariable}}, func(ctx context.Context, conn sqlx.SqlConn, v any) error {
        query :=  fmt.Sprintf("select %s from %s where {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}} limit 1", {{.lowerStartCamelObject}}Rows, m.table)
        return conn.QueryRowCtx(ctx, v, query, {{.lowerStartCamelPrimaryKey}})
    })
    switch err {
    case nil:
        return &resp, nil
    case sqlc.ErrNotFound:
        return nil, ErrNotFound
    default:
        return nil, err
    }{{else}}query := fmt.Sprintf("select %s from %s where {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}} limit 1", {{.lowerStartCamelObject}}Rows, m.table)
    var resp {{.upperStartCamelObject}}
    err := m.conn.QueryRowCtx(ctx, &resp, query, {{.lowerStartCamelPrimaryKey}})
    switch err {
    case nil:
        return &resp, nil
    case sqlx.ErrNotFound:
        return nil, ErrNotFound
    default:
        return nil, err
    }{{end}}
}

模板注入对象为 map[string]any

map[string]any{
    "withCache":                 withCache,
    "upperStartCamelObject":     camel,
    "lowerStartCamelObject":     stringx.From(camel).Untitle(),
    "originalPrimaryKey":        wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
    "lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
    "dataType":                  table.PrimaryKey.DataType,
    "cacheKey":                  table.PrimaryCacheKey.KeyExpression,
    "cacheKeyVariable":          table.PrimaryCacheKey.KeyLeft,
    "postgreSql":                postgreSql,
    "data":                      table,
}

find-one-by-field.tpl

func (m *default{{.upperStartCamelObject}}Model) FindOneBy{{.upperField}}(ctx context.Context, {{.in}}) (*{{.upperStartCamelObject}}, error) {
    {{if .withCache}}{{.cacheKey}}
    var resp {{.upperStartCamelObject}}
    err := m.QueryRowIndexCtx(ctx, &resp, {{.cacheKeyVariable}}, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v any) (i any, e error) {
        query := fmt.Sprintf("select %s from %s where {{.originalField}} limit 1", {{.lowerStartCamelObject}}Rows, m.table)
        if err := conn.QueryRowCtx(ctx, &resp, query, {{.lowerStartCamelField}}); err != nil {
            return nil, err
        }
        return resp.{{.upperStartCamelPrimaryKey}}, nil
    }, m.queryPrimary)
    switch err {
    case nil:
        return &resp, nil
    case sqlc.ErrNotFound:
        return nil, ErrNotFound
    default:
        return nil, err
    }
}{{else}}var resp {{.upperStartCamelObject}}
    query := fmt.Sprintf("select %s from %s where {{.originalField}} limit 1", {{.lowerStartCamelObject}}Rows, m.table )
    err := m.conn.QueryRowCtx(ctx, &resp, query, {{.lowerStartCamelField}})
    switch err {
    case nil:
        return &resp, nil
    case sqlx.ErrNotFound:
        return nil, ErrNotFound
    default:
        return nil, err
    }
}{{end}}

模板注入对象为 map[string]any

map[string]any{
    "upperStartCamelObject":     camelTableName,
    "upperField":                key.FieldNameJoin.Camel().With("").Source(),
    "in":                        in,
    "withCache":                 withCache,
    "cacheKey":                  key.KeyExpression,
    "cacheKeyVariable":          key.KeyLeft,
    "lowerStartCamelObject":     stringx.From(camelTableName).Untitle(),
    "lowerStartCamelField":      paramJoinString,
    "upperStartCamelPrimaryKey": table.PrimaryKey.Name.ToCamel(),
    "originalField":             originalFieldString,
    "postgreSql":                postgreSql,
    "data":                      table,
}

find-one-by-field-extra-method.tpl

func (m *default{{.upperStartCamelObject}}Model) formatPrimary(primary any) string {
    return fmt.Sprintf("%s%v", {{.primaryKeyLeft}}, primary)
}
func (m *default{{.upperStartCamelObject}}Model) queryPrimary(ctx context.Context, conn sqlx.SqlConn, v, primary any) error {
    query := fmt.Sprintf("select %s from %s where {{.originalPrimaryField}} = {{if .postgreSql}}$1{{else}}?{{end}} limit 1", {{.lowerStartCamelObject}}Rows, m.table )
    return conn.QueryRowCtx(ctx, v, query, primary)
}

模板注入对象为

map[string]any{
    "upperStartCamelObject": camelTableName,
    "primaryKeyLeft":        table.PrimaryCacheKey.VarLeft,
    "lowerStartCamelObject": stringx.From(camelTableName).Untitle(),
    "originalPrimaryField":  wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
    "postgreSql":            postgreSql,
    "data":                  table,
}

import.tpl

import (
    "context"
    "database/sql"
    "fmt"
    "strings"
    {{if .time}}"time"{{end}}
    {{if .containsPQ}}"github.com/lib/pq"{{end}}
    "github.com/zeromicro/go-zero/core/stores/builder"
    "github.com/zeromicro/go-zero/core/stores/cache"
    "github.com/zeromicro/go-zero/core/stores/sqlc"
    "github.com/zeromicro/go-zero/core/stores/sqlx"
    "github.com/zeromicro/go-zero/core/stringx"
    {{.third}}
)

模板注入对象为

map[string]any{
    "time":       timeImport,
    "containsPQ": table.ContainsPQ,
    "data":       table,
    "third":      strings.Join(thirdImports, "\n"),
}

import.no-cache.tpl

import (
    "context"
    "database/sql"
    "fmt"
    "strings"
    {{if .time}}"time"{{end}}
    {{if .containsPQ}}"github.com/lib/pq"{{end}}
    "github.com/zeromicro/go-zero/core/stores/builder"
    "github.com/zeromicro/go-zero/core/stores/sqlx"
    "github.com/zeromicro/go-zero/core/stringx"
    {{.third}}
)

模板注入对象为：

map[string]any{
    "time":       timeImport,
    "containsPQ": table.ContainsPQ,
    "data":       table,
    "third":      strings.Join(thirdImports, "\n"),
}

insert.tpl

func (m *default{{.upperStartCamelObject}}Model) Insert(ctx context.Context, data *{{.upperStartCamelObject}}) (sql.Result,error) {
    {{if .withCache}}{{.keys}}
    ret, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
        query := fmt.Sprintf("insert into %s (%s) values ({{.expression}})", m.table, {{.lowerStartCamelObject}}RowsExpectAutoSet)
        return conn.ExecCtx(ctx, query, {{.expressionValues}})
    }, {{.keyValues}}){{else}}query := fmt.Sprintf("insert into %s (%s) values ({{.expression}})", m.table, {{.lowerStartCamelObject}}RowsExpectAutoSet)
    ret,err:=m.conn.ExecCtx(ctx, query, {{.expressionValues}}){{end}}
    return ret,err
}

模板注入对象为

map[string]any{
    "withCache":             withCache,
    "upperStartCamelObject": camel,
    "lowerStartCamelObject": stringx.From(camel).Untitle(),
    "expression":            strings.Join(expressions, ", "),
    "expressionValues":      strings.Join(expressionValues, ", "),
    "keys":                  strings.Join(keys, "\n"),
    "keyValues":             strings.Join(keyVars, ", "),
    "data":                  table,
})

interface-delete.tpl

Delete(ctx context.Context, {{.lowerStartCamelPrimaryKey}} {{.dataType}}) error

模板注入对象为

map[string]any{
    "lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
    "dataType":                  table.PrimaryKey.DataType,
    "data":                      table,
}

interface-find-one.tpl

FindOne(ctx context.Context, {{.lowerStartCamelPrimaryKey}} {{.dataType}}) (*{{.upperStartCamelObject}}, error)

模板注入对象为：

map[string]any{
    "upperStartCamelObject":     camel,
    "lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
    "dataType":                  table.PrimaryKey.DataType,
    "data":                      table,
}

interface-find-one-by-field.tpl

FindOneBy{{.upperField}}(ctx context.Context, {{.in}}) (*{{.upperStartCamelObject}}, error)

模板注入对象为：

string]any{
    "upperStartCamelObject": camelTableName,
    "upperField":            key.FieldNameJoin.Camel().With("").Source(),
    "in":                    in,
    "data":                  table,
}

interface-insert.tpl

Insert(ctx context.Context, data *{{.upperStartCamelObject}}) (sql.Result,error)

注入对象为

string]any{
    "upperStartCamelObject": camel,
    "data":                  table,
}

interface-update.tpl

Update(ctx context.Context, {{if .containsIndexCache}}newData{{else}}data{{end}} *{{.upperStartCamelObject}}) error

模板注入对象为：

map[string]any{
    "upperStartCamelObject": camelTableName,
    "data":                  table,
}

model.tpl

package {{.pkg}}
{{if .withCache}}
import (
    "github.com/zeromicro/go-zero/core/stores/cache"
    "github.com/zeromicro/go-zero/core/stores/sqlx"
)
{{else}}
import "github.com/zeromicro/go-zero/core/stores/sqlx"
{{end}}
var _ {{.upperStartCamelObject}}Model = (*custom{{.upperStartCamelObject}}Model)(nil)
type (
    // {{.upperStartCamelObject}}Model is an interface to be customized, add more methods here,
    // and implement the added methods in custom{{.upperStartCamelObject}}Model.
    {{.upperStartCamelObject}}Model interface {
        {{.lowerStartCamelObject}}Model
        {{if not .withCache}}withSession(session sqlx.Session) {{.upperStartCamelObject}}Model{{end}}
    }
    custom{{.upperStartCamelObject}}Model struct {
        *default{{.upperStartCamelObject}}Model
    }
)
// New{{.upperStartCamelObject}}Model returns a model for the database table.
func New{{.upperStartCamelObject}}Model(conn sqlx.SqlConn{{if .withCache}}, c cache.CacheConf, opts ...cache.Option{{end}}) {{.upperStartCamelObject}}Model {
    return &custom{{.upperStartCamelObject}}Model{
        default{{.upperStartCamelObject}}Model: new{{.upperStartCamelObject}}Model(conn{{if .withCache}}, c, opts...{{end}}),
    }
}
{{if not .withCache}}
func (m *custom{{.upperStartCamelObject}}Model) withSession(session sqlx.Session) {{.upperStartCamelObject}}Model {
    return New{{.upperStartCamelObject}}Model(sqlx.NewSqlConnFromSession(session))
}
{{end}}

模板注入对象为：

map[string]any{
    "pkg":                   g.pkg,
    "withCache":             withCache,
    "upperStartCamelObject": in.Name.ToCamel(),
    "lowerStartCamelObject": stringx.From(in.Name.ToCamel()).Untitle(),
}