你是不是写 Go 写得挺开心的，直到有一天产品说：
“这个业务流程以后会变、会拆、可能还会上天。”
于是你开始发愁：
这时候，Freedom 跃马而来，大喊一句：
“用我！让你写得自由、改得潇洒、跑得像风！”
Freedom 是一个 基于“领域驱动设计（DDD）+ 清晰分层架构” 的 Go Web 框架。它不搞花里胡哨的魔法，讲究的就是：
结构清晰，职责分明，稳定如老狗。
| 特性 | 说明 |
|---|---|
| 基于 DDD（领域驱动设计） | 把业务逻辑写得像讲故事一样自然，结构清晰又高级 |
| 强分层架构 | Interface、Domain、Infra、Adapter…每层都像部队排好队 |
| 链路追踪神器 | 内置中间件支持链路追踪，调 Bug 像上帝视角一样舒服 |
| 熔断限流 | 自带 resilience 功能，服务顶不住也能优雅挂掉 |
| 中间件机制 | 想挂日志就挂日志，想挂追踪就挂追踪，自己定义不求人 |
| 依赖注入机制 | 解耦得干干净净，服务之间“你用我，但我不认识你” |
Life is like a journey
请求 -> Controller (Adapter)
-> Service Interface
-> Domain Service
-> Model
-> Infra（存储、消息、外部API）
换句话说：
你要做用户下单 ➜ 优惠券校验 ➜ 积分计算 ➜ 库存扣减 ➜ 发消息 ➜ 多语言 ➜ 可扩展 ➜ 不出事？
Freedom：请上车，我把这流程拆成优雅的服务、层、接口，每一层都单纯得像小学生，后期随便加功能都不怕乱。
你需要：
Freedom 提供了类似“编写游戏引擎”的开发体验，每个组件都可替换、抽象，每个依赖都可注入。
我们实现一个简单的“用户管理系统”，支持：
user-app/
├── adapter/ # 控制器层，对外暴露接口（Controller）
│ └── user.go
├── application/ # 接口层，定义服务接口
│ └── user_service.go
├── domain/ # 领域层，业务逻辑核心
│ └── user_entity.go
│ └── user_domain_service.go
├── infrastructure/ # 基础设施层，如数据库
│ └── user_repository.go
├── model/ # 实体 & 数据结构
│ └── user.go
├── vo/ # 请求和返回的数据结构
│ └── user_vo.go
├── main.go # 启动文件
└── config/
└── config.toml
// adapter/user.go
type UserController struct {
UserService application.UserService
}
func (u *UserController) GetUser(ctx freedom.Context) (vo.UserVO, error) {
id := ctx.QueryInt("id")
return u.UserService.GetUser(ctx, id)
}
func (u *UserController) CreateUser(ctx freedom.Context) (vo.UserVO, error) {
var req vo.UserCreateRequest
err := ctx.Bind(&req)
if err != nil {
return vo.UserVO{}, err
}
return u.UserService.CreateUser(ctx, req)
}
// application/user_service.go
type UserService interface {
GetUser(ctx freedom.Context, id int) (vo.UserVO, error)
CreateUser(ctx freedom.Context, req vo.UserCreateRequest) (vo.UserVO, error)
}
// domain/user_domain_service.go
type UserDomainService struct {
UserRepo *infrastructure.UserRepository
}
func (u *UserDomainService) GetUserByID(id int) (*model.User, error) {
return u.UserRepo.FindByID(id)
}
func (u *UserDomainService) CreateUser(name string) (*model.User, error) {
user := &model.User{Name: name, CreatedAt: time.Now()}
err := u.UserRepo.Save(user)
return user, err
}
// infrastructure/user_repository.go
type UserRepository struct {
freedom.Repository
}
func (r *UserRepository) FindByID(id int) (*model.User, error) {
var user model.User
err := r.FindByIDTo(id, &user)
return &user, err
}
func (r *UserRepository) Save(user *model.User) error {
return r.Save(user)
}
// model/user.go
type User struct {
ID int
Name string
CreatedAt time.Time
}
// vo/user_vo.go
type UserCreateRequest struct {
Name string `json:"name"`
}
type UserVO struct {
ID int `json:"id"`
Name string `json:"name"`
}
func main() {
app := freedom.NewApplication()
app.InstallController(func() freedom.Controller {
return &adapter.UserController{}
})
app.Run()
}
/user?id=1{"id": 1, "name": "张三"}/user with body {"name": "李四"}{"id": 2, "name": "李四"}这套架构结构清晰、解耦彻底、逻辑分明，非常适合中大型系统的扩展与演化。
就像搭积木一样，每一块都可以独立维护，改某一层不容易炸整栋楼。
这分层思想咋这么眼熟呢???
这不跟俺平时写的一样么???
咋学了感觉跟没学一样呢???