青岛游实战：3步搞定项目避坑，保姆级教程详解
看了一堆教程还是不会写项目？别急，这很正常。很多开发者卡在“知道”和“做到”之间。今天这篇青岛游实战的保姆级教程，就是为你准备的。
项目目标
我们要搭建一个完整的青岛旅游推荐系统。这不是简单的网页展示，而是包含后端逻辑、数据处理和前端交互的全栈项目。
核心功能包括：
景点数据管理与筛选
用户评论实时分析
行程规划算法
高并发访问支持
技术选型：
后端：Go语言 + Gin框架
数据库：PostgreSQL
前端：React + TypeScript
部署：Docker + Nginx
选择Go语言是因为它在高并发场景下的性能优势，特别适合旅游网站这种访问波动大的场景。PostgreSQL则提供了强大的地理空间查询能力，方便计算景点距离。
目录结构
一个清晰的目录结构能让项目维护事半功倍。我们采用领域驱动设计思想，按业务模块划分目录：
qingdao-travel/
├── cmd/
│ └── server/
│ └── main.go # 应用入口
├── internal/
│ ├── handler/ # HTTP处理器
│ ├── service/ # 业务逻辑层
│ ├── repository/ # 数据访问层
│ ├── model/ # 数据模型定义
│ └── middleware/ # 中间件
├── pkg/
│ ├── config/ # 配置管理
│ ├── logger/ # 日志封装
│ └── utils/ # 工具函数
├── migrations/ # 数据库迁移脚本
├── static/ # 前端静态资源
├── go.mod # Go模块定义
├── Dockerfile # 容器化配置
└── README.md
这种分层架构确保了代码的职责单一，方便单元测试和后期扩展。handler层只负责HTTP请求的接收和响应，service层处理业务规则，repository层专注于数据库操作。
核心代码实现
景点模型定义：
// model/spot.go
package model
import time
type Spot struct {
ID uint `json:id gorm:primaryKey`
Name string `json:name gorm:size:100;not null`
Category string `json:category gorm:size:50;index`
Description string `json:description`
Latitude float64 `json:latitude gorm:precision:8,6`
Longitude float64 `json:longitude gorm:precision:8,6`
Rating float64 `json:rating gorm:precision:3,1;default:0`
VisitCount int `json:visit_count gorm:default:0`
Images []string `json:images gorm:serializer:json`
CreatedAt time.Time `json:created_at`
UpdatedAt time.Time `json:updated_at`
DeletedAt gorm.DeletedAt `json:- gorm:index`
}
// TableName 指定表名
func (Spot) TableName() string {
return spots
}
数据访问层实现：
// repository/spot_repo.go
package repository
import (
context
github.com/jinzhu/gorm
qingdao-travel/internal/model
)
type SpotRepository interface {
GetByID(ctx context.Context, id uint) (*model.Spot, error)
GetByCategory(ctx context.Context, category string) ([]model.Spot, error)
GetNearby(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error)
Create(ctx context.Context, spot *model.Spot) error
Update(ctx context.Context, spot *model.Spot) error
}
type spotRepository struct {
db *gorm.DB
}
func NewSpotRepository(db *gorm.DB) SpotRepository {
return spotRepository{db: db}
}
func (r *spotRepository) GetByID(ctx context.Context, id uint) (*model.Spot, error) {
var spot model.Spot
// 使用WithContext传递上下文，支持超时控制
result := r.db.WithContext(ctx).First(spot, id)
if result.Error != nil {
return nil, result.Error
}
return spot, nil
}
// GetNearby 基于PostGIS实现地理范围查询
func (r *spotRepository) GetNearby(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error) {
var spots []model.Spot
// 使用ST_DWithin函数进行地理距离计算
// 单位：米，PostGIS默认使用米
query := `
SELECT * FROM spots
WHERE ST_DWithin(
ST_MakePoint(longitude, latitude)::geography,
ST_MakePoint(?::float8, ?::float8)::geography,
?::float8
)
ORDER BY ST_Distance(
ST_MakePoint(longitude, latitude)::geography,
ST_MakePoint(?::float8, ?::float8)::geography
) ASC
LIMIT 20
`
params := []interface{}{lon, lat, radiusKm * 1000, lon, lat}
result := r.db.WithContext(ctx).Raw(query, params...).Scan(spots)
if result.Error != nil {
return nil, result.Error
}
return spots, nil
}
业务逻辑层实现：
// service/spot_service.go
package service
import (
context
errors
fmt
qingdao-travel/internal/model
qingdao-travel/internal/repository
)
type SpotService interface {
GetSpotByID(ctx context.Context, id uint) (*model.Spot, error)
GetNearbySpots(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error)
ValidateSpot(spot *model.Spot) error
}
type spotService struct {
spotRepo repository.SpotRepository
}
func NewSpotService(spotRepo repository.SpotRepository) SpotService {
return spotService{spotRepo: spotRepo}
}
func (s *spotService) GetSpotByID(ctx context.Context, id uint) (*model.Spot, error) {
spot, err := s.spotRepo.GetByID(ctx, id)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fmt.Errorf(景点不存在: %d, id)
}
return nil, fmt.Errorf(查询景点失败: %v, err)
}
return spot, nil
}
func (s *spotService) GetNearbySpots(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error) {
// 参数校验
if lat -90 || lat 90 {
return nil, errors.New(纬度必须在-90到90之间)
}
if lon -180 || lon 180 {
return nil, errors.New(经度必须在-180到180之间)
}
if radiusKm = 0 || radiusKm 500 {
return nil, errors.New(搜索半径必须在1-500公里之间)
}
spots, err := s.spotRepo.GetNearby(ctx, lat, lon, radiusKm)
if err != nil {
return nil, fmt.Errorf(查询附近景点失败: %v, err)
}
return spots, nil
}
func (s *spotService) ValidateSpot(spot *model.Spot) error {
if spot.Name == {
return errors.New(景点名称不能为空)
}
if len(spot.Name) 100 {
return errors.New(景点名称不能超过100字符)
}
if spot.Latitude -90 || spot.Latitude 90 {
return errors.New(纬度值无效)
}
if spot.Longitude -180 || spot.Longitude 180 {
return errors.New(经度值无效)
}
return nil
}
HTTP处理器实现：
// handler/spot_handler.go
package handler
import (
net/http
strconv
github.com/gin-gonic/gin
qingdao-travel/internal/service
)
type SpotHandler struct {
spotService service.SpotService
}
func NewSpotHandler(spotService service.SpotService) *SpotHandler {
return SpotHandler{spotService: spotService}
}
// GetSpotByID 获取单个景点详情
// GET /api/v1/spots/:id
func (h *SpotHandler) GetSpotByID(c *gin.Context) {
idStr := c.Param(id)
id, err := strconv.ParseUint(idStr, 10, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{error: 无效的景点ID})
return
}
spot, err := h.spotService.GetSpotByID(c.Request.Context(), uint(id))
if err != nil {
if errors.Is(err, service.ErrNotFound) {
c.JSON(http.StatusNotFound, gin.H{error: 景点不存在})
return
}
c.JSON(http.StatusInternalServerError, gin.H{error: 服务器内部错误})
return
}
c.JSON(http.StatusOK, gin.H{data: spot})
}
// GetNearbySpots 获取附近景点列表
// GET /api/v1/spots/nearby?lat=36.06lon=120.38radius=5
func (h *SpotHandler) GetNearbySpots(c *gin.Context) {
latStr := c.DefaultQuery(lat, 36.06) // 青岛默认坐标
lonStr := c.DefaultQuery(lon, 120.38)
radiusStr := c.DefaultQuery(radius, 5)
lat, err1 := strconv.ParseFloat(latStr, 64)
lon, err2 := strconv.ParseFloat(lonStr, 64)
radius, err3 := strconv.ParseFloat(radiusStr, 64)
if err1 != nil || err2 != nil || err3 != nil {
c.JSON(http.StatusBadRequest, gin.H{error: 参数格式错误})
return
}
spots, err := h.spotService.GetNearbySpots(c.Request.Context(), lat, lon, radius)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{error: err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{
data: spots,
total: len(spots),
lat: lat,
lon: lon,
radius: radius,
})
}
主程序入口：
// cmd/server/main.go
package main
import (
context
log
os
os/signal
syscall
time
github.com/gin-gonic/gin
github.com/jinzhu/gorm
_ github.com/lib/pq
qingdao-travel/internal/handler
qingdao-travel/internal/repository
qingdao-travel/internal/service
qingdao-travel/pkg/config
qingdao-travel/pkg/logger
)
func main() {
// 加载配置
cfg, err := config.Load()
if err != nil {
log.Fatalf(加载配置失败: %v, err)
}
// 初始化日志
log := logger.New(cfg.LogLevel)
defer log.Sync()
// 连接数据库
db, err := gorm.Open(postgres, cfg.DatabaseURL)
if err != nil {
log.Fatal(数据库连接失败: %v, err)
}
defer db.Close()
// 依赖注入
spotRepo := repository.NewSpotRepository(db)
spotService := service.NewSpotService(spotRepo)
spotHandler := handler.NewSpotHandler(spotService)
// 创建Gin引擎
gin.SetMode(gin.ReleaseMode)
r := gin.Default()
// 注册路由
api := r.Group(/api/v1)
{
spots := api.Group(/spots)
{
spots.GET(/:id, spotHandler.GetSpotByID)
spots.GET(/nearby, spotHandler.GetNearbySpots)
}
}
// 优雅关闭
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
go func() {
-ctx.Done()
log.Info(收到关闭信号，正在优雅退出...)
// 给现有请求5秒时间完成
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := r.Shutdown(shutdownCtx); err != nil {
log.Error(服务器关闭失败: %v, err)
}
}()
log.Info(服务器启动在 %s, cfg.ServerAddr)
if err := r.Run(cfg.ServerAddr); err != nil {
log.Fatal(服务器启动失败: %v, err)
}
}
运行与测试
环境准备：
# 安装Go 1.20+
go version
# 安装PostgreSQL 14+
# 创建数据库
createdb qingdao_travel
# 启用PostGIS扩展
psql -d qingdao_travel -c CREATE EXTENSION IF NOT EXISTS postgis;
# 初始化数据库表
go run migrations/001_init.go
# 插入测试数据
go run migrations/002_seed.go
启动服务：
# 设置环境变量
export DATABASE_URL=postgres://user:pass@localhost:5432/qingdao_travel?sslmode=disable
export LOG_LEVEL=info
export SERVER_ADDR=:8080
# 启动服务
go run cmd/server/main.go
API测试：
# 测试获取景点详情
curl -X GET http://localhost:8080/api/v1/spots/1
# 测试附近景点查询
curl -X GET http://localhost:8080/api/v1/spots/nearby?lat=36.06lon=120.38radius=10
# 测试参数校验
curl -X GET http://localhost:8080/api/v1/spots/nearby?lat=999lon=120.38radius=5
单元测试示例：
// service/spot_service_test.go
package service
import (
context
testing
github.com/stretchr/testify/assert
qingdao-travel/internal/model
)
type mockSpotRepo struct{}
func (m *mockSpotRepo) GetByID(ctx context.Context, id uint) (*model.Spot, error) {
return model.Spot{ID: id, Name: 栈桥}, nil
}
func (m *mockSpotRepo) GetByCategory(ctx context.Context, category string) ([]model.Spot, error) {
return nil, nil
}
func (m *mockSpotRepo) GetNearby(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error) {
return []model.Spot{
{ID: 1, Name: 栈桥},
{ID: 2, Name: 八大关},
}, nil
}
func (m *mockSpotRepo) Create(ctx context.Context, spot *model.Spot) error {
return nil
}
func (m *mockSpotRepo) Update(ctx context.Context, spot *model.Spot) error {
return nil
}
func TestGetSpotByID(t *testing.T) {
repo := mockSpotRepo{}
svc := NewSpotService(repo)
spot, err := svc.GetSpotByID(context.Background(), 1)
assert.NoError(t, err)
assert.NotNil(t, spot)
assert.Equal(t, 栈桥, spot.Name)
}
func TestGetNearbySpots(t *testing.T) {
repo := mockSpotRepo{}
svc := NewSpotService(repo)
spots, err := svc.GetNearbySpots(context.Background(), 36.06, 120.38, 10)
assert.NoError(t, err)
assert.Len(t, spots, 2)
}
func TestValidateSpot(t *testing.T) {
repo := mockSpotRepo{}
svc := NewSpotService(repo)
// 测试有效数据
validSpot := model.Spot{
Name: 栈桥,
Latitude: 36.06,
Longitude: 120.38,
}
assert.NoError(t, svc.ValidateSpot(validSpot))
// 测试空名称
invalidSpot := model.Spot{
Name: ,
Latitude: 36.06,
Longitude: 120.38,
}
assert.Error(t, svc.ValidateSpot(invalidSpot))
}
优化扩展
性能优化策略：
数据库索引优化
-- 为常用查询字段创建索引
CREATE INDEX idx_spots_category ON spots(category);
CREATE INDEX idx_spots_geo ON spots USING GIST (
ST_MakePoint(longitude, latitude)::geography
);
缓存策略
热点景点数据使用Redis缓存
设置合理的TTL（建议5-10分钟）
使用缓存击穿、雪崩防护机制
连接池配置
// 优化数据库连接池
sqlDB, _ := db.DB()
sqlDB.SetMaxOpenConns(100)
sqlDB.SetMaxIdleConns(20)
sqlDB.SetConnMaxLifetime(time.Hour)
安全加固措施：
实施CORS策略，限制前端域名
添加请求速率限制，防止DDoS攻击
敏感操作添加身份验证
输入数据严格校验，防止SQL注入
启用HTTPS，使用HSTS头
监控告警体系：
集成Prometheus监控关键指标
配置Grafana可视化面板
设置CPU、内存、请求延迟告警阈值
错误日志聚合到ELK栈
小结
这个青岛游项目展示了Go语言构建高并发Web应用的完整流程。从目录结构设计到分层架构实现，再到地理空间查询优化，每个环节都有实战价值。
关键收获：
领域驱动设计的目录结构让代码更易维护
PostGIS地理查询大幅提升位置服务性能
依赖注入模式便于单元测试和扩展
优雅关闭确保生产环境稳定性
实际项目中，你可以根据业务需求调整技术栈。比如使用MongoDB替代PostgreSQL，或者用gRPC替代HTTP API。核心思想是保持分层清晰、职责单一、易于测试。
现在轮到你了。你公司项目里是怎么处理地理位置查询的？用的什么数据库？有没有遇到过性能瓶颈？欢迎在评论区分享你的实战经验，我们一起交流优化方案。 
长河君 · 2026/9/21 19:08:53 · 阅读 1.2k 青岛游实战：3步搞定项目避坑，保姆级教程详解
青岛游实战：3步搞定项目避坑，保姆级教程详解
看了一堆教程还是不会写项目？别急，这很正常。很多开发者卡在“知道”和“做到”之间。今天这篇青岛游实战的保姆级教程，就是为你准备的。
项目目标
我们要搭建一个完整的青岛旅游推荐系统。这不是简单的网页展示，而是包含后端逻辑、数据处理和前端交互的全栈项目。
核心功能包括：
景点数据管理与筛选
用户评论实时分析
行程规划算法
高并发访问支持
技术选型：
后端：Go语言 + Gin框架
数据库：PostgreSQL
前端：React + TypeScript
部署：Docker + Nginx
选择Go语言是因为它在高并发场景下的性能优势，特别适合旅游网站这种访问波动大的场景。PostgreSQL则提供了强大的地理空间查询能力，方便计算景点距离。
目录结构
一个清晰的目录结构能让项目维护事半功倍。我们采用领域驱动设计思想，按业务模块划分目录：
qingdao-travel/
├── cmd/
│ └── server/
│ └── main.go # 应用入口
├── internal/
│ ├── handler/ # HTTP处理器
│ ├── service/ # 业务逻辑层
│ ├── repository/ # 数据访问层
│ ├── model/ # 数据模型定义
│ └── middleware/ # 中间件
├── pkg/
│ ├── config/ # 配置管理
│ ├── logger/ # 日志封装
│ └── utils/ # 工具函数
├── migrations/ # 数据库迁移脚本
├── static/ # 前端静态资源
├── go.mod # Go模块定义
├── Dockerfile # 容器化配置
└── README.md
这种分层架构确保了代码的职责单一，方便单元测试和后期扩展。handler层只负责HTTP请求的接收和响应，service层处理业务规则，repository层专注于数据库操作。
核心代码实现
景点模型定义：
// model/spot.go
package model
import time
type Spot struct {
ID uint `json:id gorm:primaryKey`
Name string `json:name gorm:size:100;not null`
Category string `json:category gorm:size:50;index`
Description string `json:description`
Latitude float64 `json:latitude gorm:precision:8,6`
Longitude float64 `json:longitude gorm:precision:8,6`
Rating float64 `json:rating gorm:precision:3,1;default:0`
VisitCount int `json:visit_count gorm:default:0`
Images []string `json:images gorm:serializer:json`
CreatedAt time.Time `json:created_at`
UpdatedAt time.Time `json:updated_at`
DeletedAt gorm.DeletedAt `json:- gorm:index`
}
// TableName 指定表名
func (Spot) TableName() string {
return spots
}
数据访问层实现：
// repository/spot_repo.go
package repository
import (
context
github.com/jinzhu/gorm
qingdao-travel/internal/model
)
type SpotRepository interface {
GetByID(ctx context.Context, id uint) (*model.Spot, error)
GetByCategory(ctx context.Context, category string) ([]model.Spot, error)
GetNearby(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error)
Create(ctx context.Context, spot *model.Spot) error
Update(ctx context.Context, spot *model.Spot) error
}
type spotRepository struct {
db *gorm.DB
}
func NewSpotRepository(db *gorm.DB) SpotRepository {
return spotRepository{db: db}
}
func (r *spotRepository) GetByID(ctx context.Context, id uint) (*model.Spot, error) {
var spot model.Spot
// 使用WithContext传递上下文，支持超时控制
result := r.db.WithContext(ctx).First(spot, id)
if result.Error != nil {
return nil, result.Error
}
return spot, nil
}
// GetNearby 基于PostGIS实现地理范围查询
func (r *spotRepository) GetNearby(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error) {
var spots []model.Spot
// 使用ST_DWithin函数进行地理距离计算
// 单位：米，PostGIS默认使用米
query := `
SELECT * FROM spots
WHERE ST_DWithin(
ST_MakePoint(longitude, latitude)::geography,
ST_MakePoint(?::float8, ?::float8)::geography,
?::float8
)
ORDER BY ST_Distance(
ST_MakePoint(longitude, latitude)::geography,
ST_MakePoint(?::float8, ?::float8)::geography
) ASC
LIMIT 20
`
params := []interface{}{lon, lat, radiusKm * 1000, lon, lat}
result := r.db.WithContext(ctx).Raw(query, params...).Scan(spots)
if result.Error != nil {
return nil, result.Error
}
return spots, nil
}
业务逻辑层实现：
// service/spot_service.go
package service
import (
context
errors
fmt
qingdao-travel/internal/model
qingdao-travel/internal/repository
)
type SpotService interface {
GetSpotByID(ctx context.Context, id uint) (*model.Spot, error)
GetNearbySpots(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error)
ValidateSpot(spot *model.Spot) error
}
type spotService struct {
spotRepo repository.SpotRepository
}
func NewSpotService(spotRepo repository.SpotRepository) SpotService {
return spotService{spotRepo: spotRepo}
}
func (s *spotService) GetSpotByID(ctx context.Context, id uint) (*model.Spot, error) {
spot, err := s.spotRepo.GetByID(ctx, id)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fmt.Errorf(景点不存在: %d, id)
}
return nil, fmt.Errorf(查询景点失败: %v, err)
}
return spot, nil
}
func (s *spotService) GetNearbySpots(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error) {
// 参数校验
if lat -90 || lat 90 {
return nil, errors.New(纬度必须在-90到90之间)
}
if lon -180 || lon 180 {
return nil, errors.New(经度必须在-180到180之间)
}
if radiusKm = 0 || radiusKm 500 {
return nil, errors.New(搜索半径必须在1-500公里之间)
}
spots, err := s.spotRepo.GetNearby(ctx, lat, lon, radiusKm)
if err != nil {
return nil, fmt.Errorf(查询附近景点失败: %v, err)
}
return spots, nil
}
func (s *spotService) ValidateSpot(spot *model.Spot) error {
if spot.Name == {
return errors.New(景点名称不能为空)
}
if len(spot.Name) 100 {
return errors.New(景点名称不能超过100字符)
}
if spot.Latitude -90 || spot.Latitude 90 {
return errors.New(纬度值无效)
}
if spot.Longitude -180 || spot.Longitude 180 {
return errors.New(经度值无效)
}
return nil
}
HTTP处理器实现：
// handler/spot_handler.go
package handler
import (
net/http
strconv
github.com/gin-gonic/gin
qingdao-travel/internal/service
)
type SpotHandler struct {
spotService service.SpotService
}
func NewSpotHandler(spotService service.SpotService) *SpotHandler {
return SpotHandler{spotService: spotService}
}
// GetSpotByID 获取单个景点详情
// GET /api/v1/spots/:id
func (h *SpotHandler) GetSpotByID(c *gin.Context) {
idStr := c.Param(id)
id, err := strconv.ParseUint(idStr, 10, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{error: 无效的景点ID})
return
}
spot, err := h.spotService.GetSpotByID(c.Request.Context(), uint(id))
if err != nil {
if errors.Is(err, service.ErrNotFound) {
c.JSON(http.StatusNotFound, gin.H{error: 景点不存在})
return
}
c.JSON(http.StatusInternalServerError, gin.H{error: 服务器内部错误})
return
}
c.JSON(http.StatusOK, gin.H{data: spot})
}
// GetNearbySpots 获取附近景点列表
// GET /api/v1/spots/nearby?lat=36.06lon=120.38radius=5
func (h *SpotHandler) GetNearbySpots(c *gin.Context) {
latStr := c.DefaultQuery(lat, 36.06) // 青岛默认坐标
lonStr := c.DefaultQuery(lon, 120.38)
radiusStr := c.DefaultQuery(radius, 5)
lat, err1 := strconv.ParseFloat(latStr, 64)
lon, err2 := strconv.ParseFloat(lonStr, 64)
radius, err3 := strconv.ParseFloat(radiusStr, 64)
if err1 != nil || err2 != nil || err3 != nil {
c.JSON(http.StatusBadRequest, gin.H{error: 参数格式错误})
return
}
spots, err := h.spotService.GetNearbySpots(c.Request.Context(), lat, lon, radius)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{error: err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{
data: spots,
total: len(spots),
lat: lat,
lon: lon,
radius: radius,
})
}
主程序入口：
// cmd/server/main.go
package main
import (
context
log
os
os/signal
syscall
time
github.com/gin-gonic/gin
github.com/jinzhu/gorm
_ github.com/lib/pq
qingdao-travel/internal/handler
qingdao-travel/internal/repository
qingdao-travel/internal/service
qingdao-travel/pkg/config
qingdao-travel/pkg/logger
)
func main() {
// 加载配置
cfg, err := config.Load()
if err != nil {
log.Fatalf(加载配置失败: %v, err)
}
// 初始化日志
log := logger.New(cfg.LogLevel)
defer log.Sync()
// 连接数据库
db, err := gorm.Open(postgres, cfg.DatabaseURL)
if err != nil {
log.Fatal(数据库连接失败: %v, err)
}
defer db.Close()
// 依赖注入
spotRepo := repository.NewSpotRepository(db)
spotService := service.NewSpotService(spotRepo)
spotHandler := handler.NewSpotHandler(spotService)
// 创建Gin引擎
gin.SetMode(gin.ReleaseMode)
r := gin.Default()
// 注册路由
api := r.Group(/api/v1)
{
spots := api.Group(/spots)
{
spots.GET(/:id, spotHandler.GetSpotByID)
spots.GET(/nearby, spotHandler.GetNearbySpots)
}
}
// 优雅关闭
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
go func() {
-ctx.Done()
log.Info(收到关闭信号，正在优雅退出...)
// 给现有请求5秒时间完成
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := r.Shutdown(shutdownCtx); err != nil {
log.Error(服务器关闭失败: %v, err)
}
}()
log.Info(服务器启动在 %s, cfg.ServerAddr)
if err := r.Run(cfg.ServerAddr); err != nil {
log.Fatal(服务器启动失败: %v, err)
}
}
运行与测试
环境准备：
# 安装Go 1.20+
go version
# 安装PostgreSQL 14+
# 创建数据库
createdb qingdao_travel
# 启用PostGIS扩展
psql -d qingdao_travel -c CREATE EXTENSION IF NOT EXISTS postgis;
# 初始化数据库表
go run migrations/001_init.go
# 插入测试数据
go run migrations/002_seed.go
启动服务：
# 设置环境变量
export DATABASE_URL=postgres://user:pass@localhost:5432/qingdao_travel?sslmode=disable
export LOG_LEVEL=info
export SERVER_ADDR=:8080
# 启动服务
go run cmd/server/main.go
API测试：
# 测试获取景点详情
curl -X GET http://localhost:8080/api/v1/spots/1
# 测试附近景点查询
curl -X GET http://localhost:8080/api/v1/spots/nearby?lat=36.06lon=120.38radius=10
# 测试参数校验
curl -X GET http://localhost:8080/api/v1/spots/nearby?lat=999lon=120.38radius=5
单元测试示例：
// service/spot_service_test.go
package service
import (
context
testing
github.com/stretchr/testify/assert
qingdao-travel/internal/model
)
type mockSpotRepo struct{}
func (m *mockSpotRepo) GetByID(ctx context.Context, id uint) (*model.Spot, error) {
return model.Spot{ID: id, Name: 栈桥}, nil
}
func (m *mockSpotRepo) GetByCategory(ctx context.Context, category string) ([]model.Spot, error) {
return nil, nil
}
func (m *mockSpotRepo) GetNearby(ctx context.Context, lat, lon float64, radiusKm float64) ([]model.Spot, error) {
return []model.Spot{
{ID: 1, Name: 栈桥},
{ID: 2, Name: 八大关},
}, nil
}
func (m *mockSpotRepo) Create(ctx context.Context, spot *model.Spot) error {
return nil
}
func (m *mockSpotRepo) Update(ctx context.Context, spot *model.Spot) error {
return nil
}
func TestGetSpotByID(t *testing.T) {
repo := mockSpotRepo{}
svc := NewSpotService(repo)
spot, err := svc.GetSpotByID(context.Background(), 1)
assert.NoError(t, err)
assert.NotNil(t, spot)
assert.Equal(t, 栈桥, spot.Name)
}
func TestGetNearbySpots(t *testing.T) {
repo := mockSpotRepo{}
svc := NewSpotService(repo)
spots, err := svc.GetNearbySpots(context.Background(), 36.06, 120.38, 10)
assert.NoError(t, err)
assert.Len(t, spots, 2)
}
func TestValidateSpot(t *testing.T) {
repo := mockSpotRepo{}
svc := NewSpotService(repo)
// 测试有效数据
validSpot := model.Spot{
Name: 栈桥,
Latitude: 36.06,
Longitude: 120.38,
}
assert.NoError(t, svc.ValidateSpot(validSpot))
// 测试空名称
invalidSpot := model.Spot{
Name: ,
Latitude: 36.06,
Longitude: 120.38,
}
assert.Error(t, svc.ValidateSpot(invalidSpot))
}
优化扩展
性能优化策略：
数据库索引优化
-- 为常用查询字段创建索引
CREATE INDEX idx_spots_category ON spots(category);
CREATE INDEX idx_spots_geo ON spots USING GIST (
ST_MakePoint(longitude, latitude)::geography
);
缓存策略
热点景点数据使用Redis缓存
设置合理的TTL（建议5-10分钟）
使用缓存击穿、雪崩防护机制
连接池配置
// 优化数据库连接池
sqlDB, _ := db.DB()
sqlDB.SetMaxOpenConns(100)
sqlDB.SetMaxIdleConns(20)
sqlDB.SetConnMaxLifetime(time.Hour)
安全加固措施：
实施CORS策略，限制前端域名
添加请求速率限制，防止DDoS攻击
敏感操作添加身份验证
输入数据严格校验，防止SQL注入
启用HTTPS，使用HSTS头
监控告警体系：
集成Prometheus监控关键指标
配置Grafana可视化面板
设置CPU、内存、请求延迟告警阈值
错误日志聚合到ELK栈
小结
这个青岛游项目展示了Go语言构建高并发Web应用的完整流程。从目录结构设计到分层架构实现，再到地理空间查询优化，每个环节都有实战价值。
关键收获：
领域驱动设计的目录结构让代码更易维护
PostGIS地理查询大幅提升位置服务性能
依赖注入模式便于单元测试和扩展
优雅关闭确保生产环境稳定性
实际项目中，你可以根据业务需求调整技术栈。比如使用MongoDB替代PostgreSQL，或者用gRPC替代HTTP API。核心思想是保持分层清晰、职责单一、易于测试。
现在轮到你了。你公司项目里是怎么处理地理位置查询的？用的什么数据库？有没有遇到过性能瓶颈？欢迎在评论区分享你的实战经验，我们一起交流优化方案。