AUTH

pkg/a2r/api2rpc.go

@@ -12,7 +12,7 @@ import (
 
 func Call[A, B, C any](
 	rpc func(client C, ctx context.Context, req *A, options ...grpc.CallOption) (*B, error),
-	client func() C,
+	client C,
 	c *gin.Context,
 ) {
 	var req A
@@ -28,10 +28,7 @@ func Call[A, B, C any](
 			return
 		}
 	}
-	log.ZDebug(c, "gin bind json success", "req", req)
-	cli := client()
-	log.ZDebug(c, "get conn success", "req", req)
-	data, err := rpc(cli, c, &req)
+	data, err := rpc(client, c, &req)
 	if err != nil {
 		apiresp.GinError(c, err) // RPC调用失败
 		return

pkg/rpcclient/auth.go

@@ -0,0 +1,25 @@
+package rpcclient
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/auth"
+	"google.golang.org/grpc"
+)
+
+func NewAuth(discov discoveryregistry.SvcDiscoveryRegistry) *Auth {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImAuthName)
+	if err != nil {
+		panic(err)
+	}
+	client := auth.NewAuthClient(conn)
+	return &Auth{discov: discov, conn: conn, Client: client}
+}
+
+type Auth struct {
+	conn   *grpc.ClientConn
+	Client auth.AuthClient
+	discov discoveryregistry.SvcDiscoveryRegistry
+}

pkg/rpcclient/black.go

@@ -1,30 +0,0 @@
-package rpcclient
-
-import (
-	"context"
-
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
-)
-
-type BlackClient struct {
-	*MetaClient
-}
-
-func NewBlackClient(zk discoveryRegistry.SvcDiscoveryRegistry) *BlackClient {
-	return &BlackClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImFriendName)}
-}
-
-// possibleBlackUserID是否被userID拉黑，也就是是否在userID的黑名单中
-func (b *BlackClient) IsBlocked(ctx context.Context, possibleBlackUserID, userID string) (bool, error) {
-	cc, err := b.getConn(ctx)
-	if err != nil {
-		return false, err
-	}
-	r, err := friend.NewFriendClient(cc).IsBlack(ctx, &friend.IsBlackReq{UserID1: possibleBlackUserID, UserID2: userID})
-	if err != nil {
-		return false, err
-	}
-	return r.InUser2Blacks, nil
-}

pkg/rpcclient/conversation.go

@@ -5,100 +5,83 @@ import (
 	"fmt"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
 	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
+	"google.golang.org/grpc"
 )
 
-type ConversationClient struct {
-	*MetaClient
+type Conversation struct {
+	Client conversation.ConversationClient
+	conn   *grpc.ClientConn
+	discov discoveryregistry.SvcDiscoveryRegistry
 }
 
-func NewConversationClient(zk discoveryRegistry.SvcDiscoveryRegistry) *ConversationClient {
-	return &ConversationClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImConversationName)}
-}
-
-func (c *ConversationClient) ModifyConversationField(ctx context.Context, req *pbConversation.ModifyConversationFieldReq) error {
-	cc, err := c.getConn(ctx)
+func NewConversation(discov discoveryregistry.SvcDiscoveryRegistry) *Conversation {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImConversationName)
 	if err != nil {
-		return err
+		panic(err)
 	}
-	_, err = pbConversation.NewConversationClient(cc).ModifyConversationField(ctx, req)
+	client := conversation.NewConversationClient(conn)
+	return &Conversation{discov: discov, conn: conn, Client: client}
+}
+
+type ConversationRpcClient Conversation
+
+func NewConversationRpcClient(discov discoveryregistry.SvcDiscoveryRegistry) ConversationRpcClient {
+	return ConversationRpcClient(*NewConversation(discov))
+}
+
+func (c *ConversationRpcClient) ModifyConversationField(ctx context.Context, req *pbConversation.ModifyConversationFieldReq) error {
+	_, err := c.Client.ModifyConversationField(ctx, req)
 	return err
 }
 
-func (c *ConversationClient) GetSingleConversationRecvMsgOpt(ctx context.Context, userID, conversationID string) (int32, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return 0, err
-	}
+func (c *ConversationRpcClient) GetSingleConversationRecvMsgOpt(ctx context.Context, userID, conversationID string) (int32, error) {
 	var req pbConversation.GetConversationReq
 	req.OwnerUserID = userID
 	req.ConversationID = conversationID
-	conversation, err := pbConversation.NewConversationClient(cc).GetConversation(ctx, &req)
+	conversation, err := c.Client.GetConversation(ctx, &req)
 	if err != nil {
 		return 0, err
 	}
 	return conversation.GetConversation().RecvMsgOpt, err
 }
 
-func (c *ConversationClient) SingleChatFirstCreateConversation(ctx context.Context, recvID, sendID string) error {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).CreateSingleChatConversations(ctx, &pbConversation.CreateSingleChatConversationsReq{RecvID: recvID, SendID: sendID})
+func (c *ConversationRpcClient) SingleChatFirstCreateConversation(ctx context.Context, recvID, sendID string) error {
+	_, err := c.Client.CreateSingleChatConversations(ctx, &pbConversation.CreateSingleChatConversationsReq{RecvID: recvID, SendID: sendID})
 	return err
 }
 
-func (c *ConversationClient) GroupChatFirstCreateConversation(ctx context.Context, groupID string, userIDs []string) error {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).CreateGroupChatConversations(ctx, &pbConversation.CreateGroupChatConversationsReq{UserIDs: userIDs, GroupID: groupID})
+func (c *ConversationRpcClient) GroupChatFirstCreateConversation(ctx context.Context, groupID string, userIDs []string) error {
+	_, err := c.Client.CreateGroupChatConversations(ctx, &pbConversation.CreateGroupChatConversationsReq{UserIDs: userIDs, GroupID: groupID})
 	return err
 }
 
-func (c *ConversationClient) SetConversationMaxSeq(ctx context.Context, ownerUserIDs []string, conversationID string, maxSeq int64) error {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).SetConversationMaxSeq(ctx, &pbConversation.SetConversationMaxSeqReq{OwnerUserID: ownerUserIDs, ConversationID: conversationID, MaxSeq: maxSeq})
+func (c *ConversationRpcClient) SetConversationMaxSeq(ctx context.Context, ownerUserIDs []string, conversationID string, maxSeq int64) error {
+	_, err := c.Client.SetConversationMaxSeq(ctx, &pbConversation.SetConversationMaxSeqReq{OwnerUserID: ownerUserIDs, ConversationID: conversationID, MaxSeq: maxSeq})
 	return err
 }
 
-func (c *ConversationClient) GetConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).GetConversationIDs(ctx, &pbConversation.GetConversationIDsReq{UserID: ownerUserID})
+func (c *ConversationRpcClient) GetConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
+	resp, err := c.Client.GetConversationIDs(ctx, &pbConversation.GetConversationIDsReq{UserID: ownerUserID})
 	if err != nil {
 		return nil, err
 	}
 	return resp.ConversationIDs, nil
 }
 
-func (c *ConversationClient) GetConversation(ctx context.Context, ownerUserID, conversationID string) (*pbConversation.Conversation, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).GetConversation(ctx, &pbConversation.GetConversationReq{OwnerUserID: ownerUserID, ConversationID: conversationID})
+func (c *ConversationRpcClient) GetConversation(ctx context.Context, ownerUserID, conversationID string) (*pbConversation.Conversation, error) {
+	resp, err := c.Client.GetConversation(ctx, &pbConversation.GetConversationReq{OwnerUserID: ownerUserID, ConversationID: conversationID})
 	if err != nil {
 		return nil, err
 	}
 	return resp.Conversation, nil
 }
 
-func (c *ConversationClient) GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*pbConversation.Conversation, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).GetConversationsByConversationID(ctx, &pbConversation.GetConversationsByConversationIDReq{ConversationIDs: conversationIDs})
+func (c *ConversationRpcClient) GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*pbConversation.Conversation, error) {
+	resp, err := c.Client.GetConversationsByConversationID(ctx, &pbConversation.GetConversationsByConversationIDReq{ConversationIDs: conversationIDs})
 	if err != nil {
 		return nil, err
 	}
@@ -108,12 +91,8 @@ func (c *ConversationClient) GetConversationsByConversationID(ctx context.Contex
 	return resp.Conversations, nil
 }
 
-func (c *ConversationClient) GetConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*pbConversation.Conversation, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).GetConversations(ctx, &pbConversation.GetConversationsReq{OwnerUserID: ownerUserID, ConversationIDs: conversationIDs})
+func (c *ConversationRpcClient) GetConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*pbConversation.Conversation, error) {
+	resp, err := c.Client.GetConversations(ctx, &pbConversation.GetConversationsReq{OwnerUserID: ownerUserID, ConversationIDs: conversationIDs})
 	if err != nil {
 		return nil, err
 	}

pkg/rpcclient/friend.go

@@ -4,25 +4,35 @@ import (
 	"context"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"google.golang.org/grpc"
 )
 
-type FriendClient struct {
-	*MetaClient
+type Friend struct {
+	conn   *grpc.ClientConn
+	Client friend.FriendClient
+	discov discoveryregistry.SvcDiscoveryRegistry
 }
 
-func NewFriendClient(zk discoveryRegistry.SvcDiscoveryRegistry) *FriendClient {
-	return &FriendClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImFriendName)}
-}
-
-func (f *FriendClient) GetFriendsInfo(ctx context.Context, ownerUserID, friendUserID string) (resp *sdkws.FriendInfo, err error) {
-	cc, err := f.getConn(ctx)
+func NewFriend(discov discoveryregistry.SvcDiscoveryRegistry) *Friend {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImFriendName)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
-	r, err := friend.NewFriendClient(cc).GetDesignatedFriends(ctx, &friend.GetDesignatedFriendsReq{OwnerUserID: ownerUserID, FriendUserIDs: []string{friendUserID}})
+	client := friend.NewFriendClient(conn)
+	return &Friend{discov: discov, conn: conn, Client: client}
+}
+
+type FriendRpcClient Friend
+
+func NewFriendRpcClient(discov discoveryregistry.SvcDiscoveryRegistry) FriendRpcClient {
+	return FriendRpcClient(*NewFriend(discov))
+}
+
+func (f *FriendRpcClient) GetFriendsInfo(ctx context.Context, ownerUserID, friendUserID string) (resp *sdkws.FriendInfo, err error) {
+	r, err := f.Client.GetDesignatedFriends(ctx, &friend.GetDesignatedFriendsReq{OwnerUserID: ownerUserID, FriendUserIDs: []string{friendUserID}})
 	if err != nil {
 		return nil, err
 	}
@@ -31,12 +41,8 @@ func (f *FriendClient) GetFriendsInfo(ctx context.Context, ownerUserID, friendUs
 }
 
 // possibleFriendUserID是否在userID的好友中
-func (f *FriendClient) IsFriend(ctx context.Context, possibleFriendUserID, userID string) (bool, error) {
-	cc, err := f.getConn(ctx)
-	if err != nil {
-		return false, err
-	}
-	resp, err := friend.NewFriendClient(cc).IsFriend(ctx, &friend.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID})
+func (f *FriendRpcClient) IsFriend(ctx context.Context, possibleFriendUserID, userID string) (bool, error) {
+	resp, err := f.Client.IsFriend(ctx, &friend.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID})
 	if err != nil {
 		return false, err
 	}
@@ -44,15 +50,19 @@ func (f *FriendClient) IsFriend(ctx context.Context, possibleFriendUserID, userI
 
 }
 
-func (f *FriendClient) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error) {
-	cc, err := f.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
+func (f *FriendRpcClient) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error) {
 	req := friend.GetFriendIDsReq{UserID: ownerUserID}
-	resp, err := friend.NewFriendClient(cc).GetFriendIDs(ctx, &req)
+	resp, err := f.Client.GetFriendIDs(ctx, &req)
 	if err != nil {
 		return nil, err
 	}
 	return resp.FriendIDs, nil
 }
+
+func (b *FriendRpcClient) IsBlocked(ctx context.Context, possibleBlackUserID, userID string) (bool, error) {
+	r, err := b.Client.IsBlack(ctx, &friend.IsBlackReq{UserID1: possibleBlackUserID, UserID2: userID})
+	if err != nil {
+		return false, err
+	}
+	return r.InUser2Blacks, nil
+}

pkg/rpcclient/group.go

@@ -11,27 +11,32 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"google.golang.org/grpc"
 )
 
-type GroupClient struct {
-	MetaClient
+type Group struct {
+	conn   *grpc.ClientConn
+	Client group.GroupClient
+	discov discoveryregistry.SvcDiscoveryRegistry
 }
 
-func NewGroupClient(client discoveryregistry.SvcDiscoveryRegistry) *GroupClient {
-	return &GroupClient{
-		MetaClient: MetaClient{
-			client:          client,
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
-		},
-	}
-}
-
-func (g *GroupClient) GetGroupInfos(ctx context.Context, groupIDs []string, complete bool) ([]*sdkws.GroupInfo, error) {
-	cc, err := g.getConn(ctx)
+func NewGroup(discov discoveryregistry.SvcDiscoveryRegistry) *Group {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImGroupName)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
-	resp, err := group.NewGroupClient(cc).GetGroupsInfo(ctx, &group.GetGroupsInfoReq{
+	client := group.NewGroupClient(conn)
+	return &Group{discov: discov, conn: conn, Client: client}
+}
+
+type GroupRpcClient Group
+
+func NewGroupRpcClient(discov discoveryregistry.SvcDiscoveryRegistry) GroupRpcClient {
+	return GroupRpcClient(*NewGroup(discov))
+}
+
+func (g *GroupRpcClient) GetGroupInfos(ctx context.Context, groupIDs []string, complete bool) ([]*sdkws.GroupInfo, error) {
+	resp, err := g.Client.GetGroupsInfo(ctx, &group.GetGroupsInfoReq{
 		GroupIDs: groupIDs,
 	})
 	if err != nil {
@@ -47,7 +52,7 @@ func (g *GroupClient) GetGroupInfos(ctx context.Context, groupIDs []string, comp
 	return resp.GroupInfos, nil
 }
 
-func (g *GroupClient) GetGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+func (g *GroupRpcClient) GetGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
 	groups, err := g.GetGroupInfos(ctx, []string{groupID}, true)
 	if err != nil {
 		return nil, err
@@ -55,7 +60,7 @@ func (g *GroupClient) GetGroupInfo(ctx context.Context, groupID string) (*sdkws.
 	return groups[0], nil
 }
 
-func (g *GroupClient) GetGroupInfoMap(ctx context.Context, groupIDs []string, complete bool) (map[string]*sdkws.GroupInfo, error) {
+func (g *GroupRpcClient) GetGroupInfoMap(ctx context.Context, groupIDs []string, complete bool) (map[string]*sdkws.GroupInfo, error) {
 	groups, err := g.GetGroupInfos(ctx, groupIDs, complete)
 	if err != nil {
 		return nil, err
@@ -65,12 +70,8 @@ func (g *GroupClient) GetGroupInfoMap(ctx context.Context, groupIDs []string, co
 	}), nil
 }
 
-func (g *GroupClient) GetGroupMemberInfos(ctx context.Context, groupID string, userIDs []string, complete bool) ([]*sdkws.GroupMemberFullInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMembersInfo(ctx, &group.GetGroupMembersInfoReq{
+func (g *GroupRpcClient) GetGroupMemberInfos(ctx context.Context, groupID string, userIDs []string, complete bool) ([]*sdkws.GroupMemberFullInfo, error) {
+	resp, err := g.Client.GetGroupMembersInfo(ctx, &group.GetGroupMembersInfoReq{
 		GroupID: groupID,
 		UserIDs: userIDs,
 	})
@@ -87,7 +88,7 @@ func (g *GroupClient) GetGroupMemberInfos(ctx context.Context, groupID string, u
 	return resp.Members, nil
 }
 
-func (g *GroupClient) GetGroupMemberInfo(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
+func (g *GroupRpcClient) GetGroupMemberInfo(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
 	members, err := g.GetGroupMemberInfos(ctx, groupID, []string{userID}, true)
 	if err != nil {
 		return nil, err
@@ -95,7 +96,7 @@ func (g *GroupClient) GetGroupMemberInfo(ctx context.Context, groupID string, us
 	return members[0], nil
 }
 
-func (g *GroupClient) GetGroupMemberInfoMap(ctx context.Context, groupID string, userIDs []string, complete bool) (map[string]*sdkws.GroupMemberFullInfo, error) {
+func (g *GroupRpcClient) GetGroupMemberInfoMap(ctx context.Context, groupID string, userIDs []string, complete bool) (map[string]*sdkws.GroupMemberFullInfo, error) {
 	members, err := g.GetGroupMemberInfos(ctx, groupID, userIDs, true)
 	if err != nil {
 		return nil, err
@@ -105,12 +106,8 @@ func (g *GroupClient) GetGroupMemberInfoMap(ctx context.Context, groupID string,
 	}), nil
 }
 
-func (g *GroupClient) GetOwnerAndAdminInfos(ctx context.Context, groupID string) ([]*sdkws.GroupMemberFullInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
+func (g *GroupRpcClient) GetOwnerAndAdminInfos(ctx context.Context, groupID string) ([]*sdkws.GroupMemberFullInfo, error) {
+	resp, err := g.Client.GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
 		GroupID:    groupID,
 		RoleLevels: []int32{constant.GroupOwner, constant.GroupAdmin},
 	})
@@ -120,24 +117,16 @@ func (g *GroupClient) GetOwnerAndAdminInfos(ctx context.Context, groupID string)
 	return resp.Members, nil
 }
 
-func (g *GroupClient) GetOwnerInfo(ctx context.Context, groupID string) (*sdkws.GroupMemberFullInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
+func (g *GroupRpcClient) GetOwnerInfo(ctx context.Context, groupID string) (*sdkws.GroupMemberFullInfo, error) {
+	resp, err := g.Client.GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
 		GroupID:    groupID,
 		RoleLevels: []int32{constant.GroupOwner},
 	})
 	return resp.Members[0], err
 }
 
-func (g *GroupClient) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{
+func (g *GroupRpcClient) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) {
+	resp, err := g.Client.GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{
 		GroupID: groupID,
 	})
 	if err != nil {
@@ -146,12 +135,8 @@ func (g *GroupClient) GetGroupMemberIDs(ctx context.Context, groupID string) ([]
 	return resp.UserIDs, nil
 }
 
-func (g *GroupClient) GetGroupInfoCache(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupInfoCache(ctx, &group.GetGroupInfoCacheReq{
+func (g *GroupRpcClient) GetGroupInfoCache(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+	resp, err := g.Client.GetGroupInfoCache(ctx, &group.GetGroupInfoCacheReq{
 		GroupID: groupID,
 	})
 	if err != nil {
@@ -160,12 +145,8 @@ func (g *GroupClient) GetGroupInfoCache(ctx context.Context, groupID string) (*s
 	return resp.GroupInfo, nil
 }
 
-func (g *GroupClient) GetGroupMemberCache(ctx context.Context, groupID string, groupMemberID string) (*sdkws.GroupMemberFullInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMemberCache(ctx, &group.GetGroupMemberCacheReq{
+func (g *GroupRpcClient) GetGroupMemberCache(ctx context.Context, groupID string, groupMemberID string) (*sdkws.GroupMemberFullInfo, error) {
+	resp, err := g.Client.GetGroupMemberCache(ctx, &group.GetGroupMemberCacheReq{
 		GroupID:       groupID,
 		GroupMemberID: groupMemberID,
 	})

pkg/rpcclient/meta.go

@@ -1,31 +0,0 @@
-package rpcclient
-
-import (
-	"context"
-
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"google.golang.org/grpc"
-)
-
-type MetaClient struct {
-	// contains filtered or unexported fields
-	client          discoveryregistry.SvcDiscoveryRegistry
-	rpcRegisterName string
-}
-
-func NewMetaClient(client discoveryregistry.SvcDiscoveryRegistry, rpcRegisterName string, opts ...MetaClientOptions) *MetaClient {
-	c := &MetaClient{
-		client:          client,
-		rpcRegisterName: rpcRegisterName,
-	}
-	for _, opt := range opts {
-		opt(c)
-	}
-	return c
-}
-
-type MetaClientOptions func(*MetaClient)
-
-func (m *MetaClient) getConn(ctx context.Context) (*grpc.ClientConn, error) {
-	return m.client.GetConn(ctx, m.rpcRegisterName)
-}

pkg/rpcclient/msg.go

@@ -103,48 +103,44 @@ func newSessionTypeConf() map[int32]int32 {
 	}
 }
 
-type MsgClient struct {
-	conn *grpc.ClientConn
-	*MetaClient
+type Message struct {
+	conn   *grpc.ClientConn
+	Client msg.MsgClient
+	discov discoveryregistry.SvcDiscoveryRegistry
 }
 
-func NewMsgClient(discov discoveryregistry.SvcDiscoveryRegistry) *MsgClient {
-	return &MsgClient{MetaClient: NewMetaClient(discov, config.Config.RpcRegisterName.OpenImMsgName)}
-}
-
-func (m *MsgClient) SendMsg(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
-	cc, err := m.getConn(ctx)
+func NewMessage(discov discoveryregistry.SvcDiscoveryRegistry) *Message {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
-	resp, err := msg.NewMsgClient(cc).SendMsg(ctx, req)
+	client := msg.NewMsgClient(conn)
+	return &Message{discov: discov, conn: conn, Client: client}
+}
+
+type MessageRpcClient Message
+
+func NewMessageRpcClient(discov discoveryregistry.SvcDiscoveryRegistry) MessageRpcClient {
+	return MessageRpcClient(*NewMessage(discov))
+}
+
+func (m *MessageRpcClient) SendMsg(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+	resp, err := m.Client.SendMsg(ctx, req)
 	return resp, err
 }
 
-func (m *MsgClient) GetMaxSeq(ctx context.Context, req *sdkws.GetMaxSeqReq) (*sdkws.GetMaxSeqResp, error) {
-	cc, err := m.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).GetMaxSeq(ctx, req)
+func (m *MessageRpcClient) GetMaxSeq(ctx context.Context, req *sdkws.GetMaxSeqReq) (*sdkws.GetMaxSeqResp, error) {
+	resp, err := m.Client.GetMaxSeq(ctx, req)
 	return resp, err
 }
 
-func (m *MsgClient) PullMessageBySeqList(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
-	cc, err := m.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).PullMessageBySeqs(ctx, req)
+func (m *MessageRpcClient) PullMessageBySeqList(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
+	resp, err := m.Client.PullMessageBySeqs(ctx, req)
 	return resp, err
 }
 
-func (m *MsgClient) GetConversationMaxSeq(ctx context.Context, conversationID string) (int64, error) {
-	cc, err := m.getConn(ctx)
-	if err != nil {
-		return 0, err
-	}
-	resp, err := msg.NewMsgClient(cc).GetConversationMaxSeq(ctx, &msg.GetConversationMaxSeqReq{ConversationID: conversationID})
+func (m *MessageRpcClient) GetConversationMaxSeq(ctx context.Context, conversationID string) (int64, error) {
+	resp, err := m.Client.GetConversationMaxSeq(ctx, &msg.GetConversationMaxSeqReq{ConversationID: conversationID})
 	if err != nil {
 		return 0, err
 	}
@@ -167,7 +163,8 @@ func WithLocalSendMsg(sendMsg func(ctx context.Context, req *msg.SendMsgReq) (*m
 
 func WithDiscov(discov discoveryregistry.SvcDiscoveryRegistry) NewNotificationSenderOptions {
 	return func(s *NotificationSender) {
-		s.sendMsg = NewMsgClient(discov).SendMsg
+		rpcClient := NewMessageRpcClient(discov)
+		s.sendMsg = rpcClient.SendMsg
 	}
 }
 

pkg/rpcclient/notification/extend_msg.go

@@ -16,11 +16,11 @@ import (
 )
 
 type ExtendMsgNotificationSender struct {
-	*rpcclient.MsgClient
+	*rpcclient.MessageRpcClient
 }
 
 func NewExtendMsgNotificationSender(client discoveryregistry.SvcDiscoveryRegistry) *ExtendMsgNotificationSender {
-	return &ExtendMsgNotificationSender{rpcclient.NewMsgClient(client)}
+	return &ExtendMsgNotificationSender{}
 }
 
 func (e *ExtendMsgNotificationSender) ExtendMessageUpdatedNotification(ctx context.Context, sendID string, conversationID string, sessionType int32,

pkg/rpcclient/push.go

@@ -8,11 +8,10 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
 )
 
-type PushClient struct {
-	MetaClient
+type Push struct {
 }
 
-func NewPushClient(client discoveryregistry.SvcDiscoveryRegistry) *PushClient {
+func NewPushPush(client discoveryregistry.SvcDiscoveryRegistry) *PushClient {
 	return &PushClient{
 		MetaClient: MetaClient{
 			client:          client,

pkg/rpcclient/third.go

@@ -0,0 +1,25 @@
+package rpcclient
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/third"
+	"google.golang.org/grpc"
+)
+
+type Third struct {
+	conn   *grpc.ClientConn
+	Client third.ThirdClient
+	discov discoveryregistry.SvcDiscoveryRegistry
+}
+
+func NewThird(discov discoveryregistry.SvcDiscoveryRegistry) *Third {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImThirdName)
+	if err != nil {
+		panic(err)
+	}
+	client := third.NewThirdClient(conn)
+	return &Third{discov: discov, Client: client, conn: conn}
+}

pkg/rpcclient/user.go

@@ -11,27 +11,32 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"google.golang.org/grpc"
 )
 
-type UserClient struct {
-	MetaClient
+type User struct {
+	conn   *grpc.ClientConn
+	Client user.UserClient
+	discov discoveryregistry.SvcDiscoveryRegistry
 }
 
-func NewUserClient(client discoveryregistry.SvcDiscoveryRegistry) *UserClient {
-	return &UserClient{
-		MetaClient: MetaClient{
-			client:          client,
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImUserName,
-		},
-	}
-}
-
-func (u *UserClient) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
-	cc, err := u.getConn(ctx)
+func NewUser(discov discoveryregistry.SvcDiscoveryRegistry) *User {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImUserName)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
-	resp, err := user.NewUserClient(cc).GetDesignateUsers(ctx, &user.GetDesignateUsersReq{
+	client := user.NewUserClient(conn)
+	return &User{discov: discov, Client: client, conn: conn}
+}
+
+type UserRpcClient User
+
+func NewUserRpcClient(client discoveryregistry.SvcDiscoveryRegistry) UserRpcClient {
+	return UserRpcClient(*NewUser(client))
+}
+
+func (u *UserRpcClient) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
+	resp, err := u.Client.GetDesignateUsers(ctx, &user.GetDesignateUsersReq{
 		UserIDs: userIDs,
 	})
 	if err != nil {
@@ -45,7 +50,7 @@ func (u *UserClient) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdk
 	return resp.UsersInfo, nil
 }
 
-func (u *UserClient) GetUserInfo(ctx context.Context, userID string) (*sdkws.UserInfo, error) {
+func (u *UserRpcClient) GetUserInfo(ctx context.Context, userID string) (*sdkws.UserInfo, error) {
 	users, err := u.GetUsersInfo(ctx, []string{userID})
 	if err != nil {
 		return nil, err
@@ -53,7 +58,7 @@ func (u *UserClient) GetUserInfo(ctx context.Context, userID string) (*sdkws.Use
 	return users[0], nil
 }
 
-func (u *UserClient) GetUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
+func (u *UserRpcClient) GetUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
 	users, err := u.GetUsersInfo(ctx, userIDs)
 	if err != nil {
 		return nil, err
@@ -63,7 +68,7 @@ func (u *UserClient) GetUsersInfoMap(ctx context.Context, userIDs []string) (map
 	}), nil
 }
 
-func (u *UserClient) GetPublicUserInfos(ctx context.Context, userIDs []string, complete bool) ([]*sdkws.PublicUserInfo, error) {
+func (u *UserRpcClient) GetPublicUserInfos(ctx context.Context, userIDs []string, complete bool) ([]*sdkws.PublicUserInfo, error) {
 	users, err := u.GetUsersInfo(ctx, userIDs)
 	if err != nil {
 		return nil, err
@@ -78,7 +83,7 @@ func (u *UserClient) GetPublicUserInfos(ctx context.Context, userIDs []string, c
 	}), nil
 }
 
-func (u *UserClient) GetPublicUserInfo(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
+func (u *UserRpcClient) GetPublicUserInfo(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
 	users, err := u.GetPublicUserInfos(ctx, []string{userID}, true)
 	if err != nil {
 		return nil, err
@@ -86,7 +91,7 @@ func (u *UserClient) GetPublicUserInfo(ctx context.Context, userID string) (*sdk
 	return users[0], nil
 }
 
-func (u *UserClient) GetPublicUserInfoMap(ctx context.Context, userIDs []string, complete bool) (map[string]*sdkws.PublicUserInfo, error) {
+func (u *UserRpcClient) GetPublicUserInfoMap(ctx context.Context, userIDs []string, complete bool) (map[string]*sdkws.PublicUserInfo, error) {
 	users, err := u.GetPublicUserInfos(ctx, userIDs, complete)
 	if err != nil {
 		return nil, err
@@ -96,12 +101,8 @@ func (u *UserClient) GetPublicUserInfoMap(ctx context.Context, userIDs []string,
 	}), nil
 }
 
-func (u *UserClient) GetUserGlobalMsgRecvOpt(ctx context.Context, userID string) (int32, error) {
-	cc, err := u.getConn(ctx)
-	if err != nil {
-		return 0, err
-	}
-	resp, err := user.NewUserClient(cc).GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{
+func (u *UserRpcClient) GetUserGlobalMsgRecvOpt(ctx context.Context, userID string) (int32, error) {
+	resp, err := u.Client.GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{
 		UserID: userID,
 	})
 	if err != nil {
@@ -110,7 +111,7 @@ func (u *UserClient) GetUserGlobalMsgRecvOpt(ctx context.Context, userID string)
 	return resp.GlobalRecvMsgOpt, err
 }
 
-func (u *UserClient) Access(ctx context.Context, ownerUserID string) error {
+func (u *UserRpcClient) Access(ctx context.Context, ownerUserID string) error {
 	_, err := u.GetUserInfo(ctx, ownerUserID)
 	if err != nil {
 		return err