go-zero

go-zero is a high-performance web and RPC framework designed for high-concurrency, resilient microservices. It is part of the CNCF Landscape.

Key Features

• Resilience by Design: Built-in adaptive circuit breakers, rate limiting, load shedding, and timeout control.
• Code Generation: Powerful goctl tool for generating Go, iOS, Android, Kotlin, Dart, TypeScript, and JavaScript code from .api files.
• Automatic Validation: Client request parameters are automatically validated based on .api definitions.
• Service Mesh Capabilities: Built-in support for service discovery, load balancing, and call tracing.
• Developer Productivity: Integrated middleware, cache management, and monitoring tools.

Design Principles

• Simplicity: Keeping things simple is the first principle.
• High Availability: Stable operation under high concurrency.
• Resilience: Fault-oriented programming with adaptive protection.
• Developer Friendly: Encapsulating complexity to provide one way to do one thing.
• Extensibility: Flexible architecture for growth.

The goctl rpc module provides full support for advanced gRPC features:

Streaming Patterns:

• Server Streaming: rpc ServerStream(Req) returns (stream Reply);
• Client Streaming: rpc ClientStream(stream Req) returns (Reply);
• Bidirectional Streaming: rpc BidiStream(stream Req) returns (stream Reply);

Google Well-Known Types: goctl automatically recognizes these types and generates the correct Go imports:

service StreamService {
  rpc ServerStream(Req) returns (stream Reply);
  rpc ClientStream(stream Req) returns (Reply);
  rpc BidiStream(stream Req) returns (stream Reply);
}

When using the -m (--multiple) flag, goctl generates a specific directory structure to accommodate multiple services within one project. The services are grouped by name in key directories, but they share the main entry point and service context.

Key structural characteristics:

• client/: Contains subdirectories for each service (e.g., client/searchservice/).
• internal/logic/: Contains subdirectories for each service's logic (e.g., internal/logic/notifyservice/).
• internal/server/: Contains subdirectories for each service's server implementation (e.g., internal/server/searchservice/).
• multisvc.go: The single entry point for the entire application.
• internal/svc/servicecontext.go: A shared service context used by all services.
• internal/config/config.go: A shared configuration file.
• pb/: Contains the generated protobuf code for all services and shared messages.

output/
├── client
│   ├── notifyservice
│   │   └── notifyservice.go
│   └── searchservice
│       └── searchservice.go
├── etc
│   └── multisvc.yaml
├── go.mod
├── internal
│   ├── config
│   │   └── config.go
│   ├── logic
│   │   ├── notifyservice
│   │   │   └── notifylogic.go
│   │   └── searchservice
│   │       └── searchlogic.go
│   ├── server
│   │   ├── notifyservice
│   │   │   └── notifyserviceserver.go
│   │   └── searchservice
│   │       └── searchserviceserver.go
│   └── svc
│       └── servicecontext.go
├── multisvc.go
└── pb
    ├── multi.pb.go
    ├── multi_grpc.pb.go
    └── shared.pb.go

The generated model code follows a specific pattern to facilitate both direct SQL execution and cached lookups.

Key components include:

• Interface: Defines the CRUD operations (e.g., Insert, FindOne, Update, Delete).
• Struct: Represents the database table with db tags mapping fields to columns.
• NewUserModel: A constructor that accepts a sqlx.SqlConn and cache.CacheConf to initialize the model with caching capabilities.
• Caching Logic: Methods like FindOneByXxx use QueryRowIndex to check the cache for the primary key before querying the database. If a cache miss occurs, the database is queried, and the result is used to populate the cache.

type ( 
	UserModel interface {
		Insert(data User) (sql.Result, error)
		FindOne(id int64) (*User, error)
		// ... other methods
	}

	User struct {
		Id         int64     `db:"id"` 
		Name       string    `db:"name"` 
		// ... other fields
	}

	defaultUserModel struct {
		sqlc.CachedConn
		table string
	}
)

func NewUserModel(conn sqlx.SqlConn, c cache.CacheConf) UserModel {
	return &defaultUserModel{
		CachedConn: sqlc.NewConn(conn, c),
		table:      "user",
	}
}