构建可持续迭代的 Golang 应用

1
2
3
4
5
6
7
8

.
├── LICENSE
├── README.md
├── go.mod
├── go.sum
├── gin.go
├── context.go
├── xxx.go

1
2
3
4
5

.
├── list/
├── progress/
├── table/
├── text

1
2
3
4
5
6
7
8
9

.
├── api
├── build
├── cmd
├── docs
├── internal
├── pkg
├── third_party
├── tools

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

//go:build tools

//go:generate go install github.com/swaggo/swag/cmd/swag
//go:generate go install github.com/fatih/gomodifytags
//go:generate go install go.uber.org/mock/mockgen
import (
	_ "github.com/swaggo/swag/cmd/swag"

	_ "github.com/fatih/gomodifytags"

	_ "go.uber.org/mock/mockgen"
)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

# 检测基本配置
run:
  # The default concurrency value is the number of available CPU.
  concurrency: 8
  # Timeout for analysis, e.g. 30s, 5m.
  # Default: 1m
  timeout: 5m
  tests: false
  # Which dirs to skip: issues from them won't be reported.
  skip-dirs:
    - test
    - third_party
  # Which files to skip: they will be analyzed, but issues from them won't be reported.
  skip-files:
    - _test.go
    - _mock.go
    - ".*\\.pb\\.go"
    - ".*\\.gen\\.go"
linters:
  disable-all: true
  enable: # please keep this alphabetized
    # Don't use soon to deprecated[1] linters that lead to false
    # https://github.com/golangci/golangci-lint/issues/1841
    - bodyclose
    - dogsled
    - dupl
    - errcheck
    - exportloopref
    - exhaustive
    - goconst
    - gocritic
    - gofmt
    # - gomnd
    - gocyclo
    # - gosec
    - gosimple
    - govet
    - ineffassign
    - misspell
    - nolintlint
    - nakedret
    - prealloc
    - predeclared
    - revive
    - staticcheck
    - stylecheck
    - thelper
    - tparallel
    - unconvert
    - unparam
    - whitespace
    - wsl
    # - unused

linters-settings: # please keep this alphabetized
  revive:
    ignore-generated-header: true
    severity: error
    confidence: 0.8
    errorCode: 2
    warningCode: 0
    rules:
      - name: atomic
        severity: warning
      - name: package-comments
      - name: unhandled-error
        arguments : ["fmt.Printf"]
      - name: blank-imports
      - name: context-as-argument
      - name: context-keys-type
      - name: dot-imports
      - name: error-return
      - name: error-strings
      - name: error-naming
      - name: exported
        severity: warning
        arguments:
          - disableStutteringCheck
      - name: if-return
      - name: increment-decrement
      - name: var-naming
      - name: var-declaration
      - name: package-comments
      - name: range
      - name: receiver-naming
      - name: time-naming
      - name: unexported-return
      - name: indent-error-flow
      - name: errorf
      - name: argument-limit
        arguments:
          - 6
      - name: function-result-limit
        arguments:
          - 3
      - name: empty-block
      - name: confusing-naming
      - name: superfluous-else
      #      - name: unused-parameter
      - name: unreachable-code
      - name: unnecessary-stmt
      - name: struct-tag
      - name: atomic
      - name: empty-lines
      - name: duplicated-imports
      - name: import-shadowing
      - name: confusing-results
      - name: modifies-parameter
      - name: redefines-builtin-id

  staticcheck:
    checks:
      - "all"
      - "-SA1019" # TODO(fix) Using a deprecated function, variable, constant or field
  stylecheck:
    checks:
      - "ST1019"  # Importing the same package multiple times.

  lll:
    line-length: 120
  gocyclo:
    # Minimal code complexity to report.
    # Default: 30 (but we recommend 10)
    min-complexity: 8

issues:
  # List of regexps of issue texts to exclude.
  include:
    - EXC0012  # EXC0012 revive: exported (.+) should have comment( \(or a comment on this block\))? or be unexported
    - EXC0013  # EXC0013 revive: package comment should be of the form "(.+)...
    - EXC0014  # EXC0014 revive: comment on exported (.+) should be of the form "(.+)..."
    - EXC0015  # EXC0015 revive: should have a package comment
  # Excluding configuration per-path, per-linter, per-text and per-source
  exclude-rules:
    # Exclude some `typecheck` messages.
    - linters:
        - typecheck
      text: "undeclared name:"
    - linters:
        - revive
      text: "var-naming: don't use an underscore in package name"
    # Exclude `lll` issues for long lines with `go:generate`.
    - linters:
        - lll
      source: "^//go:generate "
  # Fix found issues (if it's supported by the linter).
  fix: true
# output configuration options
output:
  # Format: colored-line-number|line-number|json|tab|checkstyle|code-climate|junit-xml|github-actions
  #
  # Multiple can be specified by separating them by comma, output can be provided
  # for each of them by separating format name and path by colon symbol.
  # Output path can be either `stdout`, `stderr` or path to the file to write to.
  # Example: "checkstyle:report.json,colored-line-number"
  #
  # Default: colored-line-number
  format: colored-line-number,github-actions
  # Print lines of code with issue.
  # Default: true
  print-issued-lines: false
  # Print linter name in the end of issue text.
  # Default: true
  print-linter-name: true
  # Make issues output unique by line.
  # Default: true
  uniq-by-line: true
  # Add a prefix to the output file references.
  # Default is no prefix.
  path-prefix: ""
  # Sort results by: filepath, line and column.
  sort-results: true

severity:
  # Set the default severity for issues.
  #
  # If severity rules are defined and the issues do not match or no severity is provided to the rule
  # this will be the default severity applied.
  # Severities should match the supported severity names of the selected out format.
  # - Code climate: https://docs.codeclimate.com/docs/issues#issue-severity
  # - Checkstyle: https://checkstyle.sourceforge.io/property_types.html#SeverityLevel
  # - GitHub: https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-error-message
  #
  # Default value is an empty string.
  default-severity: error
  # If set to true `severity-rules` regular expressions become case-sensitive.
  # Default: false
  case-sensitive: true
  # When a list of severity rules are provided, severity information will be added to lint issues.
  # Severity rules have the same filtering capability as exclude rules
  # except you are allowed to specify one matcher per severity rule.
  # Only affects out formats that support setting severity information.
  #
  # Default: []
  rules:
    - linters:
        - revive
      severity: error

1
2
3
4
5
6
7
8

func NewUserServer() *UserServer {
    return &UserServer{}
}

func main()  {
    server := NewUserServer()
    ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var DB *sql.DB

func init() {
    db, err := sql.Open("mysql",os.Getenv("dataSource"))
    if err != nil {
        panic(err)
    }

    DB = db
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package db

import (
	"database/sql"

	_ "github.com/go-sql-driver/mysql"
)

func New(dsn string) (*sql.DB, error) {
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		return nil, err
	}

	if err := db.Ping(); err != nil {
		return nil, err
	}

	return db, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("not found")

func main() {
    err := do()
    if errors.Is(err, ErrNotFound) {
        fmt.Println("not found")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

.PHONY: lint
lint:
    golangci-lint run

.PHONY: test
test:
    go test -race -coverprofile=coverage.out ./...

.PHONY: build
    go build -o build/bin/app1 cmd/app1/main.go

1
2
3
4

type Repository interface {
    FindByID(id int) (*User, error)
    Save(user *User) error
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type UserService struct {
    Repository Repository
}

func (s *UserService) FindByID(id int) (*User, error) {
    return s.Repository.FindByID(id)
}

func (s *UserService) Save(user *User) error {
    return s.Repository.Save(user)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

type MockRepository struct {
}

func (r *MockRepository) FindByID(id int) (*User, error) {
    return &User{}, nil
}

func (r *MockRepository) Save(user *User) error {
    return nil
}

type MySQLRepository struct {
}

func (r *MySQLRepository) FindByID(id int) (*User, error) {
    return &User{}, nil
}

func (r *MySQLRepository) Save(user *User) error {
    return nil
}

func main() {
    var repository Repository
    if os.Getenv("ENV") == "test" {
        repository = &MockRepository{}
    } else {
        repository = &MySQLRepository{}
    }
    
    userService := &UserService{Repository: repository}
    userService.FindByID(1)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

type User struct {
    ID   int
    Name string
}

func (u *User) id() int {
	return u.ID
}

func (u *User) Save() error {
    fmt.Printf("save user %s", u.Name)
    return nil
}

func main() {
    user := &User{ID: 1, Name: "Tom"}
    user.Save()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type NewUser struct {
    User
    Age int
}

func (u *User) Save() error {
    fmt.Printf("save user %s, age %d", u.Name, u.Age)
    return nil
}

func main() {
    user := &NewUser{User: User{ID: 1, Name: "Tom"}, Age: 18}
    user.Save()
}

1
2
3
4
5
6
7
8

class User:
    def __init__(self, name="Tom", age=18):
        self.name = name
        self.age = age

user = User(name="Jerry")
print(user.name)  # Jerry
print(user.age)   # 18

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type Config struct {
    Timeout  time.Duration
    TLS      *tls.Config
}

type Request struct {
    host string
    port int
    config *Config
}

func NewRequest(host string, port int, config *Config) *Request {
    return &Request{host: host, port: port, config: config}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

type Option func(*Request)

type Request struct {
    host string
    port int
    tls *tls.Config
    timeout time.Duration
}

func WithTimeout(timeout time.Duration) Option {
    return func(r *Request) {
        r.timeout = timeout
    }
}

func WithTLS(tls *tls.Config) Option {
    return func(r *Request) {
        r.tls = tls
    }
}

func NewRequest(host string, port int, options ...Option) *Request {
  r := &Request{host: host, port: port, timeout: 10*time.Second}
    for _, option := range options {
        option(r)
    }
    return r
}

func main() {
    request := NewRequest("localhost", 8080, WithTimeout(5*time.Second), WithTLS(&tls.Config{}))
    request := NewRequest("localhost", 8080)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def log(func):
    def wrapper(*args, **kwargs):
        print(f"call {func.__name__}")
        return func(*args, **kwargs)
    return wrapper
    
@log
def add(a, b):
    return a + b

add(1, 2)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func log(f func(int, int) int) func(int, int) int {
    return func(a, b int) int {
        fmt.Printf("call %s\n", runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name())
        return f(a, b)
    }
}

func add(a, b int) int {
    return a + b
}

func main() {
    add = log(add)
    add(1, 2)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()
        c.Next()
        latency := time.Since(t)
        log.Print(latency)
    }
}

func main() {
    r := gin.Default()
    r.Use(Logger())
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run()
}

1
2
3
4
5
6
7
8

├── user
│   ├── entity.go
│   ├── user.go
│   └── user_test.go
├── order
│   ├── entity.go
│   ├── order.go
│   └── order_test.go

1
2
3
4
5
6
7
8

├── order
│   ├── repository
│   │   ├── history.go
│   │   ├── order.go
│   ├── service
│   │   ├── order.go
│   └── controller
│       ├── order.go