スケーラビリティの高い分散画像処理システムの実現：ゴーゼロの応用と実践

package main

import (
    "github.com/tal-tech/go-zero/core/conf"
    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/rest"
)

func main() {
    logx.Disable()
    var c Config
    conf.MustLoad(&c)

    server := rest.MustNewServer(c.RestConf)
    defer server.Stop()

    InitHandlers(server.Group("/"))

    go func() {
        select {
        case <-server.Done():
            logx.Info("Stopping...")
        }
    }()
    server.Start()
}

func InitHandlers(group *rest.Group) {
    group.POST("/image/:type", func(ctx *rest.Context) {
    // 业务逻辑：根据type参数分发图像任务，调用具体的RPC服务进行处理
    })
}

package handlers

import (
    "context"
    "encoding/base64"
    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/rest/httpx"
    "github.com/tal-tech/go-zero/zrpc"
    "github.com/yanyiwu/gojieba"
    "go-zero-example/service/image/api/internal/logic"
    "go-zero-example/service/image/api/internal/svc"
    "go-zero-example/service/image/rpc/image"
)

const (
    FACE_DETECT = iota
    FACE_RECOGNITION
    COLOR_DETECT
)

var jieba = gojieba.NewJieba()

type ImageType int32

type ImageHandler struct {
    ctx    context.Context
    svcCtx *svc.ServiceContext
}

func NewImageHandler(ctx context.Context, svcCtx *svc.ServiceContext) *ImageHandler {
    return &ImageHandler{ctx: ctx, svcCtx: svcCtx}
}

func (l *ImageHandler) Handle(reqTypes []ImageType, base64Data string) (*image.Data, error) {
    req := logic.ImageReq{
        ReqTypes:   reqTypes,
        Base64Data: base64Data,
    }

    // 将图像处理请求分发给所有RPC服务
    results := make([]*image.Data, 0, len(reqTypes))
    for _, reqType := range reqTypes {
        data, err := l.svcCtx.ImageRpcClient.DoImage(l.ctx, &image.ImageReq{
            ImageType: int32(reqType),
            ImageData: base64Data,
        })
        if err != nil {
            logx.WithError(err).Warnf("image rpc call failed: %v", data)
            return nil, httpx.Error(500, "服务内部错误")
        }

        results = append(results, data)
    }

    // 直接返回结果
    return logic.MergeResults(results), nil
}

// 字符串转float
func str2float(str string, defVal float64) float64 {
    if len(str) == 0 {
        return defVal
    }
    val, err := strconv.ParseFloat(str, 64)
    if err != nil {
        return defVal
    }
    return val
}

// 字符串转int
func str2int(str string, defVal int64) int64 {
    if len(str) == 0 {
        return defVal
    }
    val, err := strconv.ParseInt(str, 10, 64)
    if err != nil {
        return defVal
    }
    return val
}

// 合并处理结果
func (l *ImageHandler) MergeResults(datas []*image.Data) *image.Data {
    if len(datas) == 1 {
        return datas[0]
    }
    mergeData := &image.Data{
        MetaData: &image.MetaData{
            Status:  0,
            Message: "success",
        },
    }

    for _, data := range datas {
        if data.MetaData.Status != 0 {
            return data // 异常情况
        }
        switch data.DataType {
        case image.DataType_STRING:
            if mergeData.StringData == nil {
                mergeData.StringData = make(map[string]string)
            }
            for k, v := range data.StringData {
                mergeData.StringData[k] = v
            }
        case image.DataType_NUMBER:
            if mergeData.NumberData == nil {
                mergeData.NumberData = make(map[string]float64)
            }
            for k, v := range data.NumberData {
                mergeData.NumberData[k] = v
            }
        case image.DataType_IMAGE:
            if mergeData.ImageData == nil {
                mergeData.ImageData = make([]*image.ImageMeta, 0)
            }
            mergeData.ImageData = append(mergeData.ImageData, data.ImageData...)
        }
    }
    return mergeData
}

syntax = "proto3";

package image;

service ImageApi {
    rpc DoImage(ImageReq) returns (Data) {}
}

message ImageReq {
    int32 image_type = 1;
    string image_data = 2;
}

message ImageMetaData {
    int32 status = 1;
    string message = 2;
}

message Data {
    ImageMetaData meta_data = 1;
    DataType data_type = 2;
    map<string, string> string_data = 3; 
    map<string, float> number_data = 4;
    repeated ImageMeta image_data = 5;

}

// 可返回的数据类型
enum DataType {
    STRING = 0;
    NUMBER = 1;
    IMAGE = 2;
}

message ImageMeta {
    string url = 1;
    int32 width = 2;
    int32 height = 3;
}