8.1 微服务架构基础理论¶

package main

import (
    "github.com/gin-gonic/gin"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "net/http"
)

// 1. 定义业务模型（仅用户领域）
type User struct {
    gorm.Model
    Username string `json:"username"`
    Password string `json:"-"` // 密码不返回给前端
    Email    string `json:"email"`
}

// 2. 初始化数据库（用户服务独立数据库）
func initDB() *gorm.DB {
    dsn := "root:123456@tcp(127.0.0.1:3306)/user_db?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    db.AutoMigrate(&User{}) // 仅迁移用户表
    return db
}

// 3. 定义用户服务接口（仅用户相关操作）
func main() {
    r := gin.Default()
    db := initDB()

    // 用户注册
    r.POST("/user/register", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        db.Create(&user)
        c.JSON(http.StatusOK, gin.H{"data": user})
    })

    // 用户登录（仅示例，实际需加密密码）
    r.POST("/user/login", func(c *gin.Context) {
        var req struct {
            Username string `json:"username"`
            Password string `json:"password"`
        }
        if err := c.ShouldBindJSON(&req); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        var user User
        if err := db.Where("username = ? AND password = ?", req.Username, req.Password).First(&user).Error; err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "账号或密码错误"})
            return
        }
        c.JSON(http.StatusOK, gin.H{"msg": "登录成功", "user_id": user.ID})
    })

    r.Run(":8080") // 用户服务运行在8080端口
}

package main

import (
    "github.com/afex/hystrix-go/hystrix"
    "github.com/gin-gonic/gin"
    "net/http"
)

// 模拟调用外部服务（可能故障）
func callExternalService() (string, error) {
    // 模拟服务故障（故意返回错误）
    return "", fmt.Errorf("external service error")
}

// 封装熔断逻辑
func callWithCircuitBreaker() (string, error) {
    // 配置熔断：服务名、超时时间、错误率阈值
    hystrix.ConfigureCommand("external-service", hystrix.CommandConfig{
        Timeout:                1000, // 超时1秒
        ErrorPercentThreshold:  50,   // 错误率超过50%触发熔断
        MaxConcurrentRequests:  10,   // 最大并发请求数
    })

    var result string
    err := hystrix.Do("external-service",
        func() error {
            // 正常调用逻辑
            res, err := callExternalService()
            if err != nil {
                return err
            }
            result = res
            return nil
        },
        func(err error) error {
            // 熔断后的降级逻辑（返回默认值）
            result = "default data (service degraded)"
            return nil
        },
    )
    return result, err
}

func main() {
    r := gin.Default()

    r.GET("/call-service", func(c *gin.Context) {
        data, err := callWithCircuitBreaker()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"data": data})
    })

    r.Run(":8082")
}

package main

import (
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

// 定义监控指标（请求总数、请求耗时）
var (
    requestTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "path", "status"}, // 按请求方法、路径、状态码维度统计
    )
    requestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "Duration of HTTP requests",
            Buckets: prometheus.DefBuckets, // 默认桶（0.1, 0.25, 0.5, 1, 2.5, 5, 10秒）
        },
        []string{"method", "path"},
    )
)

// 初始化监控指标
func init() {
    prometheus.MustRegister(requestTotal)
    prometheus.MustRegister(requestDuration)
}

// 监控中间件：统计请求数和耗时
func monitorMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        // 执行后续处理
        c.Next()
        // 统计请求耗时
        duration := time.Since(start).Seconds()
        // 记录指标
        method := c.Request.Method
        path := c.FullPath()
        status := c.Writer.Status()
        requestTotal.WithLabelValues(method, path, status).Inc()
        requestDuration.WithLabelValues(method, path).Observe(duration)
    }
}

func main() {
    r := gin.Default()
    // 全局使用监控中间件
    r.Use(monitorMiddleware())

    // 业务接口
    r.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"status": "up"})
    })

    // 暴露Prometheus监控接口（供Prometheus抓取数据）
    r.GET("/metrics", func(c *gin.Context) {
        promhttp.Handler().ServeHTTP(c.Writer, c.Request)
    })

    r.Run(":8083")
}

// 商品服务（Go）- 连接PostgreSQL数据库
package main

import (
    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "net/http"
)

// 商品模型（独立数据库）
type Product struct {
    gorm.Model
    Name  string  `json:"name"`
    Price float64 `json:"price"`
    Stock int     `json:"stock"`
}

// 初始化PostgreSQL数据库（商品服务私有）
func initDB() *gorm.DB {
    dsn := "host=localhost user=postgres password=123456 dbname=product_db port=5432 sslmode=disable TimeZone=Asia/Shanghai"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect postgres")
    }
    db.AutoMigrate(&Product{})
    return db
}

func main() {
    r := gin.Default()
    db := initDB()

    // 新增商品
    r.POST("/product", func(c *gin.Context) {
        var product Product
        if err := c.ShouldBindJSON(&product); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        db.Create(&product)
        c.JSON(http.StatusOK, gin.H{"data": product})
    })

    r.Run(":8084") // 商品服务运行在8084端口
}

package main

import (
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/gin-gonic/gin"
)

// 调用用户服务API
func getUserInfo(userID int) (map[string]interface{}, error) {
    resp, err := http.Get(fmt.Sprintf("http://localhost:8080/user/info?id=%d", userID))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

// 调用商品服务API
func getProductInfo(productID int) (map[string]interface{}, error) {
    resp, err := http.Get(fmt.Sprintf("http://localhost:8084/product/info?id=%d", productID))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

// 调用订单服务API
func getOrderInfo(orderID int) (map[string]interface{}, error) {
    resp, err := http.Get(fmt.Sprintf("http://localhost:8081/order/info?id=%d", orderID))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

func main() {
    r := gin.Default()

    // 聚合服务：返回订单详情（包含用户+商品信息）
    r.GET("/order/detail/:id", func(c *gin.Context) {
        orderID := c.Param("id")
        // 1. 获取订单基本信息
        orderInfo, err := getOrderInfo(orderID)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "获取订单信息失败"})
            return
        }
        // 2. 从订单信息中提取用户ID和商品ID，调用对应服务
        userID := int(orderInfo["user_id"].(float64))
        productID := int(orderInfo["goods_id"].(float64))
        userInfo, _ := getUserInfo(userID)
        productInfo, _ := getProductInfo(productID)
        // 3. 组合结果返回
        c.JSON(http.StatusOK, gin.H{
            "order_info":  orderInfo,
            "user_info":   userInfo,
            "product_info": productInfo,
        })
    })

    r.Run(":8085") // 聚合服务运行在8085端口
}

// 订单服务（事件发布者）
package main

import (
    "github.com/gin-gonic/gin"
    "github.com/nsqio/go-nsq"
    "net/http"
)

// NSQ生产者配置
var producer *nsq.Producer

func initNSQ() error {
    var err error
    producer, err = nsq.NewProducer("127.0.0.1:4150", nsq.NewConfig())
    return err
}

func main() {
    if err := initNSQ(); err != nil {
        panic(err)
    }
    defer producer.Stop()

    r := gin.Default()

    // 创建订单并发布“订单创建”事件
    r.POST("/order/create", func(c *gin.Context) {
        var req struct {
            UserID  int     `json:"user_id"`
            GoodsID int     `json:"goods_id"`
            Amount  float64 `json:"amount"`
        }
        if err := c.ShouldBindJSON(&req); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        // 1. 保存订单（省略数据库操作）
        orderID := 1002
        // 2. 发布“订单创建”事件（JSON格式）
        event := fmt.Sprintf(`{"order_id":%d,"user_id":%d,"goods_id":%d,"amount":%f}`, orderID, req.UserID, req.GoodsID, req.Amount)
        if err := producer.Publish("order_created", []byte(event)); err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "发布事件失败"})
            return
        }

        c.JSON(http.StatusOK, gin.H{"msg": "订单创建成功", "order_id": orderID})
    })

    r.Run(":8081")
}