Go 语言从入门到精通

Appearance

实战项目 ​

本章节包含三个完整的实战项目，帮助你将所学知识应用到实际开发中。

项目 1: RESTful API 开发 ​

项目概述 ​

使用 Zoox 框架构建一个用户管理的 RESTful API。

项目结构 ​

user-api/
├── cmd/
│   └── server/
│       └── main.go
├── internal/
│   ├── handler/
│   │   └── user.go
│   ├── service/
│   │   └── user.go
│   ├── model/
│   │   └── user.go
│   └── repository/
│       └── user.go
├── go.mod
└── README.md

实现步骤 ​

1. 初始化项目 ​

bash
go mod init github.com/user/user-api
go get github.com/go-zoox/zoox

2. 定义模型 ​

go
// internal/model/user.go
package model

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

type CreateUserRequest struct {
    Name  string `json:"name" validate:"required"`
    Email string `json:"email" validate:"required,email"`
}

3. 实现 Repository ​

go
// internal/repository/user.go
package repository

import "github.com/user/user-api/internal/model"

type UserRepository struct {
    users []model.User
    nextID int
}

func NewUserRepository() *UserRepository {
    return &UserRepository{
        users:  make([]model.User, 0),
        nextID: 1,
    }
}

func (r *UserRepository) Create(user model.User) model.User {
    user.ID = r.nextID
    r.nextID++
    r.users = append(r.users, user)
    return user
}

func (r *UserRepository) FindByID(id int) (*model.User, error) {
    for _, user := range r.users {
        if user.ID == id {
            return &user, nil
        }
    }
    return nil, fmt.Errorf("用户不存在")
}

func (r *UserRepository) FindAll() []model.User {
    return r.users
}

func (r *UserRepository) Update(id int, user model.User) error {
    for i := range r.users {
        if r.users[i].ID == id {
            user.ID = id
            r.users[i] = user
            return nil
        }
    }
    return fmt.Errorf("用户不存在")
}

func (r *UserRepository) Delete(id int) error {
    for i, user := range r.users {
        if user.ID == id {
            r.users = append(r.users[:i], r.users[i+1:]...)
            return nil
        }
    }
    return fmt.Errorf("用户不存在")
}

4. 实现 Service ​

go
// internal/service/user.go
package service

import (
    "github.com/user/user-api/internal/model"
    "github.com/user/user-api/internal/repository"
)

type UserService struct {
    repo *repository.UserRepository
}

func NewUserService(repo *repository.UserRepository) *UserService {
    return &UserService{repo: repo}
}

func (s *UserService) CreateUser(req model.CreateUserRequest) (model.User, error) {
    user := model.User{
        Name:  req.Name,
        Email: req.Email,
    }
    return s.repo.Create(user), nil
}

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

func (s *UserService) GetAllUsers() []model.User {
    return s.repo.FindAll()
}

func (s *UserService) UpdateUser(id int, req model.CreateUserRequest) error {
    user := model.User{
        Name:  req.Name,
        Email: req.Email,
    }
    return s.repo.Update(id, user)
}

func (s *UserService) DeleteUser(id int) error {
    return s.repo.Delete(id)
}

5. 实现 Handler ​

go
// internal/handler/user.go
package handler

import (
    "net/http"
    "strconv"
    
    "github.com/go-zoox/zoox"
    "github.com/user/user-api/internal/model"
    "github.com/user/user-api/internal/service"
)

type UserHandler struct {
    service *service.UserService
}

func NewUserHandler(service *service.UserService) *UserHandler {
    return &UserHandler{service: service}
}

func (h *UserHandler) CreateUser(c *zoox.Context) {
    var req model.CreateUserRequest
    if err := c.BindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, zoox.H{"error": err.Error()})
        return
    }
    
    user, err := h.service.CreateUser(req)
    if err != nil {
        c.JSON(http.StatusInternalServerError, zoox.H{"error": err.Error()})
        return
    }
    
    c.JSON(http.StatusCreated, user)
}

func (h *UserHandler) GetUser(c *zoox.Context) {
    id, _ := strconv.Atoi(c.Param("id"))
    user, err := h.service.GetUser(id)
    if err != nil {
        c.JSON(http.StatusNotFound, zoox.H{"error": err.Error()})
        return
    }
    
    c.JSON(http.StatusOK, user)
}

func (h *UserHandler) GetAllUsers(c *zoox.Context) {
    users := h.service.GetAllUsers()
    c.JSON(http.StatusOK, users)
}

func (h *UserHandler) UpdateUser(c *zoox.Context) {
    id, _ := strconv.Atoi(c.Param("id"))
    var req model.CreateUserRequest
    if err := c.BindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, zoox.H{"error": err.Error()})
        return
    }
    
    if err := h.service.UpdateUser(id, req); err != nil {
        c.JSON(http.StatusNotFound, zoox.H{"error": err.Error()})
        return
    }
    
    c.JSON(http.StatusOK, zoox.H{"message": "更新成功"})
}

func (h *UserHandler) DeleteUser(c *zoox.Context) {
    id, _ := strconv.Atoi(c.Param("id"))
    if err := h.service.DeleteUser(id); err != nil {
        c.JSON(http.StatusNotFound, zoox.H{"error": err.Error()})
        return
    }
    
    c.JSON(http.StatusOK, zoox.H{"message": "删除成功"})
}

6. 主程序 ​

go
// cmd/server/main.go
package main

import (
    "github.com/go-zoox/zoox"
    "github.com/user/user-api/internal/handler"
    "github.com/user/user-api/internal/repository"
    "github.com/user/user-api/internal/service"
)

func main() {
    // 初始化依赖
    repo := repository.NewUserRepository()
    userService := service.NewUserService(repo)
    userHandler := handler.NewUserHandler(userService)
    
    // 创建应用
    app := zoox.New()
    
    // 路由定义
    api := app.Group("/api/v1")
    {
        api.Post("/users", userHandler.CreateUser)
        api.Get("/users", userHandler.GetAllUsers)
        api.Get("/users/:id", userHandler.GetUser)
        api.Put("/users/:id", userHandler.UpdateUser)
        api.Delete("/users/:id", userHandler.DeleteUser)
    }
    
    // 启动服务器
    app.Run(":8080")
}

项目 2: CLI 工具开发 ​

项目概述 ​

使用 Cobra 框架构建一个命令行工具，用于管理待办事项。

实现步骤 ​

1. 初始化项目 ​

bash
go mod init github.com/user/todo-cli
go get github.com/spf13/cobra

2. 实现核心功能 ​

go
// cmd/root.go
package cmd

import (
    "fmt"
    "os"
    
    "github.com/spf13/cobra"
)

var rootCmd = &cobra.Command{
    Use:   "todo",
    Short: "一个待办事项管理工具",
    Long:  "使用 todo 命令管理你的待办事项",
}

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}

3. 实现命令 ​

go
// cmd/add.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
)

var addCmd = &cobra.Command{
    Use:   "add",
    Short: "添加待办事项",
    Run: func(cmd *cobra.Command, args []string) {
        if len(args) == 0 {
            fmt.Println("请提供待办事项内容")
            return
        }
        // 实现添加逻辑
        fmt.Printf("已添加: %s\n", args[0])
    },
}

func init() {
    rootCmd.AddCommand(addCmd)
}

项目 3: 微服务架构 ​

项目概述 ​

构建一个简单的微服务系统，包含用户服务和订单服务。

项目结构 ​

microservices/
├── services/
│   ├── user/
│   │   └── main.go
│   └── order/
│       └── main.go
├── pkg/
│   └── common/
│       └── logger.go
└── docker-compose.yml

实现要点 ​

  1. 服务发现：使用 Consul 或 etcd
  2. API 网关：使用 Kong 或 Traefik
  3. 消息队列：使用 RabbitMQ 或 Kafka
  4. 监控：使用 Prometheus 和 Grafana
  5. 日志：使用 ELK 或 Loki

总结 ​

这些实战项目涵盖了：

  1. RESTful API：Web 服务开发
  2. CLI 工具：命令行应用开发
  3. 微服务：分布式系统架构

通过完成这些项目，你将掌握：

  • Go 语言的实际应用
  • 项目组织和代码结构
  • 常用框架和工具的使用
  • 最佳实践的应用

继续实践，不断提升你的 Go 语言技能！

基于 VitePress 构建

Copyright © 2024 Go Tutorials