CL
Clean Architecture
Clean Architecture layers, dependency inversion, and interface-based design for Go
Details
Language / Topic
GoCategory
Architecture
Rules
balanced
- Organize code into Clean Architecture layers: Domain (entities, pure business logic), Application (use cases, services), Infrastructure (adapters, repositories).
- Define interfaces (ports, repositories) in Domain or Application layers; implement in Infrastructure.
- Ensure Domain layer has no external dependencies; use dependency inversion principle.
- Organize packages by layer: `internal/domain/` (entities, business rules — no external imports), `internal/usecase/` (application services), `internal/repository/` (interfaces defined here), `internal/infrastructure/` (Postgres, Redis, HTTP client implementations).
- Define repository interfaces in the `repository` package: `type UserRepo interface { FindByID(ctx context.Context, id uuid.UUID) (*domain.User, error); Save(ctx context.Context, u *domain.User) error }` — `infrastructure` implements it, `usecase` consumes it.
- Inject dependencies through constructors: `func NewUserService(repo repository.UserRepo, mailer mailer.Mailer) *UserService { return &UserService{repo: repo, mailer: mailer} }` — no `init()` functions or package-level globals.
- Keep `internal/domain/` import-free from stdlib packages beyond `errors`, `time`, and `fmt` — no `database/sql`, `net/http`, or third-party packages allowed in domain code.
- Wire everything together in `cmd/main.go`: instantiate infra adapters, pass them to use cases, pass use cases to HTTP handlers.