Go-Zero项目开发8: 构建社交API服务与微服务解耦实践

最新推荐文章于 2026-07-21 19:15:00 发布

原创最新推荐文章于 2026-07-21 19:15:00 发布 · 296 阅读

3 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Go-Zero

纲要

回顾：社交 RPC 服务已就绪，需暴露 HTTP 接口
构建社交 API 服务
- 编写 social.api 定义路由与数据结构
- 使用 goctl api go 生成代码
- ServiceContext 注入 social-rpc 与 user-rpc 客户端
- 配置 etc/socialapi.yaml 及 jwt 认证
业务接口实现
- 好友申请：验证登录状态，调用社交 RPC
- 好友申请处理：透传处理逻辑
- 好友列表：聚合用户信息与好友关系
  - 从社交 RPC 获取好友 ID 列表
  - 批量调用用户 RPC 查询用户详情
  - 数据映射与组装
好友列表聚合流程（Mermaid 图）
微服务设计反思
- 为什么不共享数据库：解耦、灵活性、安全性
- 为什么不在 RPC 服务间相互调用：避免循环依赖、复杂度、故障隔离
- BFF 层的价值：聚合、隔离、可观测性
测试验证与总结

背景

前面我们已经完成了社交 RPC 服务，实现了好友申请、处理与列表查询的 gRPC 接口。为了让前端能够调用这些功能，还需要构建一层 HTTP API 服务（social-api）。同时，好友列表不仅需要关系数据，还需要用户详细信息，这涉及多服务数据聚合，是微服务中典型的 BFF（Backend For Frontend）场景。

本文将基于 go-zero@latest 完成社交 API 服务的搭建，并深入探讨服务间数据聚合的设计哲学。

项目结构

apps/social/
├── api/
│   ├── internal/
│   │   ├── config/
│   │   ├── handler/
│   │   ├── logic/
│   │   ├── svc/
│   │   └── types/
│   ├── social.api 
│   └── socialapi.go 
└── rpc/
    ├── internal/
    ├── model/
    └── social.proto

构建社交 API 服务

定义 API 描述文件

创建 apps/social/api/social.api，定义好友相关接口：

type (
    FriendApplyReq {
        FriendId string `json:"friend_id"`
        Reason   string `json:"reason,optional"`
    }
    FriendApplyResp {}
 
    FriendApplyHandleReq {
        ApplyId    int64 `json:"apply_id"`
        HandleType int32 `json:"handle_type"` // 1:通过 2:拒绝 
    }
    FriendApplyHandleResp {}
 
    FriendListResp {
        List []FriendInfo `json:"list"`
    }
    FriendInfo {
        UserId   string `json:"user_id"`
        Nickname string `json:"nickname"`
        Avatar   string `json:"avatar"`
        Desc     string `json:"desc"`
    }
)
 
@server(
    prefix: /v1/social 
    jwt: Auth 
)
service social-api {
    @handler FriendApplyHandler 
    post /friend/apply (FriendApplyReq) returns (FriendApplyResp)
 
    @handler FriendApplyHandleHandler 
    put /friend/apply/handle (FriendApplyHandleReq) returns (FriendApplyHandleResp)
 
    @handler FriendListHandler 
    get /friend/list returns (FriendListResp)
}

注意：jwt: Auth 指定该服务需要 JWT 验证，相关配置会在生成代码后自动添加中间件。

执行生成命令：

$ goctl api go -api apps/social/api/social.api -dir apps/social/api -style goZero

配置多 RPC 客户端

编辑 apps/social/api/internal/config/config.go，增加两个 RPC 配置：

package config 
 
import (
    "github.com/zeromicro/go-zero/rest"
    "github.com/zeromicro/go-zero/zrpc"
)
 
type Config struct {
    rest.RestConf 
    SocialRpc zrpc.RpcClientConf 
    UserRpc   zrpc.RpcClientConf 
    JWT       struct {
        AccessSecret string 
        AccessExpire int64 
    }
}

etc/socialapi.yaml 示例（开发环境）：

Name: social-api 
Host: 0.0.0.0 
Port: 8881 
SocialRpc:
  Etcd:
    Hosts:
      - 127.0.0.1:2379 
    Key: social.rpc 
UserRpc:
  Etcd:
    Hosts:
      - 127.0.0.1:2379 
    Key: user.rpc 
JWT:
  AccessSecret: "your-secret-key"
  AccessExpire: 86400

svc/servicecontext.go 创建双客户端代理：

package svc 
 
import (
    "im-system/apps/social/api/internal/config"
    "im-system/apps/social/rpc/social"
    "im-system/apps/user/rpc/user"
    "github.com/zeromicro/go-zero/zrpc"
)
 
type ServiceContext struct {
    Config     config.Config 
    SocialRpc  social.SocialClient 
    UserRpc    user.UserClient 
}
 
func NewServiceContext(c config.Config) *ServiceContext {
    return &ServiceContext{
        Config:    c,
        SocialRpc: social.NewSocialClient(zrpc.MustNewClient(c.SocialRpc).Conn()),
        UserRpc:   user.NewUserClient(zrpc.MustNewClient(c.UserRpc).Conn()),
    }
}

业务逻辑实现

好友申请

从 JWT 解析出的 context 中提取当前用户 uid，然后调用社交 RPC。

// internal/logic/friendapplylogic.go 
func (l *FriendApplyLogic) FriendApply(req *types.FriendApplyReq) (*types.FriendApplyResp, error) {
    uid := svc.GetUidFromCtx(l.ctx) // 工具函数从 context 提取 uid 
    _, err := l.svcCtx.SocialRpc.FriendApply(l.ctx, &social.FriendApplyRequest{
        UserId:   uid,
        FriendId: req.FriendId,
        Reason:   req.Reason,
    })
    if err != nil {
        return nil, err 
    }
    return &types.FriendApplyResp{}, nil 
}

好友申请处理

同样透传，仅需传递 apply_id 和 handle_type。

func (l *FriendApplyHandleLogic) FriendApplyHandle(req *types.FriendApplyHandleReq) (*types.FriendApplyHandleResp, error) {
    _, err := l.svcCtx.SocialRpc.FriendApplyHandle(l.ctx, &social.FriendApplyHandleRequest{
        ApplyId:    req.ApplyId,
        HandleType: req.HandleType,
    })
    if err != nil {
        return nil, err 
    }
    return &types.FriendApplyHandleResp{}, nil 
}

好友列表（核心聚合）

好友列表需要返回好友的昵称、头像等信息，这些数据存在于用户服务。因此需要：

调用社交 RPC 获取好友 ID 列表。
调用用户 RPC 批量查询用户信息。
组装结果。

func (l *FriendListLogic) FriendList() (*types.FriendListResp, error) {
    uid := svc.GetUidFromCtx(l.ctx)
 
    // 1. 获取好友 ID 列表 
    friendsResp, err := l.svcCtx.SocialRpc.FriendList(l.ctx, &social.FriendListRequest{
        UserId: uid,
    })
    if err != nil {
        return nil, err 
    }
    if len(friendsResp.FriendIds) == 0 {
        return &types.FriendListResp{List: []types.FriendInfo{}}, nil 
    }
 
    // 2. 批量获取用户信息 
    usersResp, err := l.svcCtx.UserRpc.FindUser(l.ctx, &user.FindUserRequest{
        Ids: friendsResp.FriendIds,
    })
    if err != nil {
        return nil, err 
    }
 
    // 3. 构建映射：uid → 用户信息 
    userMap := make(map[string]*user.GetUserInfoResponse, len(usersResp.Users))
    for _, u := range usersResp.Users {
        userMap[u.Uid] = u 
    }
 
    // 4. 组装好友列表 
    list := make([]types.FriendInfo, 0, len(friendsResp.FriendIds))
    for _, fid := range friendsResp.FriendIds {
        friendInfo := types.FriendInfo{
            UserId: fid,
        }
        if u, ok := userMap[fid]; ok {
            friendInfo.Nickname = u.Username 
            friendInfo.Avatar   = u.Avatar 
            friendInfo.Desc     = "" // 可扩展 
        }
        list = append(list, friendInfo)
    }
 
    return &types.FriendListResp{List: list}, nil 
}