Golang开发简易投票后台管理系统

.
├── main.go               # 应用入口
├── config/               # 配置管理
│   └── config.go
├── models/               # 数据模型定义
│   ├── poll.go
│   └── vote.go
├── handlers/             # HTTP请求处理函数
│   ├── poll_handler.go
│   └── vote_handler.go
├── services/             # 业务逻辑层
│   ├── poll_service.go
│   └── vote_service.go
├── repository/           # 数据库操作层 (DAO)
│   ├── poll_repo.go
│   └── vote_repo.go
├── router/               # 路由配置
│   └── router.go
└── database/             # 数据库连接与迁移
    └── db.go

// models/poll.go
type Poll struct {
    ID          int        `json:"id"`
    Title       string     `json:"title"`
    Description string     `json:"description"`
    IsMultiVote bool       `json:"is_multi_vote"`
    CreatedAt   time.Time  `json:"created_at"`
    ExpiresAt   *time.Time `json:"expires_at"` // 允许为空
    Status      string     `json:"status"`     // active, closed, draft
}

// models/option.go
type Option struct {
    ID        int    `json:"id"`
    PollID    int    `json:"poll_id"`
    Text      string `json:"text"`
    VoteCount int    `json:"vote_count"` // 票数，方便快速查询
}

// models/vote.go
type Vote struct {
    ID       int       `json:"id"`
    PollID   int       `json:"poll_id"`
    OptionID int       `json:"option_id"`
    UserID   *int      `json:"user_id"`   // 如果有用户系统
    VoterIP  string    `json:"voter_ip"`  // 匿名投票时记录IP
    VotedAt  time.Time `json:"voted_at"`
}

// repository/poll_repo.go
type PollRepository interface {
    CreatePoll(poll *models.Poll, options []models.Option) (int, error)
    GetPollByID(id int) (*models.Poll, []models.Option, error)
    UpdatePoll(poll *models.Poll) error
    DeletePoll(id int) error
    GetAllPolls() ([]models.Poll, error)
    // ... 其他方法
}

// 示例：创建投票（包含事务处理）
func (r *SQLPollRepository) CreatePoll(poll *models.Poll, options []models.Option) (int, error) {
    tx, err := r.db.Begin()
    if err != nil {
        return 0, err
    }
    defer tx.Rollback() // 确保在函数退出时回滚，除非明确提交

    // 插入投票
    stmt, err := tx.Prepare("INSERT INTO polls (title, description, is_multi_vote, created_at, expires_at, status) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id")
    if err != nil {
        return 0, err
    }
    var pollID int
    err = stmt.QueryRow(poll.Title, poll.Description, poll.IsMultiVote, poll.CreatedAt, poll.ExpiresAt, poll.Status).Scan(&pollID)
    if err != nil {
        return 0, err
    }

    // 插入选项
    for _, opt := range options {
        stmt, err = tx.Prepare("INSERT INTO options (poll_id, text, vote_count) VALUES ($1, $2, $3)")
        if err != nil {
            return 0, err
        }
        _, err = stmt.Exec(pollID, opt.Text, 0)
        if err != nil {
            return 0, err
        }
    }

    return pollID, tx.Commit() // 提交事务
}

// services/poll_service.go
type PollService struct {
    pollRepo repository.PollRepository
    voteRepo repository.VoteRepository
}

func (s *PollService) CreateNewPoll(title, description string, isMultiVote bool, expiresAt *time.Time, optionTexts []string) (int, error) {
    // 业务逻辑，如验证输入
    if len(optionTexts) < 2 {
        return 0, errors.New("投票至少需要两个选项")
    }

    poll := &models.Poll{
        Title:       title,
        Description: description,
        IsMultiVote: isMultiVote,
        CreatedAt:   time.Now(),
        ExpiresAt:   expiresAt,
        Status:      "active",
    }

    var options []models.Option
    for _, text := range optionTexts {
        options = append(options, models.Option{Text: text, VoteCount: 0})
    }

    return s.pollRepo.CreatePoll(poll, options)
}

// services/vote_service.go
func (s *VoteService) RecordVote(pollID, optionID int, userID *int, voterIP string) error {
    // 检查投票是否过期、是否允许重复投票等业务逻辑
    // ...
    return s.voteRepo.AddVote(pollID, optionID, userID, voterIP)
}

// handlers/poll_handler.go
type PollHandler struct {
    pollService services.PollService
}

func (h *PollHandler) CreatePoll(w http.ResponseWriter, r *http.Request) {
    var req struct {
        Title       string     `json:"title"`
        Description string     `json:"description"`
        IsMultiVote bool       `json:"is_multi_vote"`
        ExpiresAt   *time.Time `json:"expires_at"`
        Options     []string   `json:"options"`
    }
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    pollID, err := h.pollService.CreateNewPoll(req.Title, req.Description, req.IsMultiVote, req.ExpiresAt, req.Options)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    json.NewEncoder(w).Encode(map[string]int{"id": pollID})
}

// router/router.go
func SetupRouter(db *sql.DB) *mux.Router {
    r := mux.NewRouter()

    // 实例化Repository, Service, Handler
    pollRepo := repository.NewSQLPollRepository(db)
    voteRepo := repository.NewSQLVoteRepository(db)

    pollService := services.NewPollService(pollRepo, voteRepo)
    voteService := services.NewVoteService(voteRepo, pollRepo)

    pollHandler := handlers.NewPollHandler(pollService)
    voteHandler := handlers.NewVoteHandler(voteService)

    // 投票管理API
    r.HandleFunc("/polls", pollHandler.CreatePoll).Methods("POST")
    r.HandleFunc("/polls/{id}", pollHandler.GetPoll).Methods("GET")
    r.HandleFunc("/polls", pollHandler.GetAllPolls).Methods("GET")
    // ... 其他管理接口

    // 投票接口
    r.HandleFunc("/polls/{id}/vote", voteHandler.RecordVote).Methods("POST")
    r.HandleFunc("/polls/{id}/results", voteHandler.GetPollResults).Methods("GET")

    return r
}

// main.go
func main() {
    // 加载配置
    cfg := config.LoadConfig()

    // 连接数据库
    db, err := database.ConnectDB(cfg.DatabaseURL)
    if err != nil {
        log.Fatalf("无法连接数据库: %v", err)
    }
    defer db.Close()

    // 设置路由
    router := router.SetupRouter(db)

    // 启动HTTP服务器
    log.Printf("服务器在端口 %s 上运行...", cfg.ServerPort)
    log.Fatal(http.ListenAndServe(":"+cfg.ServerPort, router))
}

vote_count