audio/app-api
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增功能

Browse Source
This commit is contained in:
yangy
2026-05-27 18:07:55 +08:00
parent fe7b61d8d1
commit 36c6ca2766
37 changed files with 11023 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/cache/brand_cache.go
Vendored
+44
View File
@@ -0,0 +1,44 @@
package cache
import (
"context"
"encoding/json"
"fmt"
"time"
"github.com/luxsin/app-api/internal/model"
"github.com/redis/go-redis/v9"
)
const (
brandAllKey = "brand:all"
brandTTL = 30 * time.Minute
)
type BrandCache struct {
rdb *redis.Client
}
func NewBrandCache(rdb *redis.Client) *BrandCache {
return &BrandCache{rdb: rdb}
}
func (c *BrandCache) GetAll(ctx context.Context) ([]model.Brand, error) {
data, err := c.rdb.Get(ctx, brandAllKey).Bytes()
if err != nil {
return nil, err
}
var list []model.Brand
if err := json.Unmarshal(data, &list); err != nil {
return nil, fmt.Errorf("unmarshal brands: %w", err)
}
return list, nil
}
func (c *BrandCache) SetAll(ctx context.Context, list []model.Brand) error {
data, err := json.Marshal(list)
if err != nil {
return fmt.Errorf("marshal brands: %w", err)
}
return c.rdb.Set(ctx, brandAllKey, data, brandTTL).Err()
}
internal/cache/model_cache.go
Vendored
+69
View File
@@ -0,0 +1,69 @@
package cache
import (
"context"
"encoding/json"
"fmt"
"time"
"github.com/luxsin/app-api/internal/model"
"github.com/redis/go-redis/v9"
)
const (
modelBrandPrefix = "model:brand:"
modelAllKey = "model:all"
modelTTL = 30 * time.Minute
)
type ModelCache struct {
rdb *redis.Client
}
func NewModelCache(rdb *redis.Client) *ModelCache {
return &ModelCache{rdb: rdb}
}
func modelBrandKey(brandName string) string {
return modelBrandPrefix + brandName
}
func (c *ModelCache) GetByBrand(ctx context.Context, brandName string) ([]model.Model, error) {
data, err := c.rdb.Get(ctx, modelBrandKey(brandName)).Bytes()
if err != nil {
return nil, err
}
var list []model.Model
if err := json.Unmarshal(data, &list); err != nil {
return nil, fmt.Errorf("unmarshal models: %w", err)
}
return list, nil
}
func (c *ModelCache) SetByBrand(ctx context.Context, brandName string, list []model.Model) error {
data, err := json.Marshal(list)
if err != nil {
return fmt.Errorf("marshal models: %w", err)
}
return c.rdb.Set(ctx, modelBrandKey(brandName), data, modelTTL).Err()
}
func (c *ModelCache) GetAll(ctx context.Context) ([]model.Model, error) {
data, err := c.rdb.Get(ctx, modelAllKey).Bytes()
if err != nil {
return nil, err
}
var list []model.Model
if err := json.Unmarshal(data, &list); err != nil {
return nil, fmt.Errorf("unmarshal models: %w", err)
}
return list, nil
}
func (c *ModelCache) SetAll(ctx context.Context, list []model.Model) error {
data, err := json.Marshal(list)
if err != nil {
return fmt.Errorf("marshal models: %w", err)
}
return c.rdb.Set(ctx, modelAllKey, data, modelTTL).Err()
}
internal/config/redis.go
+3 -3
View File
@@ -28,9 +28,9 @@ func loadRedis(env string) RedisConfig {
}
default:
return RedisConfig{
Host: "ec2-3-69-138-29.eu-central-1.compute.amazonaws.com",
Port: 16279,
Password: getEnv("REDIS_PASSWORD", "eafon123!"),
Host: "localhost",
Port: 6379,
Password: "",
Database: 1,
}
}
internal/handler/brand.go
+2 -3
View File
@@ -1,7 +1,6 @@
package handler
import (
"database/sql"
"net/http"
"github.com/gin-gonic/gin"
@@ -16,9 +15,9 @@ type BrandHandler struct {
log *zap.Logger
}
func NewBrandHandler(db *sql.DB, log *zap.Logger) *BrandHandler {
func NewBrandHandler(repo *repository.BrandRepository, log *zap.Logger) *BrandHandler {
return &BrandHandler{
repo: repository.NewBrandRepository(db),
repo: repo,
log: log,
}
}
internal/handler/model.go
+2 -3
View File
@@ -1,7 +1,6 @@
package handler
import (
"database/sql"
"net/http"
"github.com/gin-gonic/gin"
@@ -16,9 +15,9 @@ type ModelHandler struct {
log *zap.Logger
}
func NewModelHandler(db *sql.DB, log *zap.Logger) *ModelHandler {
func NewModelHandler(repo *repository.ModelRepository, log *zap.Logger) *ModelHandler {
return &ModelHandler{
repo: repository.NewModelRepository(db),
repo: repo,
log: log,
}
}
internal/repository/brand.go
+52 -3
View File
@@ -6,18 +6,53 @@ import (
"fmt"
"strings"
"github.com/luxsin/app-api/internal/cache"
"github.com/luxsin/app-api/internal/model"
"github.com/redis/go-redis/v9"
)
type BrandRepository struct {
db *sql.DB
db *sql.DB
cache *cache.BrandCache
}
func NewBrandRepository(db *sql.DB) *BrandRepository {
return &BrandRepository{db: db}
func NewBrandRepository(db *sql.DB, brandCache *cache.BrandCache) *BrandRepository {
return &BrandRepository{db: db, cache: brandCache}
}
func (r *BrandRepository) List(ctx context.Context, brandName string) ([]model.Brand, error) {
// 尝试从 Redis 获取全量品牌
list, err := r.cache.GetAll(ctx)
if err == nil {
// 缓存命中，在应用层过滤
if brandName = strings.TrimSpace(brandName); brandName != "" {
list = filterBrands(list, brandName)
}
return list, nil
}
// 缓存未命中或 Redis 异常，降级到数据库
if err != redis.Nil {
fmt.Printf("brand cache read failed, fallback to db: %v\n", err)
}
list, err = r.ListFromDB(ctx, brandName)
if err != nil {
return nil, err
}
// 回写缓存（全量数据）
if allBrands, dbErr := r.ListFromDB(ctx, ""); dbErr == nil {
if cacheErr := r.cache.SetAll(ctx, allBrands); cacheErr != nil {
fmt.Printf("brand cache write failed: %v\n", cacheErr)
}
}
return list, nil
}
// ListFromDB 直接从数据库查询（用于预热和缓存回写）
func (r *BrandRepository) ListFromDB(ctx context.Context, brandName string) ([]model.Brand, error) {
query := "SELECT id, name FROM brand"
args := []any{}
@@ -48,3 +83,17 @@ func (r *BrandRepository) List(ctx context.Context, brandName string) ([]model.B
return list, nil
}
// filterBrands 在应用层做模糊过滤
func filterBrands(list []model.Brand, brandName string) []model.Brand {
filtered := make([]model.Brand, 0)
for _, b := range list {
if strings.Contains(
strings.ToLower(b.Name),
strings.ToLower(brandName),
) {
filtered = append(filtered, b)
}
}
return filtered
}
internal/repository/model.go
+102 -16
View File
@@ -6,45 +6,132 @@ import (
"fmt"
"strings"
"github.com/luxsin/app-api/internal/cache"
"github.com/luxsin/app-api/internal/model"
"github.com/redis/go-redis/v9"
)
type ModelRepository struct {
db *sql.DB
db *sql.DB
cache *cache.ModelCache
}
func NewModelRepository(db *sql.DB) *ModelRepository {
return &ModelRepository{db: db}
func NewModelRepository(db *sql.DB, modelCache *cache.ModelCache) *ModelRepository {
return &ModelRepository{db: db, cache: modelCache}
}
func (r *ModelRepository) List(ctx context.Context, brandName, modelName string) ([]model.Model, error) {
brandName = strings.TrimSpace(brandName)
modelName = strings.TrimSpace(modelName)
const baseQuery = `SELECT id, brand_name, name, form, rig, source, eq_key, create_at FROM model`
var (
query string
args []any
)
switch {
case brandName != "":
query = baseQuery + " WHERE brand_name = ? ORDER BY name ASC"
args = []any{brandName}
// 按品牌精确查询：优先从缓存获取
list, err := r.cache.GetByBrand(ctx, brandName)
if err == nil {
return list, nil
}
// 缓存未命中或 Redis 异常，降级到数据库
if err != redis.Nil {
fmt.Printf("model cache read failed, fallback to db: %v\n", err)
}
list, err = r.ListByBrandFromDB(ctx, brandName)
if err != nil {
return nil, err
}
// 回写缓存
if cacheErr := r.cache.SetByBrand(ctx, brandName, list); cacheErr != nil {
fmt.Printf("model cache write failed: %v\n", cacheErr)
}
return list, nil
case modelName != "":
query = baseQuery + " WHERE name LIKE ? ORDER BY name ASC"
args = []any{"%" + modelName + "%"}
// 按型号模糊查询：从全量缓存中过滤
list, err := r.cache.GetAll(ctx)
if err == nil {
return filterModels(list, modelName), nil
}
// 缓存未命中或 Redis 异常，降级到数据库
if err != redis.Nil {
fmt.Printf("model cache read failed, fallback to db: %v\n", err)
}
list, err = r.ListByModelFromDB(ctx, modelName)
if err != nil {
return nil, err
}
// 回写全量缓存
if allModels, dbErr := r.ListAllFromDB(ctx); dbErr == nil {
if cacheErr := r.cache.SetAll(ctx, allModels); cacheErr != nil {
fmt.Printf("model cache write failed: %v\n", cacheErr)
}
}
return list, nil
default:
return []model.Model{}, nil
}
}
rows, err := r.db.QueryContext(ctx, query, args...)
// ListAllFromDB 从数据库查询全部型号（用于预热和缓存回写）
func (r *ModelRepository) ListAllFromDB(ctx context.Context) ([]model.Model, error) {
const query = `SELECT id, brand_name, name, form, rig, source, eq_key, create_at FROM model ORDER BY name ASC`
rows, err := r.db.QueryContext(ctx, query)
if err != nil {
return nil, fmt.Errorf("query model: %w", err)
}
defer rows.Close()
return scanModels(rows)
}
// ListByBrandFromDB 从数据库按品牌查询型号
func (r *ModelRepository) ListByBrandFromDB(ctx context.Context, brandName string) ([]model.Model, error) {
const query = `SELECT id, brand_name, name, form, rig, source, eq_key, create_at FROM model WHERE brand_name = ? ORDER BY name ASC`
rows, err := r.db.QueryContext(ctx, query, brandName)
if err != nil {
return nil, fmt.Errorf("query model: %w", err)
}
defer rows.Close()
return scanModels(rows)
}
// ListByModelFromDB 从数据库按型号名称模糊查询
func (r *ModelRepository) ListByModelFromDB(ctx context.Context, modelName string) ([]model.Model, error) {
const query = `SELECT id, brand_name, name, form, rig, source, eq_key, create_at FROM model WHERE name LIKE ? ORDER BY name ASC`
rows, err := r.db.QueryContext(ctx, query, "%"+modelName+"%")
if err != nil {
return nil, fmt.Errorf("query model: %w", err)
}
defer rows.Close()
return scanModels(rows)
}
// filterModels 在应用层做模糊过滤
func filterModels(list []model.Model, modelName string) []model.Model {
filtered := make([]model.Model, 0)
for _, m := range list {
if strings.Contains(
strings.ToLower(m.Name),
strings.ToLower(modelName),
) {
filtered = append(filtered, m)
}
}
return filtered
}
func scanModels(rows *sql.Rows) ([]model.Model, error) {
list := make([]model.Model, 0)
for rows.Next() {
m, err := scanModel(rows)
@@ -56,7 +143,6 @@ func (r *ModelRepository) List(ctx context.Context, brandName, modelName string)
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("iterate model: %w", err)
}
return list, nil
}
internal/router/router.go
+15 -4
View File
@@ -4,25 +4,36 @@ import (
"database/sql"
"github.com/gin-gonic/gin"
"github.com/luxsin/app-api/internal/cache"
"github.com/luxsin/app-api/internal/handler"
"github.com/luxsin/app-api/internal/middleware"
"github.com/luxsin/app-api/internal/repository"
"github.com/luxsin/app-api/internal/search"
"github.com/redis/go-redis/v9"
"go.uber.org/zap"
)
func New(log *zap.Logger, db *sql.DB, searchClient *search.Client, redis *redis.Client) *gin.Engine {
func New(log *zap.Logger, db *sql.DB, searchClient *search.Client, rdb *redis.Client) *gin.Engine {
r := gin.New()
r.Use(gin.Recovery())
r.Use(middleware.RequestID())
r.Use(middleware.Logger(log))
r.Use(middleware.CORS())
// Cache
brandCache := cache.NewBrandCache(rdb)
modelCache := cache.NewModelCache(rdb)
// Repository
brandRepo := repository.NewBrandRepository(db, brandCache)
modelRepo := repository.NewModelRepository(db, modelCache)
// Handler
health := handler.NewHealthHandler()
brand := handler.NewBrandHandler(db, log)
model := handler.NewModelHandler(db, log)
brand := handler.NewBrandHandler(brandRepo, log)
model := handler.NewModelHandler(modelRepo, log)
modelList := handler.NewModelListHandler(searchClient, log)
device := handler.NewDeviceHandler(redis, log)
device := handler.NewDeviceHandler(rdb, log)
v1 := r.Group("/api/v1")
{