如何用Golang实现微服务分层架构_Golang 微服务分层设计实践_技术教程

Golang微服务分层结构包含Handler、Service、Repository和Model四层，依赖单向向下；2. Handler处理HTTP请求，Service封装业务逻辑，Repository负责数据持久化，Model定义数据结构；3. 各层职责分离，提升可维护性、可测试性和团队协作效率。

微服务架构中，良好的分层设计能提升代码可维护性、可测试性和团队协作效率。Golang 因其简洁语法和高性能，非常适合构建分层微服务。下面介绍一种实用的 Golang 微服务分层结构，并说明各层职责与实现方式。

分层结构设计

典型的 Golang 微服务可划分为以下四层，每层职责明确，依赖单向向下：

Handler 层：处理 HTTP 请求，参数解析、响应封装
Service 层：核心业务逻辑，协调数据访问与外部调用
Repository 层：数据持久化操作，对接数据库或缓存
Model 层：定义数据结构，如实体、DTO

这种结构避免了业务逻辑散落在 handler 中，也便于单元测试和替换底层实现。

各层代码实现示例

以用户服务为例，展示每一层的具体实现方式。

Model 层（model/user.go）

定义用户实体结构：

type User struct {
    ID   int64  `json:"id"`
    Name string `json:"name"`
    Email string `json:"email"`
}

Repository 层（repository/user_repo.go）

封装数据库操作，依赖 model：

type UserRepo struct {
    db *sql.DB
}

func (r *UserRepo) FindByID(id int64) (*model.User, error) {
    var user model.User
    err := r.db.QueryRow("SELECT id, name, email FROM users WHERE id = ?", id).
        Scan(&user.ID, &user.Name, &user.Email)
    if err != nil {
        return nil, err
    }
    return &user, nil
}

func (r *UserRepo) Create(user *model.User) error {
    _, err := r.db.Exec("INSERT INTO users(name, email) VALUES(?, ?)",
        user.Name, user.Email)
    return err
}

Service 层（service/user_service.go）

实现业务规则，调用 repository：

type UserService struct {
    repo *repository.UserRepo
}

func (s *UserService) GetUser(id int64) (*model.User, error) {
    if id <= 0 {
        return nil, fmt.Errorf("invalid user id")
    }
    return s.repo.FindByID(id)
}

func (s *UserService) CreateUser(name, email string) (*model.User, error) {
    if name == "" || email == "" {
        return nil, fmt.Errorf("name and email are required")
    }
    user := &model.User{Name: name, Email: email}
    err := s.repo.Create(user)
    return user, err
}

Handler 层（handler/user_handler.go）

接收请求，调用 service 并返回 JSON：

type UserHandler struct {
    service *service.UserService
}

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
    id, _ := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64)
    user, err := h.service.GetUser(id)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    json.NewEncoder(w).Encode(user)
}

依赖注入与初始化

在 main.go 中组装各层依赖，保持松耦合：

func main() {
    db, _ := sql.Open("mysql", "...")
    userRepo := repository.NewUserRepo(db)
    userService := service.NewUserService(userRepo)
    userHandler := handler.NewUserHandler(userService)

    http.HandleFunc("/user", userHandler.GetUser)
    http.ListenAndServe(":8080", nil)
}

使用依赖注入容器（如 wire 或 dig）可进一步简化对象创建过程，提升可配置性。