Golang开发个人财务管理系统示例

// internal/model/transaction.go
package model

import "time"

type Transaction struct {
    ID       int       `json:"id"`
    Amount   float64   `json:"amount"`
    Type     string    `json:"type"`     // income 或 expense
    Category string    `json:"category"` // 如餐饮、工资、交通
    Note     string    `json:"note,omitempty"`
    Date     time.Time `json:"date"`
}

// internal/storage/storage.go
package storage

import (
    "encoding/json"
    "os"
    "sync"
    "yourapp/internal/model"
)

type Storage struct {
    file string
    data []model.Transaction
    mu   sync.Mutex
}

func NewStorage(file string) (*Storage, error) {
    s := &Storage{file: file}
    if err := s.load(); err != nil {
        return nil, err
    }
    return s, nil
}

func (s *Storage) load() error {
    s.mu.Lock()
    defer s.mu.Unlock()

    data, err := os.ReadFile(s.file)
    if err != nil {
        if os.IsNotExist(err) {
            s.data = []model.Transaction{}
            return nil
        }
        return err
    }

    return json.Unmarshal(data, &s.data)
}

func (s *Storage) save() error {
    s.mu.Lock()
    defer s.mu.Unlock()

    data, err := json.MarshalIndent(s.data, "", "  ")
    if err != nil {
        return err
    }
    return os.WriteFile(s.file, data, 0644)
}

func (s *Storage) Add(tx model.Transaction) error {
    tx.ID = len(s.data) + 1
    s.data = append(s.data, tx)
    return s.save()
}

func (s *Storage) GetAll() []model.Transaction {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.data
}

func (s *Storage) GetByCategory(category string) []model.Transaction {
    s.mu.Lock()
    defer s.mu.Unlock()

    var result []model.Transaction
    for _, t := range s.data {
        if t.Category == category {
            result = append(result, t)
        }
    }
    return result
}

// internal/handler/transaction_handler.go
package handler

import (
    "encoding/json"
    "net/http"
    "yourapp/internal/model"
    "yourapp/internal/storage"
)

type TransactionHandler struct {
    store *storage.Storage
}

func NewTransactionHandler(store *storage.Storage) *TransactionHandler {
    return &TransactionHandler{store: store}
}

func (h *TransactionHandler) Create(w http.ResponseWriter, r *http.Request) {
    var tx model.Transaction
    if err := json.NewDecoder(r.Body).Decode(&tx); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    if tx.Type != "income" && tx.Type != "expense" {
        http.Error(w, "type must be 'income' or 'expense'", http.StatusBadRequest)
        return
    }

    tx.Date = r.Context().Value("now").(time.Time) // 可注入时间用于测试

    if err := h.store.Add(tx); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(tx)
}

func (h *TransactionHandler) List(w http.ResponseWriter, r *http.Request) {
    txx := h.store.GetAll()
    json.NewEncoder(w).Encode(txx)
}

// main.go
package main

import (
    "log"
    "net/http"
    "yourapp/internal/handler"
    "yourapp/internal/storage"
)

func main() {
    store, err := storage.NewStorage("transactions.json")
    if err != nil {
        log.Fatal(err)
    }

    handler := handler.NewTransactionHandler(store)

    http.HandleFunc("/transactions", func(w http.ResponseWriter, r *http.Request) {
        ctx := context.WithValue(r.Context(), "now", time.Now())
        r = r.WithContext(ctx)
        switch r.Method {
        case http.MethodGet:
            handler.List(w, r)
        case http.MethodPost:
            handler.Create(w, r)
        default:
            http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
        }
    })

    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}