goctl add stdin flag (#170)

* add stdin flag to use stdin receive api doc and use stdout output formatted result

* optimize code and output error through stderr

* fix mistake

* add dir parameter legality verify

readme-en.md

@@ -1,3 +1,5 @@
+<img align="right" width="150px" src="https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/go-zero.png">
+
 # go-zero
 
 English | [简体中文](readme.md)
@@ -23,7 +25,7 @@ Advantages of go-zero:
 * auto validate the request parameters from clients
 * plenty of builtin microservice management and concurrent toolkits
 
-<img src="https://github.com/tal-tech/zero-doc/blob/main/doc/images/architecture-en.png" alt="Architecture" width="1500" />
+<img src="https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/architecture-en.png" alt="Architecture" width="1500" />
 
 ## 1. Backgrounds of go-zero
 
@@ -74,7 +76,7 @@ go-zero is a web and rpc framework that integrates lots of engineering practices
 
 As below, go-zero protects the system with couple layers and mechanisms:
 
-![Resilience](https://github.com/tal-tech/zero-doc/blob/main/doc/images/resilience-en.png)
+![Resilience](https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/resilience-en.png)
 
 ## 4. Future development plans of go-zero
 
@@ -164,6 +166,8 @@ go get -u github.com/tal-tech/go-zero
 
    ```shell
    cd greet
+   go mod init
+   go mod tidy
    go run greet.go -f etc/greet-api.yaml
    ```
 
@@ -198,7 +202,7 @@ go get -u github.com/tal-tech/go-zero
 
 ## 7. Benchmark
 
-![benchmark](https://github.com/tal-tech/zero-doc/blob/main/doc/images/benchmark.png)
+![benchmark](https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/benchmark.png)
 
 [Checkout the test code](https://github.com/smallnest/go-web-framework-benchmark)
 

readme.md

@@ -1,3 +1,5 @@
+<img align="right" width="150px" src="https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/go-zero.png">
+
 # go-zero
 
 [English](readme-en.md) | 简体中文
@@ -8,28 +10,28 @@
 [![Release](https://img.shields.io/github/v/release/tal-tech/go-zero.svg?style=flat-square)](https://github.com/tal-tech/go-zero)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## 0. go-zero介绍
+## 0. go-zero 介绍
 
-go-zero是一个集成了各种工程实践的web和rpc框架。通过弹性设计保障了大并发服务端的稳定性，经受了充分的实战检验。
+go-zero 是一个集成了各种工程实践的 web 和 rpc 框架。通过弹性设计保障了大并发服务端的稳定性，经受了充分的实战检验。
 
 go-zero 包含极简的 API 定义和生成工具 goctl，可以根据定义的 api 文件一键生成 Go, iOS, Android, Kotlin, Dart, TypeScript, JavaScript 代码，并可直接运行。
 
-使用go-zero的好处：
+使用 go-zero 的好处：
 
 * 轻松获得支撑千万日活服务的稳定性
 * 内建级联超时控制、限流、自适应熔断、自适应降载等微服务治理能力，无需配置和额外代码
 * 微服务治理中间件可无缝集成到其它现有框架使用
-* 极简的API描述，一键生成各端代码
+* 极简的 API 描述，一键生成各端代码
 * 自动校验客户端请求参数合法性
 * 大量微服务治理和并发工具包
 
-<img src="https://github.com/tal-tech/zero-doc/blob/main/doc/images/architecture.png" alt="架构图" width="1500" />
+<img src="https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/architecture.png" alt="架构图" width="1500" />
 
-## 1. go-zero框架背景
+## 1. go-zero 框架背景
 
-18年初，我们决定从`Java+MongoDB`的单体架构迁移到微服务架构，经过仔细思考和对比，我们决定：
+18 年初，我们决定从 `Java+MongoDB` 的单体架构迁移到微服务架构，经过仔细思考和对比，我们决定：
 
-* 基于Go语言
+* 基于 Go 语言
   * 高效的性能
   * 简洁的语法
   * 广泛验证的工程效率
@@ -40,7 +42,7 @@ go-zero 包含极简的 API 定义和生成工具 goctl，可以根据定义的
   * 需要有更快速的问题定位能力
   * 更便捷的增加新特性
 
-## 2. go-zero框架设计思考
+## 2. go-zero 框架设计思考
 
 对于微服务框架的设计，我们期望保障微服务稳定性的同时，也要特别注重研发效率。所以设计之初，我们就有如下一些准则：
 
@@ -53,21 +55,21 @@ go-zero 包含极简的 API 定义和生成工具 goctl，可以根据定义的
 * 对业务开发友好，封装复杂度
 * 约束做一件事只有一种方式
 
-我们经历不到半年时间，彻底完成了从`Java+MongoDB`到`Golang+MySQL`为主的微服务体系迁移，并于18年8月底完全上线，稳定保障了业务后续迅速增长，确保了整个服务的高可用。
+我们经历不到半年时间，彻底完成了从 `Java+MongoDB` 到 `Golang+MySQL` 为主的微服务体系迁移，并于 18 年 8 月底完全上线，稳定保障了业务后续迅速增长，确保了整个服务的高可用。
 
-## 3. go-zero项目实现和特点
+## 3. go-zero 项目实现和特点
 
-go-zero是一个集成了各种工程实践的包含web和rpc框架，有如下主要特点：
+go-zero 是一个集成了各种工程实践的包含 web 和 rpc 框架，有如下主要特点：
 
 * 强大的工具支持，尽可能少的代码编写
 * 极简的接口
-* 完全兼容net/http
+* 完全兼容 net/http
 * 支持中间件，方便扩展
 * 高性能
 * 面向故障编程，弹性设计
 * 内建服务发现、负载均衡
 * 内建限流、熔断、降载，且自动触发，自动恢复
-* API参数自动校验
+* API 参数自动校验
 * 超时级联控制
 * 自动缓存控制
 * 链路跟踪、统计报警等
@@ -75,7 +77,7 @@ go-zero是一个集成了各种工程实践的包含web和rpc框架，有如下
 
 如下图，我们从多个层面保障了整体服务的高可用：
 
-![弹性设计](https://github.com/tal-tech/zero-doc/blob/main/doc/images/resilience.jpg)
+![弹性设计](https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/resilience.jpg)
 
 ## 4. Installation
 
@@ -91,88 +93,95 @@ GO111MODULE=on GOPROXY=https://goproxy.cn/,direct go get -u github.com/tal-tech/
 
     [快速构建高并发微服务](https://github.com/tal-tech/zero-doc/blob/main/doc/shorturl.md)
 
-    [快速构建高并发微服务-多RPC版](https://github.com/tal-tech/zero-doc/blob/main/doc/bookstore.md)
+    [快速构建高并发微服务 - 多 RPC 版](https://github.com/tal-tech/zero-doc/blob/main/doc/bookstore.md)
 
-1. 安装goctl工具
+1. 安装 goctl 工具
 
-   `goctl`读作`go control`，不要读成`go C-T-L`。`goctl`的意思是不要被代码控制，而是要去控制它。其中的`go`不是指`golang`。在设计`goctl`之初，我就希望通过`她`来解放我们的双手👈
+    `goctl` 读作 `go control`，不要读成 `go C-T-L`。`goctl` 的意思是不要被代码控制，而是要去控制它。其中的 `go` 不是指 `golang`。在设计 `goctl` 之初，我就希望通过 ` 她 ` 来解放我们的双手👈
 
-   ```shell
-   GO111MODULE=on GOPROXY=https://goproxy.cn/,direct go get -u github.com/tal-tech/go-zero/tools/goctl
-   ```
+    ```shell
+    GO111MODULE=on GOPROXY=https://goproxy.cn/,direct go get -u github.com/tal-tech/go-zero/tools/goctl
+    ```
 
-   确保goctl可执行
+    确保 goctl 可执行
 
-2. 快速生成api服务
+2. 快速生成 api 服务
 
-   ```shell
-   goctl api new greet
-   cd greet
-   go run greet.go -f etc/greet-api.yaml
-   ```
+    ```shell
+    goctl api new greet
+    cd greet
+    go mod init
+    go mod tidy
+    go run greet.go -f etc/greet-api.yaml
+    ```
 
-      默认侦听在8888端口（可以在配置文件里修改），可以通过curl请求：
+    默认侦听在 8888 端口（可以在配置文件里修改），可以通过 curl 请求：
 
-   ```shell
-   curl -i http://localhost:8888/greet/from/you
-   ```
+    ```shell
+    curl -i http://localhost:8888/greet/from/you
+    ```
 
-      返回如下：
+    返回如下：
 
-   ```http
-   HTTP/1.1 200 OK
-   Date: Sun, 30 Aug 2020 15:32:35 GMT
-   Content-Length: 0
-   ```
+    ```http
+    HTTP/1.1 200 OK
+    Content-Type: application/json
+	Date: Thu, 22 Oct 2020 14:03:18 GMT
+	Content-Length: 14
 
-      编写业务代码：
+	{"message":""}
+    ```
 
-      * api文件定义了服务对外暴露的路由，可参考[api规范](https://github.com/tal-tech/zero-doc/blob/main/doc/goctl.md)
-      * 可以在servicecontext.go里面传递依赖给logic，比如mysql, redis等
-      * 在api定义的get/post/put/delete等请求对应的logic里增加业务处理逻辑
+    编写业务代码：
 
-3. 可以根据api文件生成前端需要的Java, TypeScript, Dart, JavaScript代码
+      * api 文件定义了服务对外暴露的路由，可参考 [api 规范](https://github.com/tal-tech/zero-doc/blob/main/doc/goctl.md)
+      * 可以在 servicecontext.go 里面传递依赖给 logic，比如 mysql, redis 等
+      * 在 api 定义的 get/post/put/delete 等请求对应的 logic 里增加业务处理逻辑
 
-      ```shell
-      goctl api java -api greet.api -dir greet
-      goctl api dart -api greet.api -dir greet
-      ...
-      ```
+3. 可以根据 api 文件生成前端需要的 Java, TypeScript, Dart, JavaScript 代码
+
+    ```shell
+    goctl api java -api greet.api -dir greet
+    goctl api dart -api greet.api -dir greet
+    ...
+    ```
 
 ## 6. Benchmark
 
-![benchmark](https://github.com/tal-tech/zero-doc/blob/main/doc/images/benchmark.png)
+![benchmark](https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/benchmark.png)
 
 [测试代码见这里](https://github.com/smallnest/go-web-framework-benchmark)
 
 ## 7. 文档
 
-* API文档 (逐步完善中)
+* API 文档 (逐步完善中)
 
   [https://www.yuque.com/tal-tech/go-zero](https://www.yuque.com/tal-tech/go-zero)
 
-* awesome系列
+* awesome 系列
   * [快速构建高并发微服务](https://github.com/tal-tech/zero-doc/blob/main/doc/shorturl.md)
-  * [快速构建高并发微服务-多RPC版](https://github.com/tal-tech/zero-doc/blob/main/doc/bookstore.md)
-  * [goctl使用帮助](https://github.com/tal-tech/zero-doc/blob/main/doc/goctl.md)
-  * [通过MapReduce降低服务响应时间](https://github.com/tal-tech/zero-doc/blob/main/doc/mapreduce.md)
+  * [快速构建高并发微服务 - 多 RPC 版](https://github.com/tal-tech/zero-doc/blob/main/doc/bookstore.md)
+  * [goctl 使用帮助](https://github.com/tal-tech/zero-doc/blob/main/doc/goctl.md)
+  * [通过 MapReduce 降低服务响应时间](https://github.com/tal-tech/zero-doc/blob/main/doc/mapreduce.md)
   * [关键字替换和敏感词过滤工具](https://github.com/tal-tech/zero-doc/blob/main/doc/keywords.md)
   * [进程内缓存使用方法](https://github.com/tal-tech/zero-doc/blob/main/doc/collection.md)
   * [防止缓存击穿之进程内共享调用](https://github.com/tal-tech/zero-doc/blob/main/doc/sharedcalls.md)
-  * [基于prometheus的微服务指标监控](https://github.com/tal-tech/zero-doc/blob/main/doc/metric.md)
+  * [基于 prometheus 的微服务指标监控](https://github.com/tal-tech/zero-doc/blob/main/doc/metric.md)
   * [文本序列化和反序列化](https://github.com/tal-tech/zero-doc/blob/main/doc/mapping.md)
-  * [快速构建jwt鉴权认证](https://github.com/tal-tech/zero-doc/blob/main/doc/jwt.md)
+  * [快速构建 jwt 鉴权认证](https://github.com/tal-tech/zero-doc/blob/main/doc/jwt.md)
 
 ## 9. 微信交流群
 
-加群之前有劳给一个star，一个小小的star是作者们回答海量问题的动力。
+加群之前有劳给一个 star，一个小小的 star 是作者们回答海量问题的动力。
 
 如果文档中未能覆盖的任何疑问，欢迎您在群里提出，我们会尽快答复。
 
 您可以在群内提出使用中需要改进的地方，我们会考虑合理性并尽快修改。
 
-如果您发现bug请及时提issue，我们会尽快确认并修改。
+如果您发现 bug 请及时提 issue，我们会尽快确认并修改。
 
 <!-- 扫码后请加群主，便于我邀请您进讨论群，并请退出扫码网关群，谢谢！-->
 
+开源中国年度评选，给go-zero投上一票：[https://www.oschina.net/p/go-zero](https://www.oschina.net/p/go-zero)
+
 <img src="https://raw.githubusercontent.com/tal-tech/zero-doc/main/doc/images/wechat.jpg" alt="wechat" width="300" />

tools/goctl/api/apigen/gen.go

@@ -15,8 +15,8 @@ import (
 const apiTemplate = `info(
 	title: // TODO: add title
 	desc: // TODO: add description
-	author: {{.gitUser}}
-	email: {{.gitEmail}}
+	author: "{{.gitUser}}"
+	email: "{{.gitEmail}}"
 )
 
 type request struct {
@@ -28,14 +28,10 @@ type response struct {
 }
 
 service {{.serviceName}} {
-	@server(
-		handler: // TODO: set handler name and delete this comment
-	)
+	@handler // TODO: set handler name and delete this comment
 	get /users/id/:userId(request) returns(response)
 
-	@server(
-		handler: // TODO: set handler name and delete this comment
-	)
+	@handler // TODO: set handler name and delete this comment
 	post /users/create(request)
 }
 `

tools/goctl/api/format/format.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"go/format"
+	"go/scanner"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -22,39 +23,79 @@ var (
 )
 
 func GoFormatApi(c *cli.Context) error {
-	dir := c.String("dir")
-	if len(dir) == 0 {
-		return errors.New("missing -dir")
-	}
-
-	printToConsole := c.Bool("p")
+	useStdin := c.Bool("stdin")
 
 	var be errorx.BatchError
-	err := filepath.Walk(dir, func(path string, fi os.FileInfo, errBack error) (err error) {
-		if strings.HasSuffix(path, ".api") {
-			err := ApiFormat(path, printToConsole)
-			if err != nil {
-				be.Add(util.WrapErr(err, fi.Name()))
-			}
+	if useStdin {
+		if err := ApiFormatByStdin(); err != nil {
+			be.Add(err)
 		}
-		return nil
-	})
-	be.Add(err)
+	} else {
+		dir := c.String("dir")
+		if len(dir) == 0 {
+			return errors.New("missing -dir")
+		}
+
+		_, err := os.Lstat(dir)
+		if err != nil {
+			return errors.New(dir + ": No such file or directory")
+		}
+
+		err = filepath.Walk(dir, func(path string, fi os.FileInfo, errBack error) (err error) {
+			if strings.HasSuffix(path, ".api") {
+				if err := ApiFormatByPath(path); err != nil {
+					be.Add(util.WrapErr(err, fi.Name()))
+				}
+			}
+			return nil
+		})
+		be.Add(err)
+	}
 	if be.NotNil() {
-		errs := be.Err().Error()
-		fmt.Println(errs)
+		scanner.PrintError(os.Stderr, be.Err())
 		os.Exit(1)
 	}
 	return be.Err()
 }
 
-func ApiFormat(path string, printToConsole bool) error {
-	data, err := ioutil.ReadFile(path)
+func ApiFormatByStdin() error {
+	data, err := ioutil.ReadAll(os.Stdin)
 	if err != nil {
 		return err
 	}
 
-	r := reg.ReplaceAllStringFunc(string(data), func(m string) string {
+	result, err := apiFormat(string(data))
+	if err != nil {
+		return err
+	}
+
+	_, err = fmt.Print(result)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func ApiFormatByPath(apiFilePath string) error {
+	data, err := ioutil.ReadFile(apiFilePath)
+	if err != nil {
+		return err
+	}
+
+	result, err := apiFormat(string(data))
+	if err != nil {
+		return err
+	}
+
+	if err := ioutil.WriteFile(apiFilePath, []byte(result), os.ModePerm); err != nil {
+		return err
+	}
+	return nil
+}
+
+func apiFormat(data string) (string, error) {
+
+	r := reg.ReplaceAllStringFunc(data, func(m string) string {
 		parts := reg.FindStringSubmatch(m)
 		if len(parts) < 2 {
 			return m
@@ -67,11 +108,11 @@ func ApiFormat(path string, printToConsole bool) error {
 
 	apiStruct, err := parser.ParseApi(r)
 	if err != nil {
-		return err
+		return "", err
 	}
 	info := strings.TrimSpace(apiStruct.Info)
 	if len(apiStruct.Service) == 0 {
-		return nil
+		return data, nil
 	}
 
 	fs, err := format.Source([]byte(strings.TrimSpace(apiStruct.StructBody)))
@@ -81,16 +122,16 @@ func ApiFormat(path string, printToConsole bool) error {
 		if lineNumber > 0 {
 			ln, err := strconv.ParseInt(str[:lineNumber], 10, 64)
 			if err != nil {
-				return err
+				return "", err
 			}
 			pn := 0
 			if len(info) > 0 {
 				pn = countRune(info, '\n') + 1
 			}
 			number := int(ln) + pn + 1
-			return errors.New(fmt.Sprintf("line: %d, %s", number, str[lineNumber+1:]))
+			return "", errors.New(fmt.Sprintf("line: %d, %s", number, str[lineNumber+1:]))
 		}
-		return err
+		return "", err
 	}
 
 	var result string
@@ -107,11 +148,7 @@ func ApiFormat(path string, printToConsole bool) error {
 		result += strings.TrimSpace(apiStruct.Service) + "\n\n"
 	}
 
-	if printToConsole {
-		_, err := fmt.Print(result)
-		return err
-	}
-	return ioutil.WriteFile(path, []byte(result), os.ModePerm)
+	return result, nil
 }
 
 func countRune(s string, r rune) int {

tools/goctl/api/gogen/gen.go

@@ -66,7 +66,7 @@ func DoGenProject(apiFile, dir string, force bool) error {
 		return err
 	}
 
-	if err = apiformat.ApiFormat(apiFile, false); err != nil {
+	if err := apiformat.ApiFormatByPath(apiFile); err != nil {
 		return err
 	}
 

tools/goctl/api/gogen/gen_test.go

@@ -178,6 +178,13 @@ service A-api {
 }
 `
 
+const apiHasNoRequest = `
+service A-api {
+  @handler GreetHandler
+  post /greet/ping ()
+}
+`
+
 func TestParser(t *testing.T) {
 	filename := "greet.api"
 	err := ioutil.WriteFile(filename, []byte(testApiTemplate), os.ModePerm)
@@ -311,6 +318,21 @@ func TestApiHasJwtAndMiddleware(t *testing.T) {
 	validate(t, filename)
 }
 
+func TestApiHasNoRequestBody(t *testing.T) {
+	filename := "greet.api"
+	err := ioutil.WriteFile(filename, []byte(apiHasNoRequest), os.ModePerm)
+	assert.Nil(t, err)
+	defer os.Remove(filename)
+
+	parser, err := parser.NewParser(filename)
+	assert.Nil(t, err)
+
+	_, err = parser.Parse()
+	assert.Nil(t, err)
+
+	validate(t, filename)
+}
+
 func validate(t *testing.T, api string) {
 	dir := "_go"
 	err := DoGenProject(api, dir, true)

tools/goctl/api/gogen/genhandlers.go

@@ -23,14 +23,14 @@ import (
 
 func {{.HandlerName}}(ctx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var req types.{{.RequestType}}
+		{{if .HasRequest}}var req types.{{.RequestType}}
 		if err := httpx.Parse(r, &req); err != nil {
 			httpx.Error(w, err)
 			return
-		}
+		}{{end}}
 
 		l := logic.New{{.LogicType}}(r.Context(), ctx)
-		{{if .HasResp}}resp, {{end}}err := l.{{.Call}}(req)
+		{{if .HasResp}}resp, {{end}}err := l.{{.Call}}({{if .HasRequest}}req{{end}})
 		if err != nil {
 			httpx.Error(w, err)
 		} else {
@@ -47,6 +47,7 @@ type Handler struct {
 	LogicType      string
 	Call           string
 	HasResp        bool
+	HasRequest     bool
 }
 
 func genHandler(dir string, group spec.Group, route spec.Route) error {
@@ -71,6 +72,7 @@ func genHandler(dir string, group spec.Group, route spec.Route) error {
 		LogicType:      strings.TrimSuffix(strings.Title(handler), "Handler") + "Logic",
 		Call:           strings.Title(strings.TrimSuffix(handler, "Handler")),
 		HasResp:        len(route.ResponseType.Name) > 0,
+		HasRequest:     len(route.RequestType.Name) > 0,
 	})
 }
 

tools/goctl/api/gogen/genmiddleware.go

@@ -0,0 +1,59 @@
+package gogen
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+
+	"github.com/tal-tech/go-zero/tools/goctl/api/util"
+)
+
+var middlewareImplementCode = `
+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)
+	}	
+}
+`
+
+func genMiddleware(dir string, middlewares []string) error {
+	for _, item := range middlewares {
+		filename := strings.TrimSuffix(strings.ToLower(item), "middleware") + "middleware" + ".go"
+		fp, created, err := util.MaybeCreateFile(dir, middlewareDir, filename)
+		if err != nil {
+			return err
+		}
+		if !created {
+			return nil
+		}
+		defer fp.Close()
+
+		name := strings.TrimSuffix(item, "Middleware") + "Middleware"
+		t := template.Must(template.New("contextTemplate").Parse(middlewareImplementCode))
+		buffer := new(bytes.Buffer)
+		err = t.Execute(buffer, map[string]string{
+			"name": strings.Title(name),
+		})
+		if err != nil {
+			return nil
+		}
+		formatCode := formatCode(buffer.String())
+		_, err = fp.WriteString(formatCode)
+		return err
+	}
+	return nil
+}

tools/goctl/api/gogen/gensvc.go

@@ -3,6 +3,7 @@ package gogen
 import (
 	"bytes"
 	"fmt"
+	"strings"
 	"text/template"
 
 	"github.com/tal-tech/go-zero/tools/goctl/api/spec"
@@ -25,8 +26,12 @@ type ServiceContext struct {
 }
 
 func NewServiceContext(c {{.config}}) *ServiceContext {
-	return &ServiceContext{Config: c}
+	return &ServiceContext{
+		Config: c, 
+		{{.middlewareAssignment}}
+	}
 }
+
 `
 )
 
@@ -57,21 +62,32 @@ func genServiceContext(dir string, api *spec.ApiSpec) error {
 	}
 
 	var middlewareStr string
-	for _, item := range getMiddleware(api) {
+	var middlewareAssignment string
+	var middlewares = getMiddleware(api)
+	err = genMiddleware(dir, middlewares)
+	if err != nil {
+		return err
+	}
+
+	for _, item := range middlewares {
 		middlewareStr += fmt.Sprintf("%s rest.Middleware\n", item)
+		name := strings.TrimSuffix(item, "Middleware") + "Middleware"
+		middlewareAssignment += fmt.Sprintf("%s: %s,\n", item, fmt.Sprintf("middleware.New%s().%s", strings.Title(name), "Handle"))
 	}
 
 	var configImport = "\"" + ctlutil.JoinPackages(parentPkg, configDir) + "\""
 	if len(middlewareStr) > 0 {
-		configImport += fmt.Sprintf("\n\"%s/rest\"", vars.ProjectOpenSourceUrl)
+		configImport += "\n\t\"" + ctlutil.JoinPackages(parentPkg, middlewareDir) + "\""
+		configImport += fmt.Sprintf("\n\t\"%s/rest\"", vars.ProjectOpenSourceUrl)
 	}
 
 	t := template.Must(template.New("contextTemplate").Parse(text))
 	buffer := new(bytes.Buffer)
 	err = t.Execute(buffer, map[string]string{
-		"configImport": configImport,
-		"config":       "config.Config",
-		"middleware":   middlewareStr,
+		"configImport":         configImport,
+		"config":               "config.Config",
+		"middleware":           middlewareStr,
+		"middlewareAssignment": middlewareAssignment,
 	})
 	if err != nil {
 		return nil

tools/goctl/api/gogen/vars.go

@@ -7,6 +7,7 @@ const (
 	contextDir    = interval + "svc"
 	handlerDir    = interval + "handler"
 	logicDir      = interval + "logic"
+	middlewareDir = interval + "middleware"
 	typesDir      = interval + typesPacket
 	groupProperty = "group"
 )

tools/goctl/api/parser/util.go

@@ -133,7 +133,7 @@ func isTypeBeginLine(line string) bool {
 }
 
 func isServiceBeginLine(line string) bool {
-	return strings.HasPrefix(line, "@server(") || (strings.HasPrefix(line, "service") && strings.HasSuffix(line, "{"))
+	return strings.HasPrefix(line, "@server") || (strings.HasPrefix(line, "service") && strings.HasSuffix(line, "{"))
 }
 
 func lineBeginOfService(api string) int {

tools/goctl/configgen/genconfig.go

@@ -42,12 +42,14 @@ func GenConfigCommand(c *cli.Context) error {
 	if err != nil {
 		return errors.New("abs failed: " + c.String("path"))
 	}
+
 	goModPath, hasFound := util.FindGoModPath(path)
 	if !hasFound {
 		return errors.New("go mod not initial")
 	}
+
 	path = strings.TrimSuffix(path, "/config.go")
-	location := path + "/tmp"
+	location := filepath.Join(path, "tmp")
 	err = os.MkdirAll(location, os.ModePerm)
 	if err != nil {
 		return err
@@ -76,10 +78,12 @@ func GenConfigCommand(c *cli.Context) error {
 	if err != nil {
 		panic(err)
 	}
+
 	path, err = os.Getwd()
 	if err != nil {
 		panic(err)
 	}
+
 	err = os.Rename(filepath.Dir(goPath)+"/config.yaml", path+"/config.yaml")
 	if err != nil {
 		panic(err)

tools/goctl/goctl.go

@@ -51,15 +51,16 @@ var (
 							Name:  "dir",
 							Usage: "the format target dir",
 						},
-						cli.BoolFlag{
-							Name:  "p",
-							Usage: "print result to console",
-						},
 						cli.BoolFlag{
 							Name:     "iu",
 							Usage:    "ignore update",
 							Required: false,
 						},
+						cli.BoolFlag{
+							Name:     "stdin",
+							Usage:    "use stdin to input api doc content, press \"ctrl + d\" to send EOF",
+							Required: false,
+						},
 					},
 					Action: format.GoFormatApi,
 				},
@@ -269,12 +270,16 @@ var (
 							Flags: []cli.Flag{
 								cli.StringFlag{
 									Name:  "src, s",
-									Usage: "the file path of the ddl source file",
+									Usage: "the path or path globbing patterns of the ddl",
 								},
 								cli.StringFlag{
 									Name:  "dir, d",
 									Usage: "the target dir",
 								},
+								cli.StringFlag{
+									Name:  "style",
+									Usage: "the file naming style, lower|camel|underline,default is lower",
+								},
 								cli.BoolFlag{
 									Name:  "cache, c",
 									Usage: "generate code with cache [optional]",
@@ -296,7 +301,7 @@ var (
 								},
 								cli.StringFlag{
 									Name:  "table, t",
-									Usage: `source table,tables separated by commas,like "user,course`,
+									Usage: `the table or table globbing patterns in the database`,
 								},
 								cli.BoolFlag{
 									Name:  "cache, c",
@@ -306,6 +311,10 @@ var (
 									Name:  "dir, d",
 									Usage: "the target dir",
 								},
+								cli.StringFlag{
+									Name:  "style",
+									Usage: "the file naming style, lower|camel|underline,default is lower",
+								},
 								cli.BoolFlag{
 									Name:  "idea",
 									Usage: "for idea plugin [optional]",

tools/goctl/k8s/deployment.go

@@ -1,6 +1,6 @@
 package k8s
 
-var apiRpcTmeplate = `apiVersion: apps/v1beta2
+var apiRpcTmeplate = `apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: {{.name}}

tools/goctl/model/sql/README.MD

@@ -7,7 +7,7 @@ goctl model 为go-zero下的工具模块中的组件之一，目前支持识别m
 * 通过ddl生成
 
     ```shell script
-    goctl model mysql ddl -src="./sql/user.sql" -dir="./sql/model" -c=true
+    goctl model mysql ddl -src="./*.sql" -dir="./sql/model" -c=true
     ```
 
     执行上述命令后即可快速生成CURD代码。
@@ -21,7 +21,7 @@ goctl model 为go-zero下的工具模块中的组件之一，目前支持识别m
 * 通过datasource生成
 
     ```shell script
-    goctl model mysql datasource -url="user:password@tcp(127.0.0.1:3306)/database" -table="table1,table2"  -dir="./model"
+    goctl model mysql datasource -url="user:password@tcp(127.0.0.1:3306)/database" -table="*"  -dir="./model"
     ```
 
 * 生成代码示例
@@ -205,14 +205,49 @@ OPTIONS:
   * ddl
 
 	```shell script
-	goctl model mysql -src={filename} -dir={dir} -cache=true
+	goctl model mysql -src={patterns} -dir={dir} -cache=true
+	```
+
+	help
+
+	```
+	NAME:
+		goctl model mysql ddl - generate mysql model from ddl
+
+		USAGE:
+		goctl model mysql ddl [command options] [arguments...]
+
+		OPTIONS:
+		--src value, -s value  the path or path globbing patterns of the ddl
+		--dir value, -d value  the target dir
+		--cache, -c            generate code with cache [optional]
+		--idea                 for idea plugin [optional]
 	```
 
   * datasource
 
 	```shell script
-	goctl model mysql datasource -url={datasource} -table={tables}  -dir={dir} -cache=true
+	goctl model mysql datasource -url={datasource} -table={patterns}  -dir={dir} -cache=true
 	```
+
+	help
+
+	```
+		NAME:
+		goctl model mysql datasource - generate model from datasource
+
+		USAGE:
+		goctl model mysql datasource [command options] [arguments...]
+
+		OPTIONS:
+		--url value              the data source of database,like "root:password@tcp(127.0.0.1:3306)/database
+		--table value, -t value  the table or table globbing patterns in the database
+		--cache, -c              generate code with cache [optional]
+		--dir value, -d value    the target dir
+		--idea                   for idea plugin [optional]
+	```
+
+	示例用法请参考[用法](./example/generator.sh)
   
   目前仅支持redis缓存，如果选择带缓存模式，即生成的`FindOne(ByXxx)`&`Delete`代码会生成带缓存逻辑的代码，目前仅支持单索引字段（除全文索引外），对于联合索引我们默认认为不需要带缓存，且不属于通用型代码，因此没有放在代码生成行列，如example中user表中的`id`、`name`、`mobile`字段均属于单字段索引。
 
@@ -221,26 +256,26 @@ OPTIONS:
   * ddl
   
       ```shell script
-        goctl model -src={filename} -dir={dir}
+        goctl model -src={patterns} -dir={dir}
       ```
 
   * datasource
   
       ```shell script
-        goctl model mysql datasource -url={datasource} -table={tables}  -dir={dir}
+        goctl model mysql datasource -url={datasource} -table={patterns}  -dir={dir}
       ```
 
   or
   * ddl
 
       ```shell script
-        goctl model -src={filename} -dir={dir} -cache=false
+        goctl model -src={patterns} -dir={dir} -cache=false
       ```
 
   * datasource
   
       ```shell script
-        goctl model mysql datasource -url={datasource} -table={tables}  -dir={dir} -cache=false
+        goctl model mysql datasource -url={datasource} -table={patterns}  -dir={dir} -cache=false
       ```
   
 生成代码仅基本的CURD结构。
@@ -265,8 +300,3 @@ OPTIONS:
   
   目前，我认为除了基本的CURD外，其他的代码均属于<i>业务型</i>代码，这个我觉得开发人员根据业务需要进行编写更好。
 
-## QA
-
-* goctl model除了命令行模式，支持插件模式吗？
-
-  很快支持idea插件。

tools/goctl/model/sql/command/command.go

@@ -1,15 +1,18 @@
 package command
 
 import (
+	"errors"
+	"fmt"
 	"io/ioutil"
 	"path/filepath"
 	"strings"
 
-	"github.com/tal-tech/go-zero/core/collection"
+	"github.com/go-sql-driver/mysql"
 	"github.com/tal-tech/go-zero/core/logx"
 	"github.com/tal-tech/go-zero/core/stores/sqlx"
 	"github.com/tal-tech/go-zero/tools/goctl/model/sql/gen"
 	"github.com/tal-tech/go-zero/tools/goctl/model/sql/model"
+	"github.com/tal-tech/go-zero/tools/goctl/model/sql/util"
 	"github.com/tal-tech/go-zero/tools/goctl/util/console"
 	"github.com/urfave/cli"
 )
@@ -19,6 +22,7 @@ const (
 	flagDir   = "dir"
 	flagCache = "cache"
 	flagIdea  = "idea"
+	flagStyle = "style"
 	flagUrl   = "url"
 	flagTable = "table"
 )
@@ -28,17 +32,35 @@ func MysqlDDL(ctx *cli.Context) error {
 	dir := ctx.String(flagDir)
 	cache := ctx.Bool(flagCache)
 	idea := ctx.Bool(flagIdea)
+	namingStyle := strings.TrimSpace(ctx.String(flagStyle))
 	log := console.NewConsole(idea)
-	fileSrc, err := filepath.Abs(src)
+	src = strings.TrimSpace(src)
+	if len(src) == 0 {
+		return errors.New("expected path or path globbing patterns, but nothing found")
+	}
+
+	switch namingStyle {
+	case gen.NamingLower, gen.NamingCamel, gen.NamingUnderline:
+	case "":
+		namingStyle = gen.NamingLower
+	default:
+		return fmt.Errorf("unexpected naming style: %s", namingStyle)
+	}
+
+	files, err := util.MatchFiles(src)
 	if err != nil {
 		return err
 	}
-	data, err := ioutil.ReadFile(fileSrc)
-	if err != nil {
-		return err
+
+	var source []string
+	for _, file := range files {
+		data, err := ioutil.ReadFile(file)
+		if err != nil {
+			return err
+		}
+		source = append(source, string(data))
 	}
-	source := string(data)
-	generator := gen.NewDefaultGenerator(source, dir, gen.WithConsoleOption(log))
+	generator := gen.NewDefaultGenerator(strings.Join(source, "\n"), dir, namingStyle, gen.WithConsoleOption(log))
 	err = generator.Start(cache)
 	if err != nil {
 		log.Error("%v", err)
@@ -51,36 +73,72 @@ func MyDataSource(ctx *cli.Context) error {
 	dir := strings.TrimSpace(ctx.String(flagDir))
 	cache := ctx.Bool(flagCache)
 	idea := ctx.Bool(flagIdea)
-	table := strings.TrimSpace(ctx.String(flagTable))
+	namingStyle := strings.TrimSpace(ctx.String(flagStyle))
+	pattern := strings.TrimSpace(ctx.String(flagTable))
 	log := console.NewConsole(idea)
 	if len(url) == 0 {
-		log.Error("%v", "expected data source of mysql, but is empty")
+		log.Error("%v", "expected data source of mysql, but nothing found")
 		return nil
 	}
-	if len(table) == 0 {
-		log.Error("%v", "expected table(s), but nothing found")
+
+	if len(pattern) == 0 {
+		log.Error("%v", "expected table or table globbing patterns, but nothing found")
 		return nil
 	}
+
+	switch namingStyle {
+	case gen.NamingLower, gen.NamingCamel, gen.NamingUnderline:
+	case "":
+		namingStyle = gen.NamingLower
+	default:
+		return fmt.Errorf("unexpected naming style: %s", namingStyle)
+	}
+
+	cfg, err := mysql.ParseDSN(url)
+	if err != nil {
+		return err
+	}
+
 	logx.Disable()
 	conn := sqlx.NewMysql(url)
+	databaseSource := strings.TrimSuffix(url, "/"+cfg.DBName) + "/information_schema"
+	db := sqlx.NewMysql(databaseSource)
 	m := model.NewDDLModel(conn)
-	tables := collection.NewSet()
-	for _, item := range strings.Split(table, ",") {
-		item = strings.TrimSpace(item)
-		if len(item) == 0 {
+	im := model.NewInformationSchemaModel(db)
+
+	tables, err := im.GetAllTables(cfg.DBName)
+	if err != nil {
+		return err
+	}
+
+	var matchTables []string
+	for _, item := range tables {
+		match, err := filepath.Match(pattern, item)
+		if err != nil {
+			return err
+		}
+
+		if !match {
 			continue
 		}
-		tables.AddStr(item)
+
+		matchTables = append(matchTables, item)
 	}
-	ddl, err := m.ShowDDL(tables.KeysStr()...)
+	if len(matchTables) == 0 {
+		return errors.New("no tables matched")
+	}
+
+	ddl, err := m.ShowDDL(matchTables...)
 	if err != nil {
 		log.Error("%v", err)
 		return nil
 	}
-	generator := gen.NewDefaultGenerator(strings.Join(ddl, "\n"), dir, gen.WithConsoleOption(log))
+
+	generator := gen.NewDefaultGenerator(strings.Join(ddl, "\n"), dir, namingStyle, gen.WithConsoleOption(log))
 	err = generator.Start(cache)
 	if err != nil {
 		log.Error("%v", err)
 	}
+
 	return nil
 }

tools/goctl/model/sql/example/generator.sh

@@ -1,7 +1,11 @@
 #!/bin/bash
 
 # generate model with cache from ddl
-goctl model mysql ddl -src="./sql/user.sql" -dir="./sql/model" -c
+goctl model mysql ddl -src="./sql/*.sql" -dir="./sql/model/user" -c
 
 # generate model with cache from data source
-#goctl model mysql datasource -url="user:password@tcp(127.0.0.1:3306)/database" -table="table1,table2"  -dir="./model"
+#user=root
+#password=password
+#datasource=127.0.0.1:3306
+#database=test
+#goctl model mysql datasource -url="${user}:${password}@tcp(${datasource})/${database}" -table="*" -dir ./model

tools/goctl/model/sql/example/sql/user_1.sql

@@ -0,0 +1,15 @@
+-- 用户表 --
+CREATE TABLE `user1` (
+  `id` bigint(10) NOT NULL AUTO_INCREMENT,
+  `name` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '用户名称',
+  `password` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '用户密码',
+  `mobile` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '手机号',
+  `gender` char(5) COLLATE utf8mb4_general_ci NOT NULL COMMENT '男｜女｜未公开',
+  `nickname` varchar(255) COLLATE utf8mb4_general_ci DEFAULT '' COMMENT '用户昵称',
+  `create_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
+  `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `name_index` (`name`),
+  UNIQUE KEY `mobile_index` (`mobile`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+

tools/goctl/model/sql/gen/gen.go

@@ -17,6 +17,9 @@ import (
 const (
 	pwd             = "."
 	createTableFlag = `(?m)^(?i)CREATE\s+TABLE` // ignore case
+	NamingLower     = "lower"
+	NamingCamel     = "camel"
+	NamingUnderline = "underline"
 )
 
 type (
@@ -24,15 +27,17 @@ type (
 		source string
 		dir    string
 		console.Console
+		pkg         string
+		namingStyle string
 	}
 	Option func(generator *defaultGenerator)
 )
 
-func NewDefaultGenerator(source, dir string, opt ...Option) *defaultGenerator {
+func NewDefaultGenerator(source, dir, namingStyle string, opt ...Option) *defaultGenerator {
 	if dir == "" {
 		dir = pwd
 	}
-	generator := &defaultGenerator{source: source, dir: dir}
+	generator := &defaultGenerator{source: source, dir: dir, namingStyle: namingStyle}
 	var optionList []Option
 	optionList = append(optionList, newDefaultOption())
 	optionList = append(optionList, opt...)
@@ -59,6 +64,8 @@ func (g *defaultGenerator) Start(withCache bool) error {
 	if err != nil {
 		return err
 	}
+	g.dir = dirAbs
+	g.pkg = filepath.Base(dirAbs)
 	err = util.MkdirIfNotExist(dirAbs)
 	if err != nil {
 		return err
@@ -69,7 +76,14 @@ func (g *defaultGenerator) Start(withCache bool) error {
 	}
 
 	for tableName, code := range modelList {
-		name := fmt.Sprintf("%smodel.go", strings.ToLower(stringx.From(tableName).ToCamel()))
+		tn := stringx.From(tableName)
+		name := fmt.Sprintf("%smodel.go", strings.ToLower(tn.ToCamel()))
+		switch g.namingStyle {
+		case NamingCamel:
+			name = fmt.Sprintf("%sModel.go", tn.ToCamel())
+		case NamingUnderline:
+			name = fmt.Sprintf("%s_model.go", tn.ToSnake())
+		}
 		filename := filepath.Join(dirAbs, name)
 		if util.FileExists(filename) {
 			g.Warning("%s already exists, ignored.", name)
@@ -82,12 +96,18 @@ func (g *defaultGenerator) Start(withCache bool) error {
 	}
 	// generate error file
 	filename := filepath.Join(dirAbs, "vars.go")
-	if !util.FileExists(filename) {
-		err = ioutil.WriteFile(filename, []byte(template.Error), os.ModePerm)
-		if err != nil {
-			return err
-		}
+	text, err := util.LoadTemplate(category, errTemplateFile, template.Error)
+	if err != nil {
+		return err
 	}
+
+	err = util.With("vars").Parse(text).SaveTo(map[string]interface{}{
+		"pkg": g.pkg,
+	}, filename, false)
+	if err != nil {
+		return err
+	}
+
 	g.Success("Done.")
 	return nil
 }
@@ -119,8 +139,12 @@ type (
 )
 
 func (g *defaultGenerator) genModel(in parser.Table, withCache bool) (string, error) {
+	text, err := util.LoadTemplate(category, modelTemplateFile, template.Model)
+	if err != nil {
+		return "", err
+	}
 	t := util.With("model").
-		Parse(template.Model).
+		Parse(text).
 		GoFmt(true)
 
 	m, err := genCacheKeys(in)
@@ -188,6 +212,7 @@ func (g *defaultGenerator) genModel(in parser.Table, withCache bool) (string, er
 	}
 
 	output, err := t.Execute(map[string]interface{}{
+		"pkg":         g.pkg,
 		"imports":     importsCode,
 		"vars":        varsCode,
 		"types":       typesCode,

tools/goctl/model/sql/gen/gen_test.go

@@ -0,0 +1,34 @@
+package gen
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tal-tech/go-zero/core/logx"
+)
+
+var (
+	source = "CREATE TABLE `test_user_info` (\n  `id` bigint NOT NULL AUTO_INCREMENT,\n  `nanosecond` bigint NOT NULL DEFAULT '0',\n  `data` varchar(255) DEFAULT '',\n  `create_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP,\n  `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,\n  PRIMARY KEY (`id`),\n  UNIQUE KEY `nanosecond_unique` (`nanosecond`)\n) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;"
+)
+
+func TestCacheModel(t *testing.T) {
+	logx.Disable()
+	_ = Clean()
+	g := NewDefaultGenerator(source, "./testmodel/cache", NamingLower)
+	err := g.Start(true)
+	assert.Nil(t, err)
+	g = NewDefaultGenerator(source, "./testmodel/nocache", NamingLower)
+	err = g.Start(false)
+	assert.Nil(t, err)
+}
+
+func TestNamingModel(t *testing.T) {
+	logx.Disable()
+	_ = Clean()
+	g := NewDefaultGenerator(source, "./testmodel/camel", NamingCamel)
+	err := g.Start(true)
+	assert.Nil(t, err)
+	g = NewDefaultGenerator(source, "./testmodel/snake", NamingUnderline)
+	err = g.Start(true)
+	assert.Nil(t, err)
+}

tools/goctl/model/sql/gen/new.go

@@ -14,6 +14,7 @@ func genNew(table Table, withCache bool) (string, error) {
 	output, err := util.With("new").
 		Parse(text).
 		Execute(map[string]interface{}{
+			"table":                 table.Name.Source(),
 			"withCache":             withCache,
 			"upperStartCamelObject": table.Name.ToCamel(),
 		})

tools/goctl/model/sql/gen/template.go

@@ -24,6 +24,7 @@ const (
 	typesTemplateFile                     = "types.tpl"
 	updateTemplateFile                    = "update.tpl"
 	varTemplateFile                       = "var.tpl"
+	errTemplateFile                       = "err.tpl"
 )
 
 var templates = map[string]string{
@@ -41,6 +42,7 @@ var templates = map[string]string{
 	typesTemplateFile:                     template.Types,
 	updateTemplateFile:                    template.Update,
 	varTemplateFile:                       template.Vars,
+	errTemplateFile:                       template.Error,
 }
 
 func GenTemplates(_ *cli.Context) error {

tools/goctl/model/sql/model/informationschemamodel.go

@@ -0,0 +1,25 @@
+package model
+
+import (
+	"github.com/tal-tech/go-zero/core/stores/sqlx"
+)
+
+type (
+	InformationSchemaModel struct {
+		conn sqlx.SqlConn
+	}
+)
+
+func NewInformationSchemaModel(conn sqlx.SqlConn) *InformationSchemaModel {
+	return &InformationSchemaModel{conn: conn}
+}
+
+func (m *InformationSchemaModel) GetAllTables(database string) ([]string, error) {
+	query := `select TABLE_NAME from TABLES where TABLE_SCHEMA = ?`
+	var tables []string
+	err := m.conn.QueryRows(&tables, query, database)
+	if err != nil {
+		return nil, err
+	}
+	return tables, nil
+}

tools/goctl/model/sql/parser/error.go

@@ -7,5 +7,5 @@ import (
 var (
 	unSupportDDL        = errors.New("unexpected type")
 	tableBodyIsNotFound = errors.New("create table spec not found")
-	errPrimaryKey       = errors.New("unexpected joint primary key")
+	errPrimaryKey       = errors.New("unexpected join primary key")
 )

tools/goctl/model/sql/template/delete.go

@@ -9,9 +9,9 @@ func (m *{{.upperStartCamelObject}}Model) Delete({{.lowerStartCamelPrimaryKey}}
 
 	{{.keys}}
     _, err {{if .containsIndexCache}}={{else}}:={{end}} m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
-		query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
+		query := fmt.Sprintf("delete from %s where {{.originalPrimaryKey}} = ?", m.table)
 		return conn.Exec(query, {{.lowerStartCamelPrimaryKey}})
-	}, {{.keyValues}}){{else}}query := ` + "`" + `delete from ` + "` +" + ` m.table + ` + " `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
+	}, {{.keyValues}}){{else}}query := fmt.Sprintf("delete from %s where {{.originalPrimaryKey}} = ?", m.table)
 		_,err:=m.conn.Exec(query, {{.lowerStartCamelPrimaryKey}}){{end}}
 	return err
 }

tools/goctl/model/sql/template/errors.go

@@ -1,6 +1,6 @@
 package template
 
-var Error = `package model
+var Error = `package {{.pkg}}
 
 import "github.com/tal-tech/go-zero/core/stores/sqlx"
 

tools/goctl/model/sql/template/find.go

@@ -6,7 +6,7 @@ func (m *{{.upperStartCamelObject}}Model) FindOne({{.lowerStartCamelPrimaryKey}}
 	{{if .withCache}}{{.cacheKey}}
 	var resp {{.upperStartCamelObject}}
 	err := m.QueryRow(&resp, {{.cacheKeyVariable}}, func(conn sqlx.SqlConn, v interface{}) error {
-		query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalPrimaryKey}} = ? limit 1` + "`" + `
+		query :=  fmt.Sprintf("select %s from %s where {{.originalPrimaryKey}} = ? limit 1", {{.lowerStartCamelObject}}Rows, m.table)
 		return conn.QueryRow(v, query, {{.lowerStartCamelPrimaryKey}})
 	})
 	switch err {
@@ -16,7 +16,7 @@ func (m *{{.upperStartCamelObject}}Model) FindOne({{.lowerStartCamelPrimaryKey}}
 		return nil, ErrNotFound
 	default:
 		return nil, err
-	}{{else}}query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalPrimaryKey}} = ? limit 1` + "`" + `
+	}{{else}}query := fmt.Sprintf("select %s from %s where {{.originalPrimaryKey}} = ? limit 1", {{.lowerStartCamelObject}}Rows, m.table)
 	var resp {{.upperStartCamelObject}}
 	err := m.conn.QueryRow(&resp, query, {{.lowerStartCamelPrimaryKey}})
 	switch err {
@@ -36,7 +36,7 @@ func (m *{{.upperStartCamelObject}}Model) FindOneBy{{.upperField}}({{.in}}) (*{{
 	{{if .withCache}}{{.cacheKey}}
 	var resp {{.upperStartCamelObject}}
 	err := m.QueryRowIndex(&resp, {{.cacheKeyVariable}}, m.formatPrimary, func(conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
-		query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalField}} = ? limit 1` + "`" + `
+		query := fmt.Sprintf("select %s from %s where {{.originalField}} = ? limit 1", {{.lowerStartCamelObject}}Rows, m.table)
 		if err := conn.QueryRow(&resp, query, {{.lowerStartCamelField}}); err != nil {
 			return nil, err
 		}
@@ -51,7 +51,7 @@ func (m *{{.upperStartCamelObject}}Model) FindOneBy{{.upperField}}({{.in}}) (*{{
 		return nil, err
 	}
 }{{else}}var resp {{.upperStartCamelObject}}
-	query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalField}} limit 1` + "`" + `
+	query := fmt.Sprintf("select %s from %s where {{.originalField}} = ? limit 1", {{.lowerStartCamelObject}}Rows, m.table )
 	err := m.conn.QueryRow(&resp, query, {{.lowerStartCamelField}})
 	switch err {
 	case nil:
@@ -69,7 +69,7 @@ func (m *{{.upperStartCamelObject}}Model) formatPrimary(primary interface{}) str
 }
 
 func (m *{{.upperStartCamelObject}}Model) queryPrimary(conn sqlx.SqlConn, v, primary interface{}) error {
-	query := ` + "`" + `select ` + "`" + ` + {{.lowerStartCamelObject}}Rows + ` + "`" + ` from ` + "` + " + `m.table ` + " + `" + ` where {{.originalPrimaryField}} = ? limit 1` + "`" + `
+	query := fmt.Sprintf("select %s from %s where {{.originalPrimaryField}} = ? limit 1", {{.lowerStartCamelObject}}Rows, m.table )
 	return conn.QueryRow(v, query, primary)
 }
 `

tools/goctl/model/sql/template/import.go

@@ -16,6 +16,7 @@ var (
 `
 	ImportsNoCache = `import (
 	"database/sql"
+	"fmt"
 	"strings"
 	{{if .time}}"time"{{end}}
 

tools/goctl/model/sql/template/insert.go

@@ -4,11 +4,11 @@ var Insert = `
 func (m *{{.upperStartCamelObject}}Model) Insert(data {{.upperStartCamelObject}}) (sql.Result,error) {
 	{{if .withCache}}{{if .containsIndexCache}}{{.keys}}
     ret, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
-		query := ` + "`" + `insert into ` + "`" + ` + m.table + ` + "` (` + " + `{{.lowerStartCamelObject}}RowsExpectAutoSet` + " + `) values ({{.expression}})` " + `
+		query := fmt.Sprintf("insert into %s (%s) values ({{.expression}})", m.table, {{.lowerStartCamelObject}}RowsExpectAutoSet)
 		return conn.Exec(query, {{.expressionValues}})
-	}, {{.keyValues}}){{else}}query := ` + "`" + `insert into ` + "`" + ` + m.table + ` + "` (` + " + `{{.lowerStartCamelObject}}RowsExpectAutoSet` + " + `) values ({{.expression}})` " + `
+	}, {{.keyValues}}){{else}}query := fmt.Sprintf("insert into %s (%s) values ({{.expression}})", m.table, {{.lowerStartCamelObject}}RowsExpectAutoSet)
     ret,err:=m.ExecNoCache(query, {{.expressionValues}})
-	{{end}}{{else}}query := ` + "`" + `insert into ` + "`" + ` + m.table + ` + "` (` + " + `{{.lowerStartCamelObject}}RowsExpectAutoSet` + " + `) values ({{.expression}})` " + `
+	{{end}}{{else}}query := fmt.Sprintf("insert into %s (%s) values ({{.expression}})", m.table, {{.lowerStartCamelObject}}RowsExpectAutoSet)
     ret,err:=m.conn.Exec(query, {{.expressionValues}}){{end}}
 	return ret,err
 }

tools/goctl/model/sql/template/model.go

@@ -1,6 +1,6 @@
 package template
 
-var Model = `package model
+var Model = `package {{.pkg}}
 {{.imports}}
 {{.vars}}
 {{.types}}

tools/goctl/model/sql/template/new.go

@@ -1,10 +1,10 @@
 package template
 
 var New = `
-func New{{.upperStartCamelObject}}Model(conn sqlx.SqlConn,{{if .withCache}} c cache.CacheConf,{{end}} table string) *{{.upperStartCamelObject}}Model {
+func New{{.upperStartCamelObject}}Model(conn sqlx.SqlConn{{if .withCache}}, c cache.CacheConf{{end}}) *{{.upperStartCamelObject}}Model {
 	return &{{.upperStartCamelObject}}Model{
 		{{if .withCache}}CachedConn: sqlc.NewConn(conn, c){{else}}conn:conn{{end}},
-		table:      table,
+		table:      "{{.table}}",
 	}
 }
 `

tools/goctl/model/sql/template/update.go

@@ -1,13 +1,13 @@
 package template
 
 var Update = `
-func (m *{{.upperStartCamelObject}}Model) Update(data {{.upperStartCamelObject}}) (sql.Result,error) {
+func (m *{{.upperStartCamelObject}}Model) Update(data {{.upperStartCamelObject}}) error {
 	{{if .withCache}}{{.primaryCacheKey}}
-    ret, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
-		query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerStartCamelObject}}RowsWithPlaceHolder` + " + `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
+    _, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
+		query := fmt.Sprintf("update %s set %s where {{.originalPrimaryKey}} = ?", m.table, {{.lowerStartCamelObject}}RowsWithPlaceHolder)
 		return conn.Exec(query, {{.expressionValues}})
-	}, {{.primaryKeyVariable}}){{else}}query := ` + "`" + `update ` + "` +" + `m.table +` + "` " + `set ` + "` +" + `{{.lowerStartCamelObject}}RowsWithPlaceHolder` + " + `" + ` where {{.originalPrimaryKey}} = ?` + "`" + `
-    ret,err:=m.conn.Exec(query, {{.expressionValues}}){{end}}
-	return ret,err
+	}, {{.primaryKeyVariable}}){{else}}query := fmt.Sprintf("update %s set %s where {{.originalPrimaryKey}} = ?", m.table, {{.lowerStartCamelObject}}RowsWithPlaceHolder)
+    _,err:=m.conn.Exec(query, {{.expressionValues}}){{end}}
+	return err
 }
 `

tools/goctl/model/sql/util/match_test.go

@@ -0,0 +1,29 @@
+package util
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMatchFiles(t *testing.T) {
+	dir, err := filepath.Abs("./")
+	assert.Nil(t, err)
+
+	files, err := MatchFiles("./*.sql")
+	assert.Nil(t, err)
+	assert.Equal(t, []string{filepath.Join(dir, "studeat.sql"), filepath.Join(dir, "student.sql"), filepath.Join(dir, "xx.sql")}, files)
+
+	files, err = MatchFiles("./??.sql")
+	assert.Nil(t, err)
+	assert.Equal(t, []string{filepath.Join(dir, "xx.sql")}, files)
+
+	files, err = MatchFiles("./*.sq*")
+	assert.Nil(t, err)
+	assert.Equal(t, []string{filepath.Join(dir, "studeat.sql"), filepath.Join(dir, "student.sql"), filepath.Join(dir, "xx.sql"), filepath.Join(dir, "xx.sql1")}, files)
+
+	files, err = MatchFiles("./student.sql")
+	assert.Nil(t, err)
+	assert.Equal(t, []string{filepath.Join(dir, "student.sql")}, files)
+}

tools/goctl/model/sql/util/matcher.go

@@ -0,0 +1,38 @@
+package util
+
+import (
+	"io/ioutil"
+	"path/filepath"
+)
+
+// expression: globbing patterns
+func MatchFiles(in string) ([]string, error) {
+	dir, pattern := filepath.Split(in)
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	files, err := ioutil.ReadDir(abs)
+	if err != nil {
+		return nil, err
+	}
+	var res []string
+	for _, file := range files {
+		if file.IsDir() {
+			continue
+		}
+		name := file.Name()
+		match, err := filepath.Match(pattern, name)
+		if err != nil {
+			return nil, err
+		}
+
+		if !match {
+			continue
+		}
+
+		res = append(res, filepath.Join(abs, name))
+	}
+	return res, nil
+}

tools/goctl/rpc/gen/genmain.go

@@ -70,7 +70,7 @@ func (g *defaultRpcGenerator) genMain() error {
 		"srv":         srv,
 		"registers":   registers,
 		"imports":     strings.Join(imports, util.NL),
-	}, fileName, true)
+	}, fileName, false)
 }
 
 func (g *defaultRpcGenerator) genServer(pkg string, list []*parser.RpcService) (string, string) {