Go语言项目实战：构建Web应用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

my-web-app/
├── cmd/
│   └── server/
│       └── main.go        # 应用入口
├── internal/
│   ├── handler/           # HTTP处理器
│   ├── middleware/        # 中间件
│   ├── model/             # 数据模型
│   ├── repository/        # 数据访问层
│   └── service/           # 业务逻辑层
├── pkg/                   # 可导出的包
├── web/                   # 前端资源
│   ├── static/            # 静态资源(CSS, JS, 图片等)
│   └── templates/         # 模板文件
├── config/                # 配置文件
├── scripts/               # 脚本文件
├── go.mod                 # Go模块定义
├── go.sum                 # 依赖校验
├── .env.example           # 环境变量示例
├── build.sh               # 构建脚本
└── README.md              # 项目说明

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 创建项目目录
mkdir -p my-web-app/{cmd/server,internal/{handler,middleware,model,repository,service},pkg,web/{static,templates},config}

# 进入项目目录
cd my-web-app

# 初始化Go模块
go mod init github.com/yourusername/my-web-app

# 添加常用依赖
go get github.com/gin-gonic/gin     # Web框架
go get github.com/jinzhu/gorm       # ORM框架
go get github.com/jinzhu/gorm/dialects/sqlite  # SQLite驱动
go get github.com/joho/godotenv     # 环境变量管理
go get github.com/golang-jwt/jwt/v4 # JWT认证
go get github.com/go-playground/validator/v10 # 数据验证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

// cmd/server/main.go
package main

import (
	"fmt"
	"log"
	"os"

	"github.com/gin-gonic/gin"
	"github.com/joho/godotenv"
	"github.com/yourusername/my-web-app/internal/handler"
	"github.com/yourusername/my-web-app/internal/middleware"
	"github.com/yourusername/my-web-app/internal/repository"
	"github.com/yourusername/my-web-app/internal/service"
)

func main() {
	// 加载环境变量
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}

	// 初始化数据库连接
	db, err := repository.InitDB()
	if err != nil {
		log.Fatalf("Failed to connect to database: %v", err)
	}

	// 初始化存储库
	userRepo := repository.NewUserRepository(db)
	productRepo := repository.NewProductRepository(db)

	// 初始化服务
	userService := service.NewUserService(userRepo)
	productService := service.NewProductService(productRepo)

	// 初始化处理器
	userHandler := handler.NewUserHandler(userService)
	productHandler := handler.NewProductHandler(productService)

	// 设置Gin模式
	if os.Getenv("GIN_MODE") == "release" {
		gin.SetMode(gin.ReleaseMode)
	}

	// 创建Gin引擎
	router := gin.Default()

	// 添加中间件
	router.Use(middleware.Logger())
	router.Use(middleware.ErrorHandler())

	// 静态文件服务
	router.Static("/static", "./web/static")
	router.LoadHTMLGlob("./web/templates/**/*")

	// 路由设置
	api := router.Group("/api")
	{
		// 公开路由
		api.POST("/register", userHandler.Register)
		api.POST("/login", userHandler.Login)

		// 需要认证的路由
		protected := api.Group("/")
		protected.Use(middleware.Auth())
		{
			// 用户相关路由
			protected.GET("/users/me", userHandler.GetProfile)
			protected.PUT("/users/me", userHandler.UpdateProfile)

			// 产品相关路由
			protected.GET("/products", productHandler.List)
			protected.GET("/products/:id", productHandler.Get)
			protected.POST("/products", productHandler.Create)
			protected.PUT("/products/:id", productHandler.Update)
			protected.DELETE("/products/:id", productHandler.Delete)
		}
	}

	// 前端路由
	router.GET("/*any", func(c *gin.Context) {
		c.HTML(200, "index.html", gin.H{})
	})

	// 获取端口
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// 启动服务器
	fmt.Printf("Server starting on port %s\n", port)
	if err := router.Run(":" + port); err != nil {
		log.Fatalf("Failed to start server: %v", err)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 数据库配置
DATABASE_URL="sqlite3://./data.db"

# 服务器配置
PORT=8080
GIN_MODE=debug

# JWT配置
JWT_SECRET="your-secret-key"
JWT_EXPIRY=24h

# 日志配置
LOG_LEVEL=info

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// internal/config/config.go
package config

import (
	"os"
	"time"
)

type Config struct {
	Database DatabaseConfig
	Server   ServerConfig
	JWT      JWTConfig
	Log      LogConfig
}

type DatabaseConfig struct {
	URL string
}

type ServerConfig struct {
	Port    string
	GinMode string
}

type JWTConfig struct {
	Secret string
	Expiry time.Duration
}

type LogConfig struct {
	Level string
}

// LoadConfig 加载配置
func LoadConfig() *Config {
	jwtExpiry, _ := time.ParseDuration(getEnv("JWT_EXPIRY", "24h"))

	return &Config{
		Database: DatabaseConfig{
			URL: getEnv("DATABASE_URL", "sqlite3://./data.db"),
		},
		Server: ServerConfig{
			Port:    getEnv("PORT", "8080"),
			GinMode: getEnv("GIN_MODE", "debug"),
		},
		JWT: JWTConfig{
			Secret: getEnv("JWT_SECRET", "default-secret-key"),
			Expiry: jwtExpiry,
		},
		Log: LogConfig{
			Level: getEnv("LOG_LEVEL", "info"),
		},
	}
}

// getEnv 获取环境变量，如果不存在则返回默认值
func getEnv(key, defaultValue string) string {
	if value, exists := os.LookupEnv(key); exists {
		return value
	}
	return defaultValue
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// internal/model/user.go
package model

import (
	"time"

	"github.com/jinzhu/gorm"
)

type User struct {
	ID        uint      `json:"id" gorm:"primary_key"`
	Username  string    `json:"username" gorm:"unique;not null"`
	Email     string    `json:"email" gorm:"unique;not null"`
	Password  string    `json:"-" gorm:"not null"` // 不序列化密码
	Name      string    `json:"name"`
	Role      string    `json:"role" gorm:"default:'user'"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

// TableName 指定表名
func (User) TableName() string {
	return "users"
}

// BeforeCreate GORM钩子，创建前自动设置时间
func (u *User) BeforeCreate(scope *gorm.Scope) error {
	scope.SetColumn("CreatedAt", time.Now())
	scope.SetColumn("UpdatedAt", time.Now())
	return nil
}

// BeforeUpdate GORM钩子，更新前自动设置时间
func (u *User) BeforeUpdate(scope *gorm.Scope) error {
	scope.SetColumn("UpdatedAt", time.Now())
	return nil
}

// internal/model/product.go
package model

import (
	"time"

	"github.com/jinzhu/gorm"
)

type Product struct {
	ID          uint      `json:"id" gorm:"primary_key"`
	Name        string    `json:"name" gorm:"not null"`
	Description string    `json:"description"`
	Price       float64   `json:"price" gorm:"not null"`
	SKU         string    `json:"sku" gorm:"unique"`
	Stock       int       `json:"stock" gorm:"default:0"`
	Category    string    `json:"category"`
	ImageURL    string    `json:"image_url"`
	CreatedAt   time.Time `json:"created_at"`
	UpdatedAt   time.Time `json:"updated_at"`
}

// TableName 指定表名
func (Product) TableName() string {
	return "products"
}

// BeforeCreate GORM钩子
func (p *Product) BeforeCreate(scope *gorm.Scope) error {
	scope.SetColumn("CreatedAt", time.Now())
	scope.SetColumn("UpdatedAt", time.Now())
	return nil
}

// BeforeUpdate GORM钩子
func (p *Product) BeforeUpdate(scope *gorm.Scope) error {
	scope.SetColumn("UpdatedAt", time.Now())
	return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

// internal/repository/db.go
package repository

import (
	"log"
	"os"

	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/sqlite"
	"github.com/yourusername/my-web-app/internal/model"
)

var DB *gorm.DB

// InitDB 初始化数据库连接
func InitDB() (*gorm.DB, error) {
	// 获取数据库URL
	dbURL := os.Getenv("DATABASE_URL")
	if dbURL == "" {
		dbURL = "./data.db" // 默认使用SQLite
	} else {
		// 如果是sqlite3://格式的URL，提取路径部分
		if len(dbURL) > 9 && dbURL[:9] == "sqlite3://" {
			dbURL = dbURL[9:]
		}
	}

	// 连接数据库
	db, err := gorm.Open("sqlite3", dbURL)
	if err != nil {
		return nil, err
	}

	// 设置连接池参数
	db.DB().SetMaxIdleConns(10)
	db.DB().SetMaxOpenConns(100)

	// 启用日志
	if os.Getenv("GIN_MODE") != "release" {
		db.LogMode(true)
	}

	// 自动迁移
	if err := migrateDB(db); err != nil {
		return nil, err
	}

	DB = db
	return db, nil
}

// migrateDB 执行数据库迁移
func migrateDB(db *gorm.DB) error {
	log.Println("Running database migrations...")

	// 自动迁移表结构
	if err := db.AutoMigrate(
		&model.User{},
		&model.Product{},
	).Error; err != nil {
		return err
	}

	// 创建默认管理员用户
	createDefaultAdmin(db)

	log.Println("Database migrations completed successfully")
	return nil
}

// createDefaultAdmin 创建默认管理员用户
func createDefaultAdmin(db *gorm.DB) {
	var count int
	db.Model(&model.User{}).Where("role = ?", "admin").Count(&count)

	if count == 0 {
		admin := model.User{
			Username: "admin",
			Email:    "admin@example.com",
			Password: "$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy", // password: admin123
			Name:     "Administrator",
			Role:     "admin",
		}

		db.Create(&admin)
		log.Println("Default admin user created")
	}
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

// internal/repository/user_repository.go
package repository

import (
	"github.com/jinzhu/gorm"
	"github.com/yourusername/my-web-app/internal/model"
)

type UserRepository interface {
	Create(user *model.User) error
	FindByID(id uint) (*model.User, error)
	FindByUsername(username string) (*model.User, error)
	FindByEmail(email string) (*model.User, error)
	Update(user *model.User) error
	Delete(id uint) error
	List(page, pageSize int) ([]model.User, int64, error)
}

type userRepository struct {
	db *gorm.DB
}

// NewUserRepository 创建用户存储库
func NewUserRepository(db *gorm.DB) UserRepository {
	return &userRepository{db: db}
}

func (r *userRepository) Create(user *model.User) error {
	return r.db.Create(user).Error
}

func (r *userRepository) FindByID(id uint) (*model.User, error) {
	var user model.User
	err := r.db.First(&user, id).Error
	if err != nil {
		return nil, err
	}
	return &user, nil
}

func (r *userRepository) FindByUsername(username string) (*model.User, error) {
	var user model.User
	err := r.db.Where("username = ?", username).First(&user).Error
	if err != nil {
		return nil, err
	}
	return &user, nil
}

func (r *userRepository) FindByEmail(email string) (*model.User, error) {
	var user model.User
	err := r.db.Where("email = ?", email).First(&user).Error
	if err != nil {
		return nil, err
	}
	return &user, nil
}

func (r *userRepository) Update(user *model.User) error {
	return r.db.Save(user).Error
}

func (r *userRepository) Delete(id uint) error {
	return r.db.Delete(&model.User{}, id).Error
}

func (r *userRepository) List(page, pageSize int) ([]model.User, int64, error) {
	var users []model.User
	var count int64

	// 计算总数
	if err := r.db.Model(&model.User{}).Count(&count).Error; err != nil {
		return nil, 0, err
	}

	// 分页查询
	offset := (page - 1) * pageSize
	if err := r.db.Offset(offset).Limit(pageSize).Find(&users).Error; err != nil {
		return nil, 0, err
	}

	return users, count, nil
}

// internal/repository/product_repository.go
package repository

import (
	"github.com/jinzhu/gorm"
	"github.com/yourusername/my-web-app/internal/model"
)

type ProductRepository interface {
	Create(product *model.Product) error
	FindByID(id uint) (*model.Product, error)
	FindBySKU(sku string) (*model.Product, error)
	Update(product *model.Product) error
	Delete(id uint) error
	List(page, pageSize int, category string) ([]model.Product, int64, error)
	Search(query string, page, pageSize int) ([]model.Product, int64, error)
}

type productRepository struct {
	db *gorm.DB
}

// NewProductRepository 创建产品存储库
func NewProductRepository(db *gorm.DB) ProductRepository {
	return &productRepository{db: db}
}

func (r *productRepository) Create(product *model.Product) error {
	return r.db.Create(product).Error
}

func (r *productRepository) FindByID(id uint) (*model.Product, error) {
	var product model.Product
	err := r.db.First(&product, id).Error
	if err != nil {
		return nil, err
	}
	return &product, nil
}

func (r *productRepository) FindBySKU(sku string) (*model.Product, error) {
	var product model.Product
	err := r.db.Where("sku = ?", sku).First(&product).Error
	if err != nil {
		return nil, err
	}
	return &product, nil
}

func (r *productRepository) Update(product *model.Product) error {
	return r.db.Save(product).Error
}

func (r *productRepository) Delete(id uint) error {
	return r.db.Delete(&model.Product{}, id).Error
}

func (r *productRepository) List(page, pageSize int, category string) ([]model.Product, int64, error) {
	var products []model.Product
	var count int64

	query := r.db.Model(&model.Product{})
	if category != "" {
		query = query.Where("category = ?", category)
	}

	// 计算总数
	if err := query.Count(&count).Error; err != nil {
		return nil, 0, err
	}

	// 分页查询
	offset := (page - 1) * pageSize
	if err := query.Offset(offset).Limit(pageSize).Find(&products).Error; err != nil {
		return nil, 0, err
	}

	return products, count, nil
}

func (r *productRepository) Search(query string, page, pageSize int) ([]model.Product, int64, error) {
	var products []model.Product
	var count int64

	searchQuery := r.db.Model(&model.Product{}).Where(
		"name LIKE ? OR description LIKE ? OR sku LIKE ?",
		"%"+query+"%",
		"%"+query+"%",
		"%"+query+"%",
	)

	// 计算总数
	if err := searchQuery.Count(&count).Error; err != nil {
		return nil, 0, err
	}

	// 分页查询
	offset := (page - 1) * pageSize
	if err := searchQuery.Offset(offset).Limit(pageSize).Find(&products).Error; err != nil {
		return nil, 0, err
	}

	return products, count, nil
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

// internal/service/user_service.go
package service

import (
	"errors"
	"time"

	"github.com/golang-jwt/jwt/v4"
	"github.com/jinzhu/gorm"
	"github.com/yourusername/my-web-app/internal/model"
	"github.com/yourusername/my-web-app/internal/repository"
	"golang.org/x/crypto/bcrypt"
)

type UserService interface {
	Register(username, email, password, name string) (*model.User, error)
	Login(username, password string) (string, *model.User, error)
	GetUserByID(id uint) (*model.User, error)
	UpdateUser(user *model.User) error
	ChangePassword(userID uint, oldPassword, newPassword string) error
	GenerateToken(user *model.User) (string, error)
}

type userService struct {
	userRepo repository.UserRepository
}

// NewUserService 创建用户服务
func NewUserService(userRepo repository.UserRepository) UserService {
	return &userService{userRepo: userRepo}
}

// Register 用户注册
func (s *userService) Register(username, email, password, name string) (*model.User, error) {
	// 检查用户名是否已存在
	existingUser, _ := s.userRepo.FindByUsername(username)
	if existingUser != nil {
		return nil, errors.New("用户名已存在")
	}

	// 检查邮箱是否已存在
	existingEmail, _ := s.userRepo.FindByEmail(email)
	if existingEmail != nil {
		return nil, errors.New("邮箱已被注册")
	}

	// 哈希密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return nil, err
	}

	// 创建用户
	user := &model.User{
		Username: username,
		Email:    email,
		Password: string(hashedPassword),
		Name:     name,
		Role:     "user",
	}

	if err := s.userRepo.Create(user); err != nil {
		return nil, err
	}

	return user, nil
}

// Login 用户登录
func (s *userService) Login(username, password string) (string, *model.User, error) {
	// 查找用户
	user, err := s.userRepo.FindByUsername(username)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return "", nil, errors.New("用户名或密码错误")
		}
		return "", nil, err
	}

	// 验证密码
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
		return "", nil, errors.New("用户名或密码错误")
	}

	// 生成JWT令牌
	token, err := s.GenerateToken(user)
	if err != nil {
		return "", nil, err
	}

	return token, user, nil
}

// GetUserByID 根据ID获取用户
func (s *userService) GetUserByID(id uint) (*model.User, error) {
	return s.userRepo.FindByID(id)
}

// UpdateUser 更新用户信息
func (s *userService) UpdateUser(user *model.User) error {
	// 检查用户是否存在
	existingUser, err := s.userRepo.FindByID(user.ID)
	if err != nil {
		return err
	}

	// 检查用户名是否被其他用户使用
	if existingUser.Username != user.Username {
		usernameUser, _ := s.userRepo.FindByUsername(user.Username)
		if usernameUser != nil && usernameUser.ID != user.ID {
			return errors.New("用户名已被使用")
		}
	}

	// 检查邮箱是否被其他用户使用
	if existingUser.Email != user.Email {
		emailUser, _ := s.userRepo.FindByEmail(user.Email)
		if emailUser != nil && emailUser.ID != user.ID {
			return errors.New("邮箱已被使用")
		}
	}

	// 保留密码和角色不被更新
	user.Password = existingUser.Password
	user.Role = existingUser.Role

	return s.userRepo.Update(user)
}

// ChangePassword 修改密码
func (s *userService) ChangePassword(userID uint, oldPassword, newPassword string) error {
	// 获取用户
	user, err := s.userRepo.FindByID(userID)
	if err != nil {
		return err
	}

	// 验证旧密码
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(oldPassword)); err != nil {
		return errors.New("旧密码错误")
	}

	// 哈希新密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
	if err != nil {
		return err
	}

	// 更新密码
	user.Password = string(hashedPassword)
	return s.userRepo.Update(user)
}

// GenerateToken 生成JWT令牌
func (s *userService) GenerateToken(user *model.User) (string, error) {
	// 定义JWT声明
	claims := jwt.MapClaims{
		"id":       user.ID,
		"username": user.Username,
		"email":    user.Email,
		"role":     user.Role,
		"exp":      time.Now().Add(time.Hour * 24).Unix(), // 24小时过期
		"iat":      time.Now().Unix(),
	}

	// 创建令牌
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	// 使用密钥签名令牌
	tokenString, err := token.SignedString([]byte("your-secret-key"))
	if err != nil {
		return "", err
	}

	return tokenString, nil
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

// internal/service/product_service.go
package service

import (
	"errors"

	"github.com/jinzhu/gorm"
	"github.com/yourusername/my-web-app/internal/model"
	"github.com/yourusername/my-web-app/internal/repository"
)

type ProductService interface {
	Create(product *model.Product) error
	GetProductByID(id uint) (*model.Product, error)
	UpdateProduct(product *model.Product) error
	DeleteProduct(id uint) error
	ListProducts(page, pageSize int, category string) ([]model.Product, int64, error)
	SearchProducts(query string, page, pageSize int) ([]model.Product, int64, error)
	UpdateStock(id uint, quantity int) error
}

type productService struct {
	productRepo repository.ProductRepository
}

// NewProductService 创建产品服务
func NewProductService(productRepo repository.ProductRepository) ProductService {
	return &productService{productRepo: productRepo}
}

// Create 创建产品
func (s *productService) Create(product *model.Product) error {
	// 检查SKU是否已存在
	if product.SKU != "" {
		existingProduct, _ := s.productRepo.FindBySKU(product.SKU)
		if existingProduct != nil {
			return errors.New("SKU已存在")
		}
	}

	return s.productRepo.Create(product)
}

// GetProductByID 根据ID获取产品
func (s *productService) GetProductByID(id uint) (*model.Product, error) {
	product, err := s.productRepo.FindByID(id)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("产品不存在")
		}
		return nil, err
	}
	return product, nil
}

// UpdateProduct 更新产品
func (s *productService) UpdateProduct(product *model.Product) error {
	// 检查产品是否存在
	existingProduct, err := s.productRepo.FindByID(product.ID)
	if err != nil {
		return err
	}

	// 检查SKU是否被其他产品使用
	if existingProduct.SKU != product.SKU && product.SKU != "" {
		skuProduct, _ := s.productRepo.FindBySKU(product.SKU)
		if skuProduct != nil && skuProduct.ID != product.ID {
			return errors.New("SKU已被使用")
		}
	}

	return s.productRepo.Update(product)
}

// DeleteProduct 删除产品
func (s *productService) DeleteProduct(id uint) error {
	// 检查产品是否存在
	_, err := s.productRepo.FindByID(id)
	if err != nil {
		return err
	}

	return s.productRepo.Delete(id)
}

// ListProducts 列出产品
func (s *productService) ListProducts(page, pageSize int, category string) ([]model.Product, int64, error) {
	// 设置默认值
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 || pageSize > 100 {
		pageSize = 10
	}

	return s.productRepo.List(page, pageSize, category)
}

// SearchProducts 搜索产品
func (s *productService) SearchProducts(query string, page, pageSize int) ([]model.Product, int64, error) {
	// 设置默认值
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 || pageSize > 100 {
		pageSize = 10
	}

	return s.productRepo.Search(query, page, pageSize)
}

// UpdateStock 更新库存
func (s *productService) UpdateStock(id uint, quantity int) error {
	product, err := s.productRepo.FindByID(id)
	if err != nil {
		return err
	}

	// 更新库存
	product.Stock += quantity
	if product.Stock < 0 {
		return errors.New("库存不足")
	}

	return s.productRepo.Update(product)
}