## Go gRPC GORM
Go言語でgRPCとGORMを使って、指定されたテーブル構造をもとに、ユーザー間の「いいね」に基づくフォローリスト、フォローされているリスト、相互フォローの状況を取得するAPIを実装する概要を説明します。まずは、必要なテーブル構造とGoのデータモデルを定義し、その後にgRPCのサービスを定義していきます。
### 1. データモデルとテーブル定義
#### g_likes テーブル
```go
type GLike struct {
ID uint `gorm:"primaryKey"`
UserID uint
FollowUserID uint
}
func (GLike) TableName() string {
return "g_likes"
}
```
#### g_user テーブル
```go
type GUser struct {
UserID uint `gorm:"primaryKey"`
UserName string
}
func (GUser) TableName() string {
return "g_user"
}
```
### 2. gRPCの型定義
`proto`ファイルを使用して、リクエストとレスポンスのメッセージタイプを定義します。
```protobuf
syntax = "proto3";
package user;
// フォロータイプのEnum定義
enum FollowType {
NONE = 0;
FOLLOW = 1;
FOLLOWER = 2;
FOLLOW_FOLLOWER = 3;
}
// リクエストメッセージ
message UserFollowRequest {
FollowType follow_type = 1;
}
// レスポンスで返すユーザープロファイル
message UserProfile {
uint32 user_id = 1;
string user_name = 2;
FollowType follow_type = 3;
}
// レスポンスメッセージ
message UserFollowResponse {
repeated UserProfile user_profiles = 1;
}
// サービス定義
service UserFollowService {
rpc GetUserFollows(UserFollowRequest) returns (UserFollowResponse) {}
}
```
### 3. gRPCサーバー実装
gRPCのサーバー側の実装では、`GetUserFollows` RPCを実装し、リクエストに基づいてデータベースから適切なデータを取得し、レスポンスを構築します。この例では、実際のデータベース操作やgRPCサーバーの起動部分は省略し、主な処理の概念を説明します。
```go
package main
import (
"context"
"fmt"
"log"
"net"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
pb "path/to/your/protobuf/package"
)
type server struct {
pb.UnimplementedUserFollowServiceServer
}
func (s *server) GetUserFollows(ctx context.Context, req *pb.UserFollowRequest) (*pb.UserFollowResponse, error) {
// データベース接続とロジックの実装（例示）
db, err := gorm.Open(sqlite.Open("your_database.db"), &gorm.Config{})
if err != nil {
log.Fatalf("failed to connect database: %v", err)
}
// ここでデータベースからデータを取得し、レスポンスを構築
// 実際の実装は、リクエストのフォロータイプに応じて異なります
return &pb.UserFollowResponse{
// レスポンスにユーザープロファイルを追加
}, nil
}
func main() {
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", 8080"))
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterUserFollowServiceServer(s, &server{})
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}
```
このコードは、gRPCサーバーを8080ポートで起動し、`UserFollowService`を実装する基本的なフレームワークを提供します。`GetUserFollows`関数内で、リクエストに応じたロジックを実装する必要があります。これには、`g_likes`テーブルと`g_user`テーブルからデータを取得し、条件に応じて加工する処理が含まれます。
### データベースからデータを取得して処理する例
ここでは、`GetUserFollows`関数内で、特定のユーザーのフォロー関係に応じたデータを取得する疑似コードを示します。実際には、リクエストパラメータに応じて、フォローしているユーザーのリスト、フォローされているユーザーのリスト、相互フォローのリストを取得するロジックを実装する必要があります。
```go
// 疑似コード、具体的な実装は状況に応じて調整してください
func (s *server) GetUserFollows(ctx context.Context, req *pb.UserFollowRequest) (*pb.UserFollowResponse, error) {
db, err := gorm.Open(sqlite.Open("your_database.db"), &gorm.Config{})
if err != nil {
return nil, err
}
var userProfiles *pb.UserProfile
// リクエストに応じた処理
switch req.FollowType {
case pb.FollowType_FOLLOW:
// フォローしているユーザーのリストを取得するロジック
case pb.FollowType_FOLLOWER:
// フォローされているユーザーのリストを取得するロジック
case pb.FollowType_FOLLOW_FOLLOWER:
// 相互フォローのユーザーリストを取得するロジック
default:
// 該当しない場合の処理
}
// データベースから取得したデータを基にレスポンスを構築
return &pb.UserFollowResponse{
UserProfiles: userProfiles,
}, nil
}
```
ここでのポイントは、`g_likes`テーブルと`g_user`テーブルを結合して、必要な情報を取得するSQLクエリを構築することです。GORMの`Joins`や`Where`メソッドを活用して、条件にマッチするレコードを検索します。
このサンプルコードは、実際のビジネスロジックやエラーハンドリングを大幅に単純化しています。実際のアプリケーションでは、セキュリティ対策（たとえば、SQLインジェクション対策）、エラーハンドリング、効率的なデータベースアクセス方法（インデックスの活用など）にも注意を払う必要があります。
<b>フォローリスト</b>
パフォーマンスを考慮し、`g_likes`テーブルからフォローしているユーザーのIDを一度に取得した後、それを使って`g_user`テーブルからユーザー名を別途取得する方法を示します。これにより、DBへのクエリ回数を減らし、効率的なデータアクセスを実現します。
```go
func (s *server) GetUserFollows(ctx context.Context, userID uint) (*pb.UserFollowResponse, error) {
db, err := gorm.Open(sqlite.Open("your_database.db"), &gorm.Config{})
if err != nil {
return nil, err
}
// Step 1: ユーザーがフォローしているユーザーのIDを取得
var followUserIDs uint
err = db.Model(&GLike{}).Where("user_id = ?", userID).Select("follow_user_id").Find(&followUserIDs).Error
if err != nil {
return nil, err
}
if len(followUserIDs) == 0 {
// フォローしているユーザーがいない場合は空のレスポンスを返す
return &pb.UserFollowResponse{}, nil
}
// Step 2: 取得したユーザーIDからユーザー名を取得
var users GUser
err = db.Where("user_id IN ?", followUserIDs).Find(&users).Error
if err != nil {
return nil, err
}
// ユーザー名をレスポンスにマッピング
userProfiles := make(*pb.UserProfile, len(users))
for i, user := range users {
userProfiles[i] = &pb.UserProfile{
UserId: uint32(user.UserID),
UserName: user.UserName,
FollowType: pb.FollowType_FOLLOW, // このユーザーはフォローしているタイプ
}
}
return &pb.UserFollowResponse{
UserProfiles: userProfiles,
}, nil
}
```
この方法では、まずフォローしているユーザーのIDのリストを`g_likes`テーブルから取得します。次に、そのリストを使って`g_user`テーブルからユーザー名を含む情報を一括で取得します。最後に、この情報を基にレスポンスを構築しています。
このアプローチにより、データベースへの問い合わせを効率的に行い、特に大量のデータを扱う場合のパフォーマンスを向上させることができます。ただし、実際には認証情報からユーザーIDを取得するロジックをこの関数に組み込む必要がありますが、その部分はここでは省略しています。
### フォロワーリスト
もちろんです。フォローされている（フォロワーの）ユーザーのリストを取得するロジックも、前述の方法と同様に、効率的にデータを取得するために`IN`句を使用します。このロジックでは、特定のユーザーIDに対して、他のユーザーからフォローされている（つまり、そのユーザーIDが`follow_user_id`になっているレコード）ユーザーの情報を`g_likes`テーブルと`g_user`テーブルから取得します。
```go
func (s *server) GetFollowers(ctx context.Context, userID uint) (*pb.UserFollowResponse, error) {
db, err := gorm.Open(sqlite.Open("your_database.db"), &gorm.Config{})
if err != nil {
return nil, err
}
// Step 1: ユーザーをフォローしているユーザーのIDを取得
var followerUserIDs uint
err = db.Model(&GLike{}).Where("follow_user_id = ?", userID).Select("user_id").Find(&followerUserIDs).Error
if err != nil {
return nil, err
}
if len(followerUserIDs) == 0 {
// フォロワーがいない場合は空のレスポンスを返す
return &pb.UserFollowResponse{}, nil
}
// Step 2: 取得したユーザーIDからユーザー名を取得
var users GUser
err = db.Where("user_id IN ?", followerUserIDs).Find(&users).Error
if err != nil {
return nil, err
}
// ユーザー名をレスポンスにマッピング
userProfiles := make(*pb.UserProfile, len(users))
for i, user := range users {
userProfiles[i] = &pb.UserProfile{
UserId: uint32(user.UserID),
UserName: user.UserName,
FollowType: pb.FollowType_FOLLOWER, // このユーザーはフォローされているタイプ（フォロワー）
}
}
return &pb.UserFollowResponse{
UserProfiles: userProfiles,
}, nil
}
```
この関数では、最初に特定のユーザーIDをフォローしているユーザーのIDを`g_likes`テーブルから取得します。この時点で、`user_id`がフォロワーのユーザーIDに相当します。次に、取得したフォロワーのIDを使って`g_user`テーブルからユーザー名を含む情報を一括で取得します。最後に、取得した情報をレスポンスの形式に合わせて構築しています。
この方法により、特定のユーザーに対するフォロワーのリストを効率的に取得し、クライアントに提供することができます。この処理も、前述のフォローしているユーザーのリストを取得する処理と同様に、データベースへのアクセスを最適化してパフォーマンスを向上させています。
<b>スライス説明</b>
`userProfiles := make(*pb.UserProfile, len(users))`のこの行は、Go言語でスライスを初期化する標準的な方法の一つです。ここでの目的は、`pb.UserProfile`型のポインタを要素とするスライス（つまり、`UserProfile`オブジェクトのリスト）を作成し、そのサイズを`users`スライスの長さ（つまり、取得したユーザー情報の数）と同じにすることです。`make`関数は、指定された型のスライスを初期化してメモリを割り当て、指定されたサイズ（ここでは`len(users)`）でスライスを作成します。
このコードの詳細な意味は以下の通りです：
- `make(*pb.UserProfile, len(users))`：`*pb.UserProfile`型（`pb.UserProfile`のポインタ型）の空のスライスを作成します。このスライスの初期容量と長さは`users`スライスの長さ（`len(users)`）です。これにより、`users`に含まれる各ユーザー情報に対応する`UserProfile`オブジェクトを保存するためのスペースが確保されます。
- `userProfiles`：上記で作成したスライスを参照する変数です。このスライスは、後に`users`スライスから取得した各ユーザー情報を基に構築される`UserProfile`オブジェクトのポインタを格納するために使用されます。
この処理は、データベースから取得したユーザー情報（`users`スライスに格納されている）を、gRPCのレスポンスメッセージに変換するための準備として必要です。具体的には、`users`スライスに含まれる各`GUser`オブジェクトを、`pb.UserProfile`（プロトコルバッファ定義に基づくユーザープロファイルの構造体）のインスタンスに変換し、それを`userProfiles`スライスに追加していきます。この過程で、最終的にクライアントに返すレスポンスオブジェクトが構築されます。
## 相互フォロー
相互フォローのユーザーリストを取得するには、`g_likes`テーブルを使って、ユーザーがフォローしている人とフォローされている人の両方の条件を満たすユーザーのリストを抽出します。このプロセスには、まずフォローしているユーザーのIDのリストとフォローされているユーザーのIDのリストを取得し、その交差点（共通部分）を見つけることが含まれます。以下は、そのロジックを実装した例です。
```go
func (s *server) GetMutualFollows(ctx context.Context, userID uint) (*pb.UserFollowResponse, error) {
db, err := gorm.Open(sqlite.Open("your_database.db"), &gorm.Config{})
if err != nil {
return nil, err
}
// フォローしているユーザーのIDリストを取得
var followingUserIDs uint
err = db.Model(&GLike{}).Where("user_id = ?", userID).Select("follow_user_id").Find(&followingUserIDs).Error
if err != nil {
return nil, err
}
// フォローされているユーザーのIDリストを取得
var followerUserIDs uint
err = db.Model(&GLike{}).Where("follow_user_id = ?", userID).Select("user_id").Find(&followerUserIDs).Error
if err != nil {
return nil, err
}
// 相互フォローしているユーザーのIDを見つける
mutualFollowIDs := intersection(followingUserIDs, followerUserIDs)
if len(mutualFollowIDs) == 0 {
// 相互フォローがいない場合は空のレスポンスを返す
return &pb.UserFollowResponse{}, nil
}
// 相互フォローしているユーザーの情報を取得
var users GUser
err = db.Where("user_id IN ?", mutualFollowIDs).Find(&users).Error
if err != nil {
return nil, err
}
// レスポンスを構築
userProfiles := make(*pb.UserProfile, len(users))
for i, user := range users {
userProfiles[i] = &pb.UserProfile{
UserId: uint32(user.UserID),
UserName: user.UserName,
FollowType: pb.FollowType_FOLLOW_FOLLOWER, // 相互フォロー
}
}
return &pb.UserFollowResponse{
UserProfiles: userProfiles,
}, nil
}
// 二つのスライスの交差点（共通部分）を見つけるヘルパー関数
func intersection(a, b uint) uint {
m := make(map[uint]bool)
var intersection uint
for _, item := range a {
m[item] = true
}
for _, item := range b {
if _, ok := m[item]; ok {
intersection = append(intersection, item)
}
}
return intersection
}
```
このロジックでは、まず指定されたユーザーIDがフォローしているユーザーのIDリストと、そのユーザーをフォローしている（フォロワーの）ユーザーのIDリストを取得します。その後、`intersection`関数を使って、これら二つのリストの共通部分（相互フォローしているユーザーのIDリスト）を計算します。最後に、このIDリストを使って`g_user`テーブルから相互フォローしているユーザーの詳細情報を取得し、レスポンスを構築しています。
このアプローチにより、指定されたユーザーと相互フォロー関係にあるユーザーのリストを効率的に取得できます。
<b>ヘルパー関数説明</b>
`intersection`関数は、二つの`uint`型のスライス（リスト）`a`と`b`の間で共通する要素（交差点、または積集合）を見つけるためのヘルパー関数です。この関数の目的は、特にこのケースでは、相互にフォローし合っているユーザーのIDを識別することです。ここでのロジックは、効率的に共通要素を見つけ出すためにマップ（連想配列）を使用しています。
関数の手順は以下の通りです：
1. **マップの初期化**: 最初に、`uint`型のキーを持ち、`bool`型の値を持つマップ`m`を初期化します。このマップは、スライス`a`の要素が存在するかどうかを追跡するために使用されます。
2. **スライス`a`の要素をマップに登録**: スライス`a`をループし、各要素をマップ`m`にキーとして追加します。このとき、マップの値は`true`に設定されます（実際には、値自体は重要ではありません。このマップは、要素が存在するかどうかのみを追跡します）。
3. **スライス`b`の要素がマップに存在するか確認**: 次に、スライス`b`をループし、その各要素がマップ`m`に存在するかどうかを確認します。要素がマップに存在する（つまり、スライス`a`と`b`に共通する要素である）場合、その要素は交差点に含まれるため、結果のスライス`intersection`に追加されます。
4. **結果のスライスを返す**: 最後に、交差点に含まれる要素を集めたスライス`intersection`を返します。
このヘルパー関数により、二つのスライスの共通部分を効率的に見つけることができます。相互フォローのユーザーIDを識別するこのケースでは、一方のユーザーがフォローしている人のリストと、そのユーザーをフォローしている人のリストの共通部分を見つけるために使用されます。
```go
func intersection(a, b uint) uint {
m := make(map[uint]bool) // ステップ1: マップの初期化
var intersection uint
for _, item := range a { // ステップ2: スライス`a`の要素をマップに登録
m[item] = true
}
for _, item := range b { // ステップ3: スライス`b`の要素がマップに存在するか確認
if _, ok := m[item]; ok {
intersection = append(intersection, item) // 交差点に追加
}
}
return intersection // ステップ4: 結果のスライスを返す
}
```
この関数は、効率的に集合の操作を行う一例であり、Go言語で集合を扱う際の典型的なアプローチを示しています。
## ロジックをまとめる
統合したコード例を以下に示します。このコードは、リクエストの`FollowType`に基づいて、ユーザーがフォローしているリスト、フォローされているリスト、または相互フォローのユーザーリストを取得するロジックを含む`GetUserFollows`関数の一部として機能します。リクエストに応じて適切な処理を行い、結果をレスポンスとして返します。
```go
func (s *server) GetUserFollows(ctx context.Context, req *pb.UserFollowRequest, userID uint) (*pb.UserFollowResponse, error) {
db, err := gorm.Open(sqlite.Open("your_database.db"), &gorm.Config{})
if err != nil {
return nil, err
}
var userIDs uint
var users GUser
// リクエストに応じた処理
switch req.FollowType {
case pb.FollowType_FOLLOW:
// フォローしているユーザーのIDリストを取得
err = db.Model(&GLike{}).Where("user_id = ?", userID).Select("follow_user_id").Find(&userIDs).Error
case pb.FollowType_FOLLOWER:
// フォローされているユーザーのIDリストを取得
err = db.Model(&GLike{}).Where("follow_user_id = ?", userID).Select("user_id").Find(&userIDs).Error
case pb.FollowType_FOLLOW_FOLLOWER:
// 相互フォローしているユーザーのIDリストを取得
var followingUserIDs uint
var followerUserIDs uint
err = db.Model(&GLike{}).Where("user_id = ?", userID).Select("follow_user_id").Find(&followingUserIDs).Error
if err != nil {
return nil, err
}
err = db.Model(&GLike{}).Where("follow_user_id = ?", userID).Select("user_id").Find(&followerUserIDs).Error
if err != nil {
return nil, err
}
userIDs = intersection(followingUserIDs, followerUserIDs)
default:
// 該当しない場合は空のレスポンスを返す
return &pb.UserFollowResponse{}, nil
}
if err != nil {
return nil, err
}
if len(userIDs) > 0 {
// 取得したユーザーIDからユーザー情報を取得
err = db.Where("user_id IN ?", userIDs).Find(&users).Error
if err != nil {
return nil, err
}
}
// ユーザー情報からレスポンスを構築
userProfiles := make(*pb.UserProfile, len(users))
for i, user := range users {
userProfiles[i] = &pb.UserProfile{
UserId: uint32(user.UserID),
UserName: user.UserName,
FollowType: req.FollowType, // リクエストに応じたフォロータイプ
}
}
return &pb.UserFollowResponse{
UserProfiles: userProfiles,
}, nil
}
```
この関数は、リクエストタイプに応じて異なるロジックを実行し、フォロー関係に基づくユーザーリストを取得して返します。相互フォローの場合は、二つのリスト（フォローしている人とフォローされている人）の共通部分を計算するために、先に説明した`intersection`関数を使用しています。
このコードは、具体的なユーザーIDをどのようにして取得するか（例: 認証情報から）については触れていません。その部分は、実際のアプリケーションの認証メカニズムによって異なります。また、エラーハンドリングは基本的なレベルでしか行っていません
## エラーハンドリング追加例
はい、Go言語の強力な型システムと、GORMやgRPCのようなフレームワークを使うと、かなり簡潔かつ効率的にバックエンドのロジックを実装することができます。エラーハンドリングに関しては、Go言語はエラーを明示的に扱う設計哲学を持っているため、各ステップで発生可能なエラーを適切にチェックし、必要に応じて対処することが重要です。
以下は、前述のコード例にエラーハンドリングを追加したバージョンです。この例では、各データベース操作後にエラーが発生していないかをチェックし、エラーがあればそれを呼び出し元に返して処理を中断します。
```go
func (s *server) GetUserFollows(ctx context.Context, req *pb.UserFollowRequest, userID uint) (*pb.UserFollowResponse, error) {
db, err := gorm.Open(sqlite.Open("your_database.db"), &gorm.Config{})
if err != nil {
// データベース接続エラー
return nil, fmt.Errorf("failed to connect to database: %w", err)
}
var userIDs uint
switch req.FollowType {
case pb.FollowType_FOLLOW:
if err := db.Model(&GLike{}).Where("user_id = ?", userID).Select("follow_user_id").Find(&userIDs).Error; err != nil {
return nil, fmt.Errorf("error fetching following user IDs: %w", err)
}
case pb.FollowType_FOLLOWER:
if err := db.Model(&GLike{}).Where("follow_user_id = ?", userID).Select("user_id").Find(&userIDs).Error; err != nil {
return nil, fmt.Errorf("error fetching follower user IDs: %w", err)
}
case pb.FollowType_FOLLOW_FOLLOWER:
var followingUserIDs, followerUserIDs uint
if err := db.Model(&GLike{}).Where("user_id = ?", userID).Select("follow_user_id").Find(&followingUserIDs).Error; err != nil {
return nil, fmt.Errorf("error fetching following user IDs for mutual follow: %w", err)
}
if err := db.Model(&GLike{}).Where("follow_user_id = ?", userID).Select("user_id").Find(&followerUserIDs).Error; err != nil {
return nil, fmt.Errorf("error fetching follower user IDs for mutual follow: %w", err)
}
userIDs = intersection(followingUserIDs, followerUserIDs)
default:
return &pb.UserFollowResponse{}, nil
}
var users GUser
if len(userIDs) > 0 {
if err := db.Where("user_id IN ?", userIDs).Find(&users).Error; err != nil {
return nil, fmt.Errorf("error fetching user details: %w", err)
}
}
userProfiles := make(*pb.UserProfile, len(users))
for i, user := range users {
userProfiles[i] = &pb.UserProfile{
UserId: uint32(user.UserID),
UserName: user.UserName,
FollowType: req.FollowType,
}
}
return &pb.UserFollowResponse{UserProfiles: userProfiles}, nil
}
```
このコードでは、各操作後に`if err != nil`ブロックを使ってエラーをチェックし、発生したエラーを包括的なメッセージとともに返しています。これにより、エラーが発生した場合の原因をより詳細に追跡しやすくなり、デバッグを容易にします。Go言語のエラーハンドリングは、このようにエラーを積極的に管理し、適切な場所で処理を行うことで、信頼性の高いアプリケーションを構築することを促します。
## レスポンス追加
<b>ist_max追加するとどうなるか</b>
message UserFollowResponse {
repeated UserProfile user_profiles = 1;
int32 list_max = 2; // 追加されたフィールド
}
`proto`ファイルに`UserProfile`の型と、レスポンスメッセージに整数型の`list_max`を追加することで、レスポンスメッセージにユーザープロファイルのリストと、そのリストの最大長を示すフィールドが含まれるようになります。この変更により、レスポンスの柔軟性と情報の豊富さが向上します。具体的には、以下のように変更されます。
### 変更前の`UserProfile`とレスポンスメッセージ定義
```protobuf
message UserProfile {
uint32 user_id = 1;
string user_name = 2;
FollowType follow_type = 3;
}
```
### 変更後の`UserProfile`とレスポンスメッセージ定義
`UserProfile`の定義は変更なしでそのままですが、レスポンスメッセージに`list_max`フィールドを追加します。
```protobuf
message UserFollowResponse {
repeated UserProfile user_profiles = 1;
int32 list_max = 2; // 追加されたフィールド
}
```
### 追加された`list_max`の意味合いと利用方法
- `list_max`フィールドは、クライアントに対して、レスポンスとして返されるユーザープロファイルリストの最大長を示します。これにより、クライアントは取得できるユーザープロファイルの総数を事前に知ることができ、ページネーションやリストの表示制限などに利用できます。
- 例えば、サーバーがフォロワーのリストを返す際に、全フォロワーが多数いる場合にすべてを一度に返すのではなく、最初のN個だけを返し、`list_max`には全フォロワー数を設定することで、クライアント側で「さらに読み込む」機能を実装できます。
- このフィールドはオプショナルであり、レスポンスに含めるかどうかは、サーバー側の実装に依存します。利用シナリオに応じて、この値を適切に設定することが推奨されます。
このように`proto`ファイルを変更することで、APIのレスポンスがより詳細な情報を提供できるようになり、クライアント側でのデータ処理や表示ロジックがより柔軟になります。
`list_max`フィールドをレスポンスメッセージに追加することで、Go言語でのgRPCサーバー実装におけるレスポンスの構築方法が変わります。`list_max`には、例えば、特定のクエリに対する結果の総数や、レスポンスとして返すリストの最大許容数など、クライアントにとって有用な情報を設定することができます。以下に、`list_max`を含むレスポンスを構築する方法の例を示します。
### `GetUserFollows`関数の更新例
この例では、`GetUserFollows`関数が`list_max`に具体的な値を設定してレスポンスを返すように変更されています。`list_max`には、例として、取得したユーザープロファイルリストの総数を設定します。実際のアプリケーションでは、この値をデータベースのクエリ結果の総数などから動的に導出することが考えられます。
```go
func (s *server) GetUserFollows(ctx context.Context, req *pb.UserFollowRequest, userID uint) (*pb.UserFollowResponse, error) {
// データベース接続などの初期化処理は省略
// ユーザープロファイルリストの取得ロジックは省略
// 仮に取得したユーザープロファイルの数を示す変数として usersCount を設定します
usersCount := 100 // 実際にはデータベースから取得したユーザーの総数など
// 仮にレスポンスに含めるユーザープロファイルのリストが10件だとします
userProfiles := make(*pb.UserProfile, 10)
// ユーザープロファイルの設定ロジックは省略
// レスポンスを構築
response := &pb.UserFollowResponse{
UserProfiles: userProfiles,
ListMax: int32(usersCount), // list_max に総数を設定
}
return response, nil
}
```
```go
func (s *server) GetUserFollows(ctx context.Context, req *pb.UserFollowRequest, userID uint) (*pb.UserFollowResponse, error) {
// データベース接続と初期化処理
var users GUser
var listMax int32
switch req.FollowType {
case pb.FollowType_FOLLOW:
// フォローしているユーザーのリストとその総数を取得するロジック
// users にユーザーリストをセット
// listMax に総数をセット
case pb.FollowType_FOLLOWER:
// フォローされているユーザーのリストとその総数を取得するロジック
// users にユーザーリストをセット
// listMax に総数をセット
case pb.FollowType_FOLLOW_FOLLOWER:
// 相互フォローのユーザーリストとその総数を取得するロジック
// users にユーザーリストをセット
// listMax に総数をセット
default:
// 該当しない場合の処理
}
// users と listMax を使ってレスポンスを構築
userProfiles := make([]*pb.UserProfile, len(users))
for i, user := range users {
userProfiles[i] = &pb.UserProfile{
UserId: uint32(user.UserID),
UserName: user.UserName,
FollowType: req.FollowType,
}
}
response := &pb.UserFollowResponse{
UserProfiles: userProfiles,
ListMax: listMax, // list_max に設定
}
return response, nil
}
```
このコードでは、`list_max`フィールドに`usersCount`変数の値を設定しています。これにより、クライアント側は、レスポンスとして受け取ったユーザープロファイルリストが全体のうちの一部であること、そしてその全体のサイズが何であるかを知ることができます。この情報は、ユーザーインターフェースでのページネーションの実装や、データのさらなる取得が必要かどうかを判断する際に役立ちます。
