feat: Optimizing RPC call (#2993)

* pb

* fix: Modifying other fields while setting IsPrivateChat does not take effect

* fix: quote message error revoke

* refactoring scheduled tasks

* refactoring scheduled tasks

* refactoring scheduled tasks

* refactoring scheduled tasks

* refactoring scheduled tasks

* refactoring scheduled tasks

* rpc client

* rpc client

* rpc client

* rpc client

* rpc client

* rpc client

* rpc client

* rpc client

go.mod

@@ -2,8 +2,6 @@ module github.com/openimsdk/open-im-server/v3
 
 go 1.22.7
 
-toolchain go1.23.2
-
 require (
 	firebase.google.com/go/v4 v4.14.1
 	github.com/dtm-labs/rockscache v0.1.1
@@ -14,8 +12,8 @@ require (
 	github.com/gorilla/websocket v1.5.1
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/openimsdk/protocol v0.0.72-alpha.67
+	github.com/openimsdk/protocol v0.0.72-alpha.68
-	github.com/openimsdk/tools v0.0.50-alpha.58
+	github.com/openimsdk/tools v0.0.50-alpha.60
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.18.0
 	github.com/stretchr/testify v1.9.0

go.sum

@@ -319,10 +319,10 @@ github.com/onsi/gomega v1.25.0 h1:Vw7br2PCDYijJHSfBOWhov+8cAnUf8MfMaIOV323l6Y=
 github.com/onsi/gomega v1.25.0/go.mod h1:r+zV744Re+DiYCIPRlYOTxn0YkOLcAnW8k1xXdMPGhM=
 github.com/openimsdk/gomake v0.0.15-alpha.2 h1:5Q8yl8ezy2yx+q8/ucU/t4kJnDfCzNOrkXcDACCqtyM=
 github.com/openimsdk/gomake v0.0.15-alpha.2/go.mod h1:PndCozNc2IsQIciyn9mvEblYWZwJmAI+06z94EY+csI=
-github.com/openimsdk/protocol v0.0.72-alpha.67 h1:zlLbVkoT0OYsjO2RCutQuDFllcfNvZfdYchvlR6UIe0=
+github.com/openimsdk/protocol v0.0.72-alpha.68 h1:Ekn6S9Ftt12Xs/p9kJ39RDr2gSwIczz+MmSHQE4lAek=
-github.com/openimsdk/protocol v0.0.72-alpha.67/go.mod h1:Iet+piS/jaS+kWWyj6EEr36mk4ISzIRYjoMSVA4dq2M=
+github.com/openimsdk/protocol v0.0.72-alpha.68/go.mod h1:Iet+piS/jaS+kWWyj6EEr36mk4ISzIRYjoMSVA4dq2M=
-github.com/openimsdk/tools v0.0.50-alpha.58 h1:hkFL02Bzzp/l5x+tb7kJ9zes7hilh65EQ4qEIthsQX4=
+github.com/openimsdk/tools v0.0.50-alpha.60 h1:dYqYpSdSN5o6CxlEjua2USfwfUiG0tUWFBpqghTjbWE=
-github.com/openimsdk/tools v0.0.50-alpha.58/go.mod h1:muCtxguNJv8lFwLei27UASu2Nvg4ERSeN0R4K5tivk0=
+github.com/openimsdk/tools v0.0.50-alpha.60/go.mod h1:muCtxguNJv8lFwLei27UASu2Nvg4ERSeN0R4K5tivk0=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=

internal/api/auth.go

@@ -21,24 +21,26 @@ import (
 	"github.com/openimsdk/tools/a2r"
 )
 
-type AuthApi rpcclient.Auth
+type AuthApi struct {
+	Client auth.AuthClient
+}
 
-func NewAuthApi(client rpcclient.Auth) AuthApi {
+func NewAuthApi(client auth.AuthClient) AuthApi {
-	return AuthApi(client)
+	return AuthApi{client}
 }
 
 func (o *AuthApi) GetAdminToken(c *gin.Context) {
-	a2r.Call(auth.AuthClient.GetAdminToken, o.Client, c)
+	a2r.Call(c, auth.AuthClient.GetAdminToken, o.Client)
 }
 
 func (o *AuthApi) GetUserToken(c *gin.Context) {
-	a2r.Call(auth.AuthClient.GetUserToken, o.Client, c)
+	a2r.Call(c, auth.AuthClient.GetUserToken, o.Client)
 }
 
 func (o *AuthApi) ParseToken(c *gin.Context) {
-	a2r.Call(auth.AuthClient.ParseToken, o.Client, c)
+	a2r.Call(c, auth.AuthClient.ParseToken, o.Client)
 }
 
 func (o *AuthApi) ForceLogout(c *gin.Context) {
-	a2r.Call(auth.AuthClient.ForceLogout, o.Client, c)
+	a2r.Call(c, auth.AuthClient.ForceLogout, o.Client)
 }

internal/api/conversation.go

@@ -21,52 +21,54 @@ import (
 	"github.com/openimsdk/tools/a2r"
 )
 
-type ConversationApi rpcclient.Conversation
+type ConversationApi struct {
+	Client conversation.ConversationClient
+}
 
-func NewConversationApi(client rpcclient.Conversation) ConversationApi {
+func NewConversationApi(client conversation.ConversationClient) ConversationApi {
-	return ConversationApi(client)
+	return ConversationApi{client}
 }
 
 func (o *ConversationApi) GetAllConversations(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetAllConversations, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetAllConversations, o.Client)
 }
 
 func (o *ConversationApi) GetSortedConversationList(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetSortedConversationList, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetSortedConversationList, o.Client)
 }
 
 func (o *ConversationApi) GetConversation(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetConversation, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetConversation, o.Client)
 }
 
 func (o *ConversationApi) GetConversations(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetConversations, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetConversations, o.Client)
 }
 
 func (o *ConversationApi) SetConversations(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.SetConversations, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.SetConversations, o.Client)
 }
 
 func (o *ConversationApi) GetConversationOfflinePushUserIDs(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetConversationOfflinePushUserIDs, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetConversationOfflinePushUserIDs, o.Client)
 }
 
 func (o *ConversationApi) GetFullOwnerConversationIDs(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetFullOwnerConversationIDs, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetFullOwnerConversationIDs, o.Client)
 }
 
 func (o *ConversationApi) GetIncrementalConversation(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetIncrementalConversation, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetIncrementalConversation, o.Client)
 }
 
 func (o *ConversationApi) GetOwnerConversation(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetOwnerConversation, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetOwnerConversation, o.Client)
 }
 
 func (o *ConversationApi) GetNotNotifyConversationIDs(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetNotNotifyConversationIDs, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetNotNotifyConversationIDs, o.Client)
 }
 
 func (o *ConversationApi) GetPinnedConversationIDs(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetPinnedConversationIDs, o.Client, c)
+	a2r.Call(c, conversation.ConversationClient.GetPinnedConversationIDs, o.Client)
 }

internal/api/friend.go

@@ -22,94 +22,96 @@ import (
 	"github.com/openimsdk/tools/a2r"
 )
 
-type FriendApi rpcclient.Friend
+type FriendApi struct {
+	Client relation.FriendClient
+}
 
-func NewFriendApi(client rpcclient.Friend) FriendApi {
+func NewFriendApi(client relation.FriendClient) FriendApi {
-	return FriendApi(client)
+	return FriendApi{client}
 }
 
 func (o *FriendApi) ApplyToAddFriend(c *gin.Context) {
-	a2r.Call(relation.FriendClient.ApplyToAddFriend, o.Client, c)
+	a2r.Call(c, relation.FriendClient.ApplyToAddFriend, o.Client)
 }
 
 func (o *FriendApi) RespondFriendApply(c *gin.Context) {
-	a2r.Call(relation.FriendClient.RespondFriendApply, o.Client, c)
+	a2r.Call(c, relation.FriendClient.RespondFriendApply, o.Client)
 }
 
 func (o *FriendApi) DeleteFriend(c *gin.Context) {
-	a2r.Call(relation.FriendClient.DeleteFriend, o.Client, c)
+	a2r.Call(c, relation.FriendClient.DeleteFriend, o.Client)
 }
 
 func (o *FriendApi) GetFriendApplyList(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetPaginationFriendsApplyTo, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetPaginationFriendsApplyTo, o.Client)
 }
 
 func (o *FriendApi) GetDesignatedFriendsApply(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetDesignatedFriendsApply, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetDesignatedFriendsApply, o.Client)
 }
 
 func (o *FriendApi) GetSelfApplyList(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetPaginationFriendsApplyFrom, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetPaginationFriendsApplyFrom, o.Client)
 }
 
 func (o *FriendApi) GetFriendList(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetPaginationFriends, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetPaginationFriends, o.Client)
 }
 
 func (o *FriendApi) GetDesignatedFriends(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetDesignatedFriends, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetDesignatedFriends, o.Client)
 }
 
 func (o *FriendApi) SetFriendRemark(c *gin.Context) {
-	a2r.Call(relation.FriendClient.SetFriendRemark, o.Client, c)
+	a2r.Call(c, relation.FriendClient.SetFriendRemark, o.Client)
 }
 
 func (o *FriendApi) AddBlack(c *gin.Context) {
-	a2r.Call(relation.FriendClient.AddBlack, o.Client, c)
+	a2r.Call(c, relation.FriendClient.AddBlack, o.Client)
 }
 
 func (o *FriendApi) GetPaginationBlacks(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetPaginationBlacks, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetPaginationBlacks, o.Client)
 }
 
 func (o *FriendApi) GetSpecifiedBlacks(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetSpecifiedBlacks, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetSpecifiedBlacks, o.Client)
 }
 
 func (o *FriendApi) RemoveBlack(c *gin.Context) {
-	a2r.Call(relation.FriendClient.RemoveBlack, o.Client, c)
+	a2r.Call(c, relation.FriendClient.RemoveBlack, o.Client)
 }
 
 func (o *FriendApi) ImportFriends(c *gin.Context) {
-	a2r.Call(relation.FriendClient.ImportFriends, o.Client, c)
+	a2r.Call(c, relation.FriendClient.ImportFriends, o.Client)
 }
 
 func (o *FriendApi) IsFriend(c *gin.Context) {
-	a2r.Call(relation.FriendClient.IsFriend, o.Client, c)
+	a2r.Call(c, relation.FriendClient.IsFriend, o.Client)
 }
 
 func (o *FriendApi) GetFriendIDs(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetFriendIDs, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetFriendIDs, o.Client)
 }
 
 func (o *FriendApi) GetSpecifiedFriendsInfo(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetSpecifiedFriendsInfo, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetSpecifiedFriendsInfo, o.Client)
 }
 
 func (o *FriendApi) UpdateFriends(c *gin.Context) {
-	a2r.Call(relation.FriendClient.UpdateFriends, o.Client, c)
+	a2r.Call(c, relation.FriendClient.UpdateFriends, o.Client)
 }
 
 func (o *FriendApi) GetIncrementalFriends(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetIncrementalFriends, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetIncrementalFriends, o.Client)
 }
 
 // GetIncrementalBlacks is temporarily unused.
 // Deprecated: This function is currently unused and may be removed in future versions.
 func (o *FriendApi) GetIncrementalBlacks(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetIncrementalBlacks, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetIncrementalBlacks, o.Client)
 }
 
 func (o *FriendApi) GetFullFriendUserIDs(c *gin.Context) {
-	a2r.Call(relation.FriendClient.GetFullFriendUserIDs, o.Client, c)
+	a2r.Call(c, relation.FriendClient.GetFullFriendUserIDs, o.Client)
 }

internal/api/group.go

@@ -21,146 +21,148 @@ import (
 	"github.com/openimsdk/tools/a2r"
 )
 
-type GroupApi rpcclient.Group
+type GroupApi struct {
+	Client group.GroupClient
+}
 
-func NewGroupApi(client rpcclient.Group) GroupApi {
+func NewGroupApi(client group.GroupClient) GroupApi {
-	return GroupApi(client)
+	return GroupApi{client}
 }
 
 func (o *GroupApi) CreateGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.CreateGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.CreateGroup, o.Client)
 }
 
 func (o *GroupApi) SetGroupInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.SetGroupInfo, o.Client, c)
+	a2r.Call(c, group.GroupClient.SetGroupInfo, o.Client)
 }
 
 func (o *GroupApi) SetGroupInfoEx(c *gin.Context) {
-	a2r.Call(group.GroupClient.SetGroupInfoEx, o.Client, c)
+	a2r.Call(c, group.GroupClient.SetGroupInfoEx, o.Client)
 }
 
 func (o *GroupApi) JoinGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.JoinGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.JoinGroup, o.Client)
 }
 
 func (o *GroupApi) QuitGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.QuitGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.QuitGroup, o.Client)
 }
 
 func (o *GroupApi) ApplicationGroupResponse(c *gin.Context) {
-	a2r.Call(group.GroupClient.GroupApplicationResponse, o.Client, c)
+	a2r.Call(c, group.GroupClient.GroupApplicationResponse, o.Client)
 }
 
 func (o *GroupApi) TransferGroupOwner(c *gin.Context) {
-	a2r.Call(group.GroupClient.TransferGroupOwner, o.Client, c)
+	a2r.Call(c, group.GroupClient.TransferGroupOwner, o.Client)
 }
 
 func (o *GroupApi) GetRecvGroupApplicationList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupApplicationList, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroupApplicationList, o.Client)
 }
 
 func (o *GroupApi) GetUserReqGroupApplicationList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetUserReqApplicationList, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetUserReqApplicationList, o.Client)
 }
 
 func (o *GroupApi) GetGroupUsersReqApplicationList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupUsersReqApplicationList, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroupUsersReqApplicationList, o.Client)
 }
 
 func (o *GroupApi) GetSpecifiedUserGroupRequestInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetSpecifiedUserGroupRequestInfo, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetSpecifiedUserGroupRequestInfo, o.Client)
 }
 
 func (o *GroupApi) GetGroupsInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupsInfo, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroupsInfo, o.Client)
-	//a2r.Call(group.GroupClient.GetGroupsInfo, o.Client, c, a2r.NewNilReplaceOption(group.GroupClient.GetGroupsInfo))
+	//a2r.Call(c, group.GroupClient.GetGroupsInfo, o.Client, c, a2r.NewNilReplaceOption(group.GroupClient.GetGroupsInfo))
 }
 
 func (o *GroupApi) KickGroupMember(c *gin.Context) {
-	a2r.Call(group.GroupClient.KickGroupMember, o.Client, c)
+	a2r.Call(c, group.GroupClient.KickGroupMember, o.Client)
 }
 
 func (o *GroupApi) GetGroupMembersInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupMembersInfo, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroupMembersInfo, o.Client)
-	//a2r.Call(group.GroupClient.GetGroupMembersInfo, o.Client, c, a2r.NewNilReplaceOption(group.GroupClient.GetGroupMembersInfo))
+	//a2r.Call(c, group.GroupClient.GetGroupMembersInfo, o.Client, c, a2r.NewNilReplaceOption(group.GroupClient.GetGroupMembersInfo))
 }
 
 func (o *GroupApi) GetGroupMemberList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupMemberList, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroupMemberList, o.Client)
 }
 
 func (o *GroupApi) InviteUserToGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.InviteUserToGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.InviteUserToGroup, o.Client)
 }
 
 func (o *GroupApi) GetJoinedGroupList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetJoinedGroupList, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetJoinedGroupList, o.Client)
 }
 
 func (o *GroupApi) DismissGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.DismissGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.DismissGroup, o.Client)
 }
 
 func (o *GroupApi) MuteGroupMember(c *gin.Context) {
-	a2r.Call(group.GroupClient.MuteGroupMember, o.Client, c)
+	a2r.Call(c, group.GroupClient.MuteGroupMember, o.Client)
 }
 
 func (o *GroupApi) CancelMuteGroupMember(c *gin.Context) {
-	a2r.Call(group.GroupClient.CancelMuteGroupMember, o.Client, c)
+	a2r.Call(c, group.GroupClient.CancelMuteGroupMember, o.Client)
 }
 
 func (o *GroupApi) MuteGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.MuteGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.MuteGroup, o.Client)
 }
 
 func (o *GroupApi) CancelMuteGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.CancelMuteGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.CancelMuteGroup, o.Client)
 }
 
 func (o *GroupApi) SetGroupMemberInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.SetGroupMemberInfo, o.Client, c)
+	a2r.Call(c, group.GroupClient.SetGroupMemberInfo, o.Client)
 }
 
 func (o *GroupApi) GetGroupAbstractInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupAbstractInfo, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroupAbstractInfo, o.Client)
 }
 
 // func (g *Group) SetGroupMemberNickname(c *gin.Context) {
-//	a2r.Call(group.GroupClient.SetGroupMemberNickname, g.userClient, c)
+//	a2r.Call(c, group.GroupClient.SetGroupMemberNickname, g.userClient)
 //}
 //
 // func (g *Group) GetGroupAllMemberList(c *gin.Context) {
-//	a2r.Call(group.GroupClient.GetGroupAllMember, g.userClient, c)
+//	a2r.Call(c, group.GroupClient.GetGroupAllMember, g.userClient)
 //}
 
 func (o *GroupApi) GroupCreateCount(c *gin.Context) {
-	a2r.Call(group.GroupClient.GroupCreateCount, o.Client, c)
+	a2r.Call(c, group.GroupClient.GroupCreateCount, o.Client)
 }
 
 func (o *GroupApi) GetGroups(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroups, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroups, o.Client)
 }
 
 func (o *GroupApi) GetGroupMemberUserIDs(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupMemberUserIDs, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetGroupMemberUserIDs, o.Client)
 }
 
 func (o *GroupApi) GetIncrementalJoinGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetIncrementalJoinGroup, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetIncrementalJoinGroup, o.Client)
 }
 
 func (o *GroupApi) GetIncrementalGroupMember(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetIncrementalGroupMember, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetIncrementalGroupMember, o.Client)
 }
 
 func (o *GroupApi) GetIncrementalGroupMemberBatch(c *gin.Context) {
-	a2r.Call(group.GroupClient.BatchGetIncrementalGroupMember, o.Client, c)
+	a2r.Call(c, group.GroupClient.BatchGetIncrementalGroupMember, o.Client)
 }
 
 func (o *GroupApi) GetFullGroupMemberUserIDs(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetFullGroupMemberUserIDs, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetFullGroupMemberUserIDs, o.Client)
 }
 
 func (o *GroupApi) GetFullJoinGroupIDs(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetFullJoinGroupIDs, o.Client, c)
+	a2r.Call(c, group.GroupClient.GetFullJoinGroupIDs, o.Client)
 }

internal/api/init.go

@@ -30,7 +30,7 @@ import (
 
 	kdisc "github.com/openimsdk/open-im-server/v3/pkg/common/discoveryregister"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
-	"github.com/openimsdk/tools/discovery"
+	"github.com/openimsdk/tools/discovery/etcd"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/system/program"
@@ -55,6 +55,7 @@ func Start(ctx context.Context, index int, config *Config) error {
 	if err != nil {
 		return errs.WrapMsg(err, "failed to register discovery service")
 	}
+	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
 
 	var (
 		netDone        = make(chan struct{}, 1)
@@ -62,7 +63,30 @@ func Start(ctx context.Context, index int, config *Config) error {
 		prometheusPort int
 	)
 
-	router := newGinRouter(client, config)
+	registerIP, err := network.GetRpcRegisterIP("")
+	if err != nil {
+		return err
+	}
+
+	getAutoPort := func() (net.Listener, int, error) {
+		registerAddr := net.JoinHostPort(registerIP, "0")
+		listener, err := net.Listen("tcp", registerAddr)
+		if err != nil {
+			return nil, 0, errs.WrapMsg(err, "listen err", "registerAddr", registerAddr)
+		}
+		_, portStr, _ := net.SplitHostPort(listener.Addr().String())
+		port, _ := strconv.Atoi(portStr)
+		return listener, port, nil
+	}
+
+	if config.API.Prometheus.AutoSetPorts && config.Discovery.Enable != conf.ETCD {
+		return errs.New("only etcd support autoSetPorts", "RegisterName", "api").Wrap()
+	}
+
+	router, err := newGinRouter(ctx, client, config)
+	if err != nil {
+		return err
+	}
 	if config.API.Prometheus.Enable {
 		go func() {
 			prometheusPort, err = datautil.GetElemByIndex(config.API.Prometheus.Ports, index)

internal/api/jssdk/jssdk.go

@@ -2,14 +2,15 @@ package jssdk
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"sort"
+
 	"github.com/gin-gonic/gin"
 	"github.com/openimsdk/protocol/conversation"
-	"github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/jssdk"
 	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/protocol/sdkws"
-	"github.com/openimsdk/protocol/user"
 	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/datautil"
 	"sort"
@@ -31,11 +32,11 @@ func NewJSSdkApi(user user.UserClient, friend relation.FriendClient, group group
 }
 
 type JSSdk struct {
-	user   user.UserClient
+	userClient         rpcli.UserClient
-	friend relation.FriendClient
+	relationClient     rpcli.RelationClient
-	group  group.GroupClient
+	groupClient        rpcli.GroupClient
-	msg    msg.MsgClient
+	conversationClient rpcli.ConversationClient
-	conv   conversation.ConversationClient
+	msgClient          rpcli.MsgClient
 }
 
 func (x *JSSdk) GetActiveConversations(c *gin.Context) {
@@ -67,11 +68,11 @@ func (x *JSSdk) fillConversations(ctx context.Context, conversations []*jssdk.Co
 		groupMap  map[string]*sdkws.GroupInfo
 	)
 	if len(userIDs) > 0 {
-		users, err := field(ctx, x.user.GetDesignateUsers, &user.GetDesignateUsersReq{UserIDs: userIDs}, (*user.GetDesignateUsersResp).GetUsersInfo)
+		users, err := x.userClient.GetUsersInfo(ctx, userIDs)
 		if err != nil {
 			return err
 		}
-		friends, err := field(ctx, x.friend.GetFriendInfo, &relation.GetFriendInfoReq{OwnerUserID: conversations[0].Conversation.OwnerUserID, FriendUserIDs: userIDs}, (*relation.GetFriendInfoResp).GetFriendInfos)
+		friends, err := x.relationClient.GetFriendsInfo(ctx, conversations[0].Conversation.OwnerUserID, userIDs)
 		if err != nil {
 			return err
 		}
@@ -79,11 +80,11 @@ func (x *JSSdk) fillConversations(ctx context.Context, conversations []*jssdk.Co
 		friendMap = datautil.SliceToMap(friends, (*relation.FriendInfoOnly).GetFriendUserID)
 	}
 	if len(groupIDs) > 0 {
-		resp, err := x.group.GetGroupsInfo(ctx, &group.GetGroupsInfoReq{GroupIDs: groupIDs})
+		groups, err := x.groupClient.GetGroupsInfo(ctx, groupIDs)
 		if err != nil {
 			return err
 		}
-		groupMap = datautil.SliceToMap(resp.GroupInfos, (*sdkws.GroupInfo).GetGroupID)
+		groupMap = datautil.SliceToMap(groups, (*sdkws.GroupInfo).GetGroupID)
 	}
 	for _, c := range conversations {
 		if c.Conversation.GroupID == "" {
@@ -101,21 +102,18 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 		req.Count = defaultGetActiveConversation
 	}
 	req.OwnerUserID = mcontext.GetOpUserID(ctx)
-	conversationIDs, err := field(ctx, x.conv.GetConversationIDs,
+	conversationIDs, err := x.conversationClient.GetConversationIDs(ctx, req.OwnerUserID)
-		&conversation.GetConversationIDsReq{UserID: req.OwnerUserID}, (*conversation.GetConversationIDsResp).GetConversationIDs)
 	if err != nil {
 		return nil, err
 	}
 	if len(conversationIDs) == 0 {
 		return &jssdk.GetActiveConversationsResp{}, nil
 	}
-	readSeq, err := field(ctx, x.msg.GetHasReadSeqs,
+	readSeq, err := x.msgClient.GetHasReadSeqs(ctx, conversationIDs, req.OwnerUserID)
-		&msg.GetHasReadSeqsReq{UserID: req.OwnerUserID, ConversationIDs: conversationIDs}, (*msg.SeqsInfoResp).GetMaxSeqs)
 	if err != nil {
 		return nil, err
 	}
-	activeConversation, err := field(ctx, x.msg.GetActiveConversation,
+	activeConversation, err := x.msgClient.GetActiveConversation(ctx, conversationIDs)
-		&msg.GetActiveConversationReq{ConversationIDs: conversationIDs}, (*msg.GetActiveConversationResp).GetConversations)
 	if err != nil {
 		return nil, err
 	}
@@ -126,8 +124,7 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 		Conversation: activeConversation,
 	}
 	if len(activeConversation) > 1 {
-		pinnedConversationIDs, err := field(ctx, x.conv.GetPinnedConversationIDs,
+		pinnedConversationIDs, err := x.conversationClient.GetPinnedConversationIDs(ctx, req.OwnerUserID)
-			&conversation.GetPinnedConversationIDsReq{UserID: req.OwnerUserID}, (*conversation.GetPinnedConversationIDsResp).GetConversationIDs)
 		if err != nil {
 			return nil, err
 		}
@@ -135,25 +132,18 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 	}
 	sort.Sort(&sortConversations)
 	sortList := sortConversations.Top(int(req.Count))
-	conversations, err := field(ctx, x.conv.GetConversations,
+	conversations, err := x.conversationClient.GetConversations(ctx, datautil.Slice(sortList, func(c *msg.ActiveConversation) string {
-		&conversation.GetConversationsReq{
+		return c.ConversationID
-			OwnerUserID: req.OwnerUserID,
+	}), req.OwnerUserID)
-			ConversationIDs: datautil.Slice(sortList, func(c *msg.ActiveConversation) string {
-				return c.ConversationID
-			})}, (*conversation.GetConversationsResp).GetConversations)
 	if err != nil {
 		return nil, err
 	}
-	msgs, err := field(ctx, x.msg.GetSeqMessage,
+	msgs, err := x.msgClient.GetSeqMessage(ctx, req.OwnerUserID, datautil.Slice(sortList, func(c *msg.ActiveConversation) *msg.ConversationSeqs {
-		&msg.GetSeqMessageReq{
+		return &msg.ConversationSeqs{
-			UserID: req.OwnerUserID,
+			ConversationID: c.ConversationID,
-			Conversations: datautil.Slice(sortList, func(c *msg.ActiveConversation) *msg.ConversationSeqs {
+			Seqs:           []int64{c.MaxSeq},
-				return &msg.ConversationSeqs{
+		}
-					ConversationID: c.ConversationID,
+	}))
-					Seqs:           []int64{c.MaxSeq},
-				}
-			}),
-		}, (*msg.GetSeqMessageResp).GetMsgs)
 	if err != nil {
 		return nil, err
 	}
@@ -195,7 +185,7 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 
 func (x *JSSdk) getConversations(ctx context.Context, req *jssdk.GetConversationsReq) (*jssdk.GetConversationsResp, error) {
 	req.OwnerUserID = mcontext.GetOpUserID(ctx)
-	conversations, err := field(ctx, x.conv.GetConversations, &conversation.GetConversationsReq{OwnerUserID: req.OwnerUserID, ConversationIDs: req.ConversationIDs}, (*conversation.GetConversationsResp).GetConversations)
+	conversations, err := x.conversationClient.GetConversations(ctx, req.ConversationIDs, req.OwnerUserID)
 	if err != nil {
 		return nil, err
 	}
@@ -205,13 +195,11 @@ func (x *JSSdk) getConversations(ctx context.Context, req *jssdk.GetConversation
 	req.ConversationIDs = datautil.Slice(conversations, func(c *conversation.Conversation) string {
 		return c.ConversationID
 	})
-	maxSeqs, err := field(ctx, x.msg.GetMaxSeqs,
+	maxSeqs, err := x.msgClient.GetMaxSeqs(ctx, req.ConversationIDs)
-		&msg.GetMaxSeqsReq{ConversationIDs: req.ConversationIDs}, (*msg.SeqsInfoResp).GetMaxSeqs)
 	if err != nil {
 		return nil, err
 	}
-	readSeqs, err := field(ctx, x.msg.GetHasReadSeqs,
+	readSeqs, err := x.msgClient.GetHasReadSeqs(ctx, req.ConversationIDs, req.OwnerUserID)
-		&msg.GetHasReadSeqsReq{UserID: req.OwnerUserID, ConversationIDs: req.ConversationIDs}, (*msg.SeqsInfoResp).GetMaxSeqs)
 	if err != nil {
 		return nil, err
 	}
@@ -226,8 +214,7 @@ func (x *JSSdk) getConversations(ctx context.Context, req *jssdk.GetConversation
 	}
 	var msgs map[string]*sdkws.PullMsgs
 	if len(conversationSeqs) > 0 {
-		msgs, err = field(ctx, x.msg.GetSeqMessage,
+		msgs, err = x.msgClient.GetSeqMessage(ctx, req.OwnerUserID, conversationSeqs)
-			&msg.GetSeqMessageReq{UserID: req.OwnerUserID, Conversations: conversationSeqs}, (*msg.GetSeqMessageResp).GetMsgs)
 		if err != nil {
 			return nil, err
 		}

internal/api/msg.go

@@ -21,7 +21,7 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/apistruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/sdkws"
@@ -37,16 +37,14 @@ import (
 )
 
 type MessageApi struct {
-	*rpcclient.Message
+	Client        msg.MsgClient
-	validate      *validator.Validate
+	userClient    *rpcli.UserClient
-	userRpcClient *rpcclient.UserRpcClient
 	imAdminUserID []string
+	validate      *validator.Validate
 }
 
-func NewMessageApi(msgRpcClient *rpcclient.Message, userRpcClient *rpcclient.User,
+func NewMessageApi(client msg.MsgClient, userClient *rpcli.UserClient, imAdminUserID []string) MessageApi {
-	imAdminUserID []string) MessageApi {
+	return MessageApi{Client: client, userClient: userClient, imAdminUserID: imAdminUserID, validate: validator.New()}
-	return MessageApi{Message: msgRpcClient, validate: validator.New(),
-		userRpcClient: rpcclient.NewUserRpcClientByUser(userRpcClient), imAdminUserID: imAdminUserID}
 }
 
 func (*MessageApi) SetOptions(options map[string]bool, value bool) {
@@ -108,51 +106,51 @@ func (m *MessageApi) newUserSendMsgReq(_ *gin.Context, params *apistruct.SendMsg
 }
 
 func (m *MessageApi) GetSeq(c *gin.Context) {
-	a2r.Call(msg.MsgClient.GetMaxSeq, m.Client, c)
+	a2r.Call(c, msg.MsgClient.GetMaxSeq, m.Client)
 }
 
 func (m *MessageApi) PullMsgBySeqs(c *gin.Context) {
-	a2r.Call(msg.MsgClient.PullMessageBySeqs, m.Client, c)
+	a2r.Call(c, msg.MsgClient.PullMessageBySeqs, m.Client)
 }
 
 func (m *MessageApi) RevokeMsg(c *gin.Context) {
-	a2r.Call(msg.MsgClient.RevokeMsg, m.Client, c)
+	a2r.Call(c, msg.MsgClient.RevokeMsg, m.Client)
 }
 
 func (m *MessageApi) MarkMsgsAsRead(c *gin.Context) {
-	a2r.Call(msg.MsgClient.MarkMsgsAsRead, m.Client, c)
+	a2r.Call(c, msg.MsgClient.MarkMsgsAsRead, m.Client)
 }
 
 func (m *MessageApi) MarkConversationAsRead(c *gin.Context) {
-	a2r.Call(msg.MsgClient.MarkConversationAsRead, m.Client, c)
+	a2r.Call(c, msg.MsgClient.MarkConversationAsRead, m.Client)
 }
 
 func (m *MessageApi) GetConversationsHasReadAndMaxSeq(c *gin.Context) {
-	a2r.Call(msg.MsgClient.GetConversationsHasReadAndMaxSeq, m.Client, c)
+	a2r.Call(c, msg.MsgClient.GetConversationsHasReadAndMaxSeq, m.Client)
 }
 
 func (m *MessageApi) SetConversationHasReadSeq(c *gin.Context) {
-	a2r.Call(msg.MsgClient.SetConversationHasReadSeq, m.Client, c)
+	a2r.Call(c, msg.MsgClient.SetConversationHasReadSeq, m.Client)
 }
 
 func (m *MessageApi) ClearConversationsMsg(c *gin.Context) {
-	a2r.Call(msg.MsgClient.ClearConversationsMsg, m.Client, c)
+	a2r.Call(c, msg.MsgClient.ClearConversationsMsg, m.Client)
 }
 
 func (m *MessageApi) UserClearAllMsg(c *gin.Context) {
-	a2r.Call(msg.MsgClient.UserClearAllMsg, m.Client, c)
+	a2r.Call(c, msg.MsgClient.UserClearAllMsg, m.Client)
 }
 
 func (m *MessageApi) DeleteMsgs(c *gin.Context) {
-	a2r.Call(msg.MsgClient.DeleteMsgs, m.Client, c)
+	a2r.Call(c, msg.MsgClient.DeleteMsgs, m.Client)
 }
 
 func (m *MessageApi) DeleteMsgPhysicalBySeq(c *gin.Context) {
-	a2r.Call(msg.MsgClient.DeleteMsgPhysicalBySeq, m.Client, c)
+	a2r.Call(c, msg.MsgClient.DeleteMsgPhysicalBySeq, m.Client)
 }
 
 func (m *MessageApi) DeleteMsgPhysical(c *gin.Context) {
-	a2r.Call(msg.MsgClient.DeleteMsgPhysical, m.Client, c)
+	a2r.Call(c, msg.MsgClient.DeleteMsgPhysical, m.Client)
 }
 
 func (m *MessageApi) getSendMsgReq(c *gin.Context, req apistruct.SendMsg) (sendMsgReq *msg.SendMsgReq, err error) {
@@ -176,7 +174,7 @@ func (m *MessageApi) getSendMsgReq(c *gin.Context, req apistruct.SendMsg) (sendM
 	case constant.OANotification:
 		data = apistruct.OANotificationElem{}
 		req.SessionType = constant.NotificationChatType
-		if err = m.userRpcClient.GetNotificationByID(c, req.SendID); err != nil {
+		if err = m.userClient.GetNotificationByID(c, req.SendID); err != nil {
 			return nil, err
 		}
 	default:
@@ -310,10 +308,10 @@ func (m *MessageApi) BatchSendMsg(c *gin.Context) {
 
 	var recvIDs []string
 	if req.IsSendAll {
-		pageNumber := 1
+		var pageNumber int32 = 1
-		showNumber := 500
+		const showNumber = 500
 		for {
-			recvIDsPart, err := m.userRpcClient.GetAllUserIDs(c, int32(pageNumber), int32(showNumber))
+			recvIDsPart, err := m.userClient.GetAllUserIDs(c, pageNumber, showNumber)
 			if err != nil {
 				apiresp.GinError(c, err)
 				return
@@ -351,25 +349,33 @@ func (m *MessageApi) BatchSendMsg(c *gin.Context) {
 }
 
 func (m *MessageApi) CheckMsgIsSendSuccess(c *gin.Context) {
-	a2r.Call(msg.MsgClient.GetSendMsgStatus, m.Client, c)
+	a2r.Call(c, msg.MsgClient.GetSendMsgStatus, m.Client)
 }
 
 func (m *MessageApi) GetUsersOnlineStatus(c *gin.Context) {
-	a2r.Call(msg.MsgClient.GetSendMsgStatus, m.Client, c)
+	a2r.Call(c, msg.MsgClient.GetSendMsgStatus, m.Client)
 }
 
 func (m *MessageApi) GetActiveUser(c *gin.Context) {
-	a2r.Call(msg.MsgClient.GetActiveUser, m.Client, c)
+	a2r.Call(c, msg.MsgClient.GetActiveUser, m.Client)
 }
 
 func (m *MessageApi) GetActiveGroup(c *gin.Context) {
-	a2r.Call(msg.MsgClient.GetActiveGroup, m.Client, c)
+	a2r.Call(c, msg.MsgClient.GetActiveGroup, m.Client)
 }
 
 func (m *MessageApi) SearchMsg(c *gin.Context) {
-	a2r.Call(msg.MsgClient.SearchMessage, m.Client, c)
+	a2r.Call(c, msg.MsgClient.SearchMessage, m.Client)
 }
 
 func (m *MessageApi) GetServerTime(c *gin.Context) {
-	a2r.Call(msg.MsgClient.GetServerTime, m.Client, c)
+	a2r.Call(c, msg.MsgClient.GetServerTime, m.Client)
+}
+
+func (m *MessageApi) GetStreamMsg(c *gin.Context) {
+	a2r.Call(c, msg.MsgClient.GetServerTime, m.Client)
+}
+
+func (m *MessageApi) AppendStreamMsg(c *gin.Context) {
+	a2r.Call(c, msg.MsgClient.GetServerTime, m.Client)
 }

internal/api/router.go

@@ -1,7 +1,17 @@
 package api
 
 import (
+	"context"
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/protocol/conversation"
+	"github.com/openimsdk/protocol/group"
+	"github.com/openimsdk/protocol/msg"
+	"github.com/openimsdk/protocol/relation"
+	"github.com/openimsdk/protocol/third"
+	"github.com/openimsdk/protocol/user"
+	"net/http"
+	"strings"
 
 	"github.com/openimsdk/open-im-server/v3/internal/api/jssdk"
 
@@ -48,9 +58,37 @@ func prommetricsGin() gin.HandlerFunc {
 	}
 }
 
-func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.Engine {
+func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, config *Config) (*gin.Engine, error) {
-	disCov.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()),
+	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()),
 		grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
+	authConn, err := client.GetConn(ctx, config.Discovery.RpcService.Auth)
+	if err != nil {
+		return nil, err
+	}
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
+	if err != nil {
+		return nil, err
+	}
+	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
+	if err != nil {
+		return nil, err
+	}
+	friendConn, err := client.GetConn(ctx, config.Discovery.RpcService.Friend)
+	if err != nil {
+		return nil, err
+	}
+	conversationConn, err := client.GetConn(ctx, config.Discovery.RpcService.Conversation)
+	if err != nil {
+		return nil, err
+	}
+	thirdConn, err := client.GetConn(ctx, config.Discovery.RpcService.Third)
+	if err != nil {
+		return nil, err
+	}
+	msgConn, err := client.GetConn(ctx, config.Discovery.RpcService.Msg)
+	if err != nil {
+		return nil, err
+	}
 	gin.SetMode(gin.ReleaseMode)
 	r := gin.New()
 	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
@@ -74,12 +112,12 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 	case BestSpeed:
 		r.Use(gzip.Gzip(gzip.BestSpeed))
 	}
-	r.Use(prommetricsGin(), gin.RecoveryWithWriter(gin.DefaultErrorWriter, mw.GinPanicErr), mw.CorsHandler(), mw.GinParseOperationID(), GinParseToken(authRpc))
+	r.Use(prommetricsGin(), gin.RecoveryWithWriter(gin.DefaultErrorWriter, mw.GinPanicErr), mw.CorsHandler(), mw.GinParseOperationID(), GinParseToken(rpcli.NewAuthClient(authConn)))
-	u := NewUserApi(*userRpc)
+	j := jssdk.NewJSSdkApi()
-	m := NewMessageApi(messageRpc, userRpc, config.Share.IMAdminUserID)
+
-	j := jssdk.NewJSSdkApi(userRpc.Client, friendRpc.Client, groupRpc.Client, messageRpc.Client, conversationRpc.Client)
+	u := NewUserApi(user.NewUserClient(userConn), client, config.Discovery.RpcService)
-	userRouterGroup := r.Group("/user")
 	{
+		userRouterGroup := r.Group("/user")
 		userRouterGroup.POST("/user_register", u.UserRegister)
 		userRouterGroup.POST("/update_user_info", u.UpdateUserInfo)
 		userRouterGroup.POST("/update_user_info_ex", u.UpdateUserInfoEx)
@@ -105,9 +143,9 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		userRouterGroup.POST("/search_notification_account", u.SearchNotificationAccount)
 	}
 	// friend routing group
-	friendRouterGroup := r.Group("/friend")
 	{
-		f := NewFriendApi(*friendRpc)
+		f := NewFriendApi(relation.NewFriendClient(friendConn))
+		friendRouterGroup := r.Group("/friend")
 		friendRouterGroup.POST("/delete_friend", f.DeleteFriend)
 		friendRouterGroup.POST("/get_friend_apply_list", f.GetFriendApplyList)
 		friendRouterGroup.POST("/get_designated_friend_apply", f.GetDesignatedFriendsApply)
@@ -130,9 +168,10 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		friendRouterGroup.POST("/get_incremental_friends", f.GetIncrementalFriends)
 		friendRouterGroup.POST("/get_full_friend_user_ids", f.GetFullFriendUserIDs)
 	}
-	g := NewGroupApi(*groupRpc)
+
-	groupRouterGroup := r.Group("/group")
+	g := NewGroupApi(group.NewGroupClient(groupConn))
 	{
+		groupRouterGroup := r.Group("/group")
 		groupRouterGroup.POST("/create_group", g.CreateGroup)
 		groupRouterGroup.POST("/set_group_info", g.SetGroupInfo)
 		groupRouterGroup.POST("/set_group_info_ex", g.SetGroupInfoEx)
@@ -166,9 +205,9 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		groupRouterGroup.POST("/get_full_join_group_ids", g.GetFullJoinGroupIDs)
 	}
 	// certificate
-	authRouterGroup := r.Group("/auth")
 	{
-		a := NewAuthApi(*authRpc)
+		a := NewAuthApi(pbAuth.NewAuthClient(authConn))
+		authRouterGroup := r.Group("/auth")
 		authRouterGroup.POST("/get_admin_token", a.GetAdminToken)
 		authRouterGroup.POST("/get_user_token", a.GetUserToken)
 		authRouterGroup.POST("/parse_token", a.ParseToken)
@@ -176,9 +215,9 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 
 	}
 	// Third service
-	thirdGroup := r.Group("/third")
 	{
-		t := NewThirdApi(*thirdRpc)
+		t := NewThirdApi(third.NewThirdClient(thirdConn), config.API.Prometheus.GrafanaURL)
+		thirdGroup := r.Group("/third")
 		thirdGroup.GET("/prometheus", t.GetPrometheus)
 		thirdGroup.POST("/fcm_update_token", t.FcmUpdateToken)
 		thirdGroup.POST("/set_app_badge", t.SetAppBadge)
@@ -201,8 +240,9 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		objectGroup.GET("/*name", t.ObjectRedirect)
 	}
 	// Message
-	msgGroup := r.Group("/msg")
+	m := NewMessageApi(msg.NewMsgClient(msgConn), rpcli.NewUserClient(userConn), config.Share.IMAdminUserID)
 	{
+		msgGroup := r.Group("/msg")
 		msgGroup.POST("/newest_seq", m.GetSeq)
 		msgGroup.POST("/search_msg", m.SearchMsg)
 		msgGroup.POST("/send_msg", m.SendMessage)
@@ -225,9 +265,9 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		msgGroup.POST("/get_server_time", m.GetServerTime)
 	}
 	// Conversation
-	conversationGroup := r.Group("/conversation")
 	{
-		c := NewConversationApi(*conversationRpc)
+		c := NewConversationApi(conversation.NewConversationClient(conversationConn))
+		conversationGroup := r.Group("/conversation")
 		conversationGroup.POST("/get_sorted_conversation_list", c.GetSortedConversationList)
 		conversationGroup.POST("/get_all_conversations", c.GetAllConversations)
 		conversationGroup.POST("/get_conversation", c.GetConversation)
@@ -241,22 +281,39 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		conversationGroup.POST("/get_pinned_conversation_ids", c.GetPinnedConversationIDs)
 	}
 
-	statisticsGroup := r.Group("/statistics")
 	{
+		statisticsGroup := r.Group("/statistics")
 		statisticsGroup.POST("/user/register", u.UserRegisterCount)
 		statisticsGroup.POST("/user/active", m.GetActiveUser)
 		statisticsGroup.POST("/group/create", g.GroupCreateCount)
 		statisticsGroup.POST("/group/active", m.GetActiveGroup)
 	}
 
-	jssdk := r.Group("/jssdk")
+	{
-	jssdk.POST("/get_conversations", j.GetConversations)
+		jssdk := r.Group("/jssdk")
-	jssdk.POST("/get_active_conversations", j.GetActiveConversations)
+		jssdk.POST("/get_conversations", j.GetConversations)
+		jssdk.POST("/get_active_conversations", j.GetActiveConversations)
+	}
+	{
+		pd := NewPrometheusDiscoveryApi(config, client)
+		proDiscoveryGroup := r.Group("/prometheus_discovery", pd.Enable)
+		proDiscoveryGroup.GET("/api", pd.Api)
+		proDiscoveryGroup.GET("/user", pd.User)
+		proDiscoveryGroup.GET("/group", pd.Group)
+		proDiscoveryGroup.GET("/msg", pd.Msg)
+		proDiscoveryGroup.GET("/friend", pd.Friend)
+		proDiscoveryGroup.GET("/conversation", pd.Conversation)
+		proDiscoveryGroup.GET("/third", pd.Third)
+		proDiscoveryGroup.GET("/auth", pd.Auth)
+		proDiscoveryGroup.GET("/push", pd.Push)
+		proDiscoveryGroup.GET("/msg_gateway", pd.MessageGateway)
+		proDiscoveryGroup.GET("/msg_transfer", pd.MessageTransfer)
+	}
 
-	return r
+	return r, nil
 }
 
-func GinParseToken(authRPC *rpcclient.Auth) gin.HandlerFunc {
+func GinParseToken(authClient *rpcli.AuthClient) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		switch c.Request.Method {
 		case http.MethodPost:
@@ -274,7 +331,7 @@ func GinParseToken(authRPC *rpcclient.Auth) gin.HandlerFunc {
 				c.Abort()
 				return
 			}
-			resp, err := authRPC.ParseToken(c, token)
+			resp, err := authClient.ParseToken(c, token)
 			if err != nil {
 				apiresp.GinError(c, err)
 				c.Abort()

internal/api/third.go

@@ -31,18 +31,21 @@ import (
 	"github.com/openimsdk/tools/mcontext"
 )
 
-type ThirdApi rpcclient.Third
+type ThirdApi struct {
+	GrafanaUrl string
+	Client     third.ThirdClient
+}
 
-func NewThirdApi(client rpcclient.Third) ThirdApi {
+func NewThirdApi(client third.ThirdClient, grafanaUrl string) ThirdApi {
-	return ThirdApi(client)
+	return ThirdApi{Client: client, GrafanaUrl: grafanaUrl}
 }
 
 func (o *ThirdApi) FcmUpdateToken(c *gin.Context) {
-	a2r.Call(third.ThirdClient.FcmUpdateToken, o.Client, c)
+	a2r.Call(c, third.ThirdClient.FcmUpdateToken, o.Client)
 }
 
 func (o *ThirdApi) SetAppBadge(c *gin.Context) {
-	a2r.Call(third.ThirdClient.SetAppBadge, o.Client, c)
+	a2r.Call(c, third.ThirdClient.SetAppBadge, o.Client)
 }
 
 // #################### s3 ####################
@@ -77,44 +80,44 @@ func setURLPrefix(c *gin.Context, urlPrefix *string) error {
 }
 
 func (o *ThirdApi) PartLimit(c *gin.Context) {
-	a2r.Call(third.ThirdClient.PartLimit, o.Client, c)
+	a2r.Call(c, third.ThirdClient.PartLimit, o.Client)
 }
 
 func (o *ThirdApi) PartSize(c *gin.Context) {
-	a2r.Call(third.ThirdClient.PartSize, o.Client, c)
+	a2r.Call(c, third.ThirdClient.PartSize, o.Client)
 }
 
 func (o *ThirdApi) InitiateMultipartUpload(c *gin.Context) {
 	opt := setURLPrefixOption(third.ThirdClient.InitiateMultipartUpload, func(req *third.InitiateMultipartUploadReq) error {
 		return setURLPrefix(c, &req.UrlPrefix)
 	})
-	a2r.Call(third.ThirdClient.InitiateMultipartUpload, o.Client, c, opt)
+	a2r.Call(c, third.ThirdClient.InitiateMultipartUpload, o.Client, opt)
 }
 
 func (o *ThirdApi) AuthSign(c *gin.Context) {
-	a2r.Call(third.ThirdClient.AuthSign, o.Client, c)
+	a2r.Call(c, third.ThirdClient.AuthSign, o.Client)
 }
 
 func (o *ThirdApi) CompleteMultipartUpload(c *gin.Context) {
 	opt := setURLPrefixOption(third.ThirdClient.CompleteMultipartUpload, func(req *third.CompleteMultipartUploadReq) error {
 		return setURLPrefix(c, &req.UrlPrefix)
 	})
-	a2r.Call(third.ThirdClient.CompleteMultipartUpload, o.Client, c, opt)
+	a2r.Call(c, third.ThirdClient.CompleteMultipartUpload, o.Client, opt)
 }
 
 func (o *ThirdApi) AccessURL(c *gin.Context) {
-	a2r.Call(third.ThirdClient.AccessURL, o.Client, c)
+	a2r.Call(c, third.ThirdClient.AccessURL, o.Client)
 }
 
 func (o *ThirdApi) InitiateFormData(c *gin.Context) {
-	a2r.Call(third.ThirdClient.InitiateFormData, o.Client, c)
+	a2r.Call(c, third.ThirdClient.InitiateFormData, o.Client)
 }
 
 func (o *ThirdApi) CompleteFormData(c *gin.Context) {
 	opt := setURLPrefixOption(third.ThirdClient.CompleteFormData, func(req *third.CompleteFormDataReq) error {
 		return setURLPrefix(c, &req.UrlPrefix)
 	})
-	a2r.Call(third.ThirdClient.CompleteFormData, o.Client, c, opt)
+	a2r.Call(c, third.ThirdClient.CompleteFormData, o.Client, opt)
 }
 
 func (o *ThirdApi) ObjectRedirect(c *gin.Context) {
@@ -156,15 +159,15 @@ func (o *ThirdApi) ObjectRedirect(c *gin.Context) {
 
 // #################### logs ####################.
 func (o *ThirdApi) UploadLogs(c *gin.Context) {
-	a2r.Call(third.ThirdClient.UploadLogs, o.Client, c)
+	a2r.Call(c, third.ThirdClient.UploadLogs, o.Client)
 }
 
 func (o *ThirdApi) DeleteLogs(c *gin.Context) {
-	a2r.Call(third.ThirdClient.DeleteLogs, o.Client, c)
+	a2r.Call(c, third.ThirdClient.DeleteLogs, o.Client)
 }
 
 func (o *ThirdApi) SearchLogs(c *gin.Context) {
-	a2r.Call(third.ThirdClient.SearchLogs, o.Client, c)
+	a2r.Call(c, third.ThirdClient.SearchLogs, o.Client)
 }
 
 func (o *ThirdApi) GetPrometheus(c *gin.Context) {

internal/api/user.go

@@ -16,7 +16,7 @@ package api
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msggateway"
 	"github.com/openimsdk/protocol/user"
@@ -26,42 +26,46 @@ import (
 	"github.com/openimsdk/tools/log"
 )
 
-type UserApi rpcclient.User
+type UserApi struct {
+	Client user.UserClient
+	discov discovery.SvcDiscoveryRegistry
+	config config.RpcService
+}
 
-func NewUserApi(client rpcclient.User) UserApi {
+func NewUserApi(client user.UserClient, discov discovery.SvcDiscoveryRegistry, config config.RpcService) UserApi {
-	return UserApi(client)
+	return UserApi{Client: client, discov: discov, config: config}
 }
 
 func (u *UserApi) UserRegister(c *gin.Context) {
-	a2r.Call(user.UserClient.UserRegister, u.Client, c)
+	a2r.Call(c, user.UserClient.UserRegister, u.Client)
 }
 
 // UpdateUserInfo is deprecated. Use UpdateUserInfoEx
 func (u *UserApi) UpdateUserInfo(c *gin.Context) {
-	a2r.Call(user.UserClient.UpdateUserInfo, u.Client, c)
+	a2r.Call(c, user.UserClient.UpdateUserInfo, u.Client)
 }
 
 func (u *UserApi) UpdateUserInfoEx(c *gin.Context) {
-	a2r.Call(user.UserClient.UpdateUserInfoEx, u.Client, c)
+	a2r.Call(c, user.UserClient.UpdateUserInfoEx, u.Client)
 }
 func (u *UserApi) SetGlobalRecvMessageOpt(c *gin.Context) {
-	a2r.Call(user.UserClient.SetGlobalRecvMessageOpt, u.Client, c)
+	a2r.Call(c, user.UserClient.SetGlobalRecvMessageOpt, u.Client)
 }
 
 func (u *UserApi) GetUsersPublicInfo(c *gin.Context) {
-	a2r.Call(user.UserClient.GetDesignateUsers, u.Client, c)
+	a2r.Call(c, user.UserClient.GetDesignateUsers, u.Client)
 }
 
 func (u *UserApi) GetAllUsersID(c *gin.Context) {
-	a2r.Call(user.UserClient.GetAllUserID, u.Client, c)
+	a2r.Call(c, user.UserClient.GetAllUserID, u.Client)
 }
 
 func (u *UserApi) AccountCheck(c *gin.Context) {
-	a2r.Call(user.UserClient.AccountCheck, u.Client, c)
+	a2r.Call(c, user.UserClient.AccountCheck, u.Client)
 }
 
 func (u *UserApi) GetUsers(c *gin.Context) {
-	a2r.Call(user.UserClient.GetPaginationUsers, u.Client, c)
+	a2r.Call(c, user.UserClient.GetPaginationUsers, u.Client)
 }
 
 // GetUsersOnlineStatus Get user online status.
@@ -71,7 +75,7 @@ func (u *UserApi) GetUsersOnlineStatus(c *gin.Context) {
 		apiresp.GinError(c, err)
 		return
 	}
-	conns, err := u.Discov.GetConns(c, u.MessageGateWayRpcName)
+	conns, err := u.discov.GetConns(c, u.config.MessageGateway)
 	if err != nil {
 		apiresp.GinError(c, err)
 		return
@@ -122,7 +126,7 @@ func (u *UserApi) GetUsersOnlineStatus(c *gin.Context) {
 }
 
 func (u *UserApi) UserRegisterCount(c *gin.Context) {
-	a2r.Call(user.UserClient.UserRegisterCount, u.Client, c)
+	a2r.Call(c, user.UserClient.UserRegisterCount, u.Client)
 }
 
 // GetUsersOnlineTokenDetail Get user online token details.
@@ -135,7 +139,7 @@ func (u *UserApi) GetUsersOnlineTokenDetail(c *gin.Context) {
 		apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap())
 		return
 	}
-	conns, err := u.Discov.GetConns(c, u.MessageGateWayRpcName)
+	conns, err := u.discov.GetConns(c, u.config.MessageGateway)
 	if err != nil {
 		apiresp.GinError(c, err)
 		return
@@ -188,52 +192,52 @@ func (u *UserApi) GetUsersOnlineTokenDetail(c *gin.Context) {
 
 // SubscriberStatus Presence status of subscribed users.
 func (u *UserApi) SubscriberStatus(c *gin.Context) {
-	a2r.Call(user.UserClient.SubscribeOrCancelUsersStatus, u.Client, c)
+	a2r.Call(c, user.UserClient.SubscribeOrCancelUsersStatus, u.Client)
 }
 
 // GetUserStatus Get the online status of the user.
 func (u *UserApi) GetUserStatus(c *gin.Context) {
-	a2r.Call(user.UserClient.GetUserStatus, u.Client, c)
+	a2r.Call(c, user.UserClient.GetUserStatus, u.Client)
 }
 
 // GetSubscribeUsersStatus Get the online status of subscribers.
 func (u *UserApi) GetSubscribeUsersStatus(c *gin.Context) {
-	a2r.Call(user.UserClient.GetSubscribeUsersStatus, u.Client, c)
+	a2r.Call(c, user.UserClient.GetSubscribeUsersStatus, u.Client)
 }
 
 // ProcessUserCommandAdd user general function add.
 func (u *UserApi) ProcessUserCommandAdd(c *gin.Context) {
-	a2r.Call(user.UserClient.ProcessUserCommandAdd, u.Client, c)
+	a2r.Call(c, user.UserClient.ProcessUserCommandAdd, u.Client)
 }
 
 // ProcessUserCommandDelete user general function delete.
 func (u *UserApi) ProcessUserCommandDelete(c *gin.Context) {
-	a2r.Call(user.UserClient.ProcessUserCommandDelete, u.Client, c)
+	a2r.Call(c, user.UserClient.ProcessUserCommandDelete, u.Client)
 }
 
 // ProcessUserCommandUpdate  user general function update.
 func (u *UserApi) ProcessUserCommandUpdate(c *gin.Context) {
-	a2r.Call(user.UserClient.ProcessUserCommandUpdate, u.Client, c)
+	a2r.Call(c, user.UserClient.ProcessUserCommandUpdate, u.Client)
 }
 
 // ProcessUserCommandGet user general function get.
 func (u *UserApi) ProcessUserCommandGet(c *gin.Context) {
-	a2r.Call(user.UserClient.ProcessUserCommandGet, u.Client, c)
+	a2r.Call(c, user.UserClient.ProcessUserCommandGet, u.Client)
 }
 
 // ProcessUserCommandGet user general function get all.
 func (u *UserApi) ProcessUserCommandGetAll(c *gin.Context) {
-	a2r.Call(user.UserClient.ProcessUserCommandGetAll, u.Client, c)
+	a2r.Call(c, user.UserClient.ProcessUserCommandGetAll, u.Client)
 }
 
 func (u *UserApi) AddNotificationAccount(c *gin.Context) {
-	a2r.Call(user.UserClient.AddNotificationAccount, u.Client, c)
+	a2r.Call(c, user.UserClient.AddNotificationAccount, u.Client)
 }
 
 func (u *UserApi) UpdateNotificationAccountInfo(c *gin.Context) {
-	a2r.Call(user.UserClient.UpdateNotificationAccountInfo, u.Client, c)
+	a2r.Call(c, user.UserClient.UpdateNotificationAccountInfo, u.Client)
 }
 
 func (u *UserApi) SearchNotificationAccount(c *gin.Context) {
-	a2r.Call(user.UserClient.SearchNotificationAccount, u.Client, c)
+	a2r.Call(c, user.UserClient.SearchNotificationAccount, u.Client)
 }

internal/msggateway/hub_server.go

@@ -16,6 +16,7 @@ package msggateway
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"sync/atomic"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -35,7 +36,14 @@ import (
 )
 
 func (s *Server) InitServer(ctx context.Context, config *Config, disCov discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
-	s.LongConnServer.SetDiscoveryRegistry(disCov, config)
+	userConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.User)
+	if err != nil {
+		return err
+	}
+	s.userClient = rpcli.NewUserClient(userConn)
+	if err := s.LongConnServer.SetDiscoveryRegistry(ctx, disCov, config); err != nil {
+		return err
+	}
 	msggateway.RegisterMsgGatewayServer(server, s)
 	s.userRcp = rpcclient.NewUserRpcClient(disCov, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
 	if s.ready != nil {
@@ -64,6 +72,7 @@ type Server struct {
 	ready          func(srv *Server) error
 	userRcp        rpcclient.UserRpcClient
 	queue          *memamq.MemoryQueue
+	userClient     *rpcli.UserClient
 }
 
 func (s *Server) SetLongConnServer(LongConnServer LongConnServer) {

internal/msggateway/init.go

@@ -57,9 +57,10 @@ func Start(ctx context.Context, index int, conf *Config) error {
 		WithMessageMaxMsgLength(conf.MsgGateway.LongConnSvr.WebsocketMaxMsgLen),
 	)
 
-	hubServer := NewServer(rpcPort, longServer, conf, func(srv *Server) error {
+	hubServer := NewServer(longServer, conf, func(srv *Server) error {
-		longServer.online, _ = rpccache.NewOnlineCache(srv.userRcp, nil, rdb, false, longServer.subscriberUserOnlineStatusChanges)
+		var err error
-		return nil
+		longServer.online, err = rpccache.NewOnlineCache(srv.userClient, nil, rdb, false, longServer.subscriberUserOnlineStatusChanges)
+		return err
 	})
 
 	go longServer.ChangeOnlineStatus(4)

internal/msggateway/message_handler.go

@@ -17,6 +17,7 @@ package msggateway
 import (
 	"context"
 	"encoding/json"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"sync"
 
 	"github.com/go-playground/validator/v10"
@@ -102,34 +103,33 @@ func (r *Resp) String() string {
 }
 
 type MessageHandler interface {
-	GetSeq(context context.Context, data *Req) ([]byte, error)
+	GetSeq(ctx context.Context, data *Req) ([]byte, error)
-	SendMessage(context context.Context, data *Req) ([]byte, error)
+	SendMessage(ctx context.Context, data *Req) ([]byte, error)
-	SendSignalMessage(context context.Context, data *Req) ([]byte, error)
+	SendSignalMessage(ctx context.Context, data *Req) ([]byte, error)
-	PullMessageBySeqList(context context.Context, data *Req) ([]byte, error)
+	PullMessageBySeqList(ctx context.Context, data *Req) ([]byte, error)
-	GetConversationsHasReadAndMaxSeq(context context.Context, data *Req) ([]byte, error)
+	GetConversationsHasReadAndMaxSeq(ctx context.Context, data *Req) ([]byte, error)
-	GetSeqMessage(context context.Context, data *Req) ([]byte, error)
+	GetSeqMessage(ctx context.Context, data *Req) ([]byte, error)
-	UserLogout(context context.Context, data *Req) ([]byte, error)
+	UserLogout(ctx context.Context, data *Req) ([]byte, error)
-	SetUserDeviceBackground(context context.Context, data *Req) ([]byte, bool, error)
+	SetUserDeviceBackground(ctx context.Context, data *Req) ([]byte, bool, error)
 }
 
 var _ MessageHandler = (*GrpcHandler)(nil)
 
 type GrpcHandler struct {
-	msgRpcClient *rpcclient.MessageRpcClient
+	validate   *validator.Validate
-	pushClient   *rpcclient.PushRpcClient
+	msgClient  *rpcli.MsgClient
-	validate     *validator.Validate
+	pushClient *rpcli.PushMsgServiceClient
 }
 
-func NewGrpcHandler(validate *validator.Validate, client discovery.SvcDiscoveryRegistry, rpcRegisterName *config.RpcRegisterName) *GrpcHandler {
+func NewGrpcHandler(validate *validator.Validate, msgClient *rpcli.MsgClient, pushClient *rpcli.PushMsgServiceClient) *GrpcHandler {
-	msgRpcClient := rpcclient.NewMessageRpcClient(client, rpcRegisterName.Msg)
-	pushRpcClient := rpcclient.NewPushRpcClient(client, rpcRegisterName.Push)
 	return &GrpcHandler{
-		msgRpcClient: &msgRpcClient,
+		validate:   validate,
-		pushClient:   &pushRpcClient, validate: validate,
+		msgClient:  msgClient,
+		pushClient: pushClient,
 	}
 }
 
-func (g GrpcHandler) GetSeq(ctx context.Context, data *Req) ([]byte, error) {
+func (g *GrpcHandler) GetSeq(ctx context.Context, data *Req) ([]byte, error) {
 	req := sdkws.GetMaxSeqReq{}
 	if err := proto.Unmarshal(data.Data, &req); err != nil {
 		return nil, errs.WrapMsg(err, "GetSeq: error unmarshaling request", "action", "unmarshal", "dataType", "GetMaxSeqReq")
@@ -137,7 +137,7 @@ func (g GrpcHandler) GetSeq(ctx context.Context, data *Req) ([]byte, error) {
 	if err := g.validate.Struct(&req); err != nil {
 		return nil, errs.WrapMsg(err, "GetSeq: validation failed", "action", "validate", "dataType", "GetMaxSeqReq")
 	}
-	resp, err := g.msgRpcClient.GetMaxSeq(ctx, &req)
+	resp, err := g.msgClient.MsgClient.GetMaxSeq(ctx, &req)
 	if err != nil {
 		return nil, err
 	}
@@ -150,7 +150,7 @@ func (g GrpcHandler) GetSeq(ctx context.Context, data *Req) ([]byte, error) {
 
 // SendMessage handles the sending of messages through gRPC. It unmarshals the request data,
 // validates the message, and then sends it using the message RPC client.
-func (g GrpcHandler) SendMessage(ctx context.Context, data *Req) ([]byte, error) {
+func (g *GrpcHandler) SendMessage(ctx context.Context, data *Req) ([]byte, error) {
 	var msgData sdkws.MsgData
 	if err := proto.Unmarshal(data.Data, &msgData); err != nil {
 		return nil, errs.WrapMsg(err, "SendMessage: error unmarshaling message data", "action", "unmarshal", "dataType", "MsgData")
@@ -161,7 +161,7 @@ func (g GrpcHandler) SendMessage(ctx context.Context, data *Req) ([]byte, error)
 	}
 
 	req := msg.SendMsgReq{MsgData: &msgData}
-	resp, err := g.msgRpcClient.SendMsg(ctx, &req)
+	resp, err := g.msgClient.MsgClient.SendMsg(ctx, &req)
 	if err != nil {
 		return nil, err
 	}
@@ -174,8 +174,8 @@ func (g GrpcHandler) SendMessage(ctx context.Context, data *Req) ([]byte, error)
 	return c, nil
 }
 
-func (g GrpcHandler) SendSignalMessage(context context.Context, data *Req) ([]byte, error) {
+func (g *GrpcHandler) SendSignalMessage(ctx context.Context, data *Req) ([]byte, error) {
-	resp, err := g.msgRpcClient.SendMsg(context, nil)
+	resp, err := g.msgClient.MsgClient.SendMsg(ctx, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -186,7 +186,7 @@ func (g GrpcHandler) SendSignalMessage(context context.Context, data *Req) ([]by
 	return c, nil
 }
 
-func (g GrpcHandler) PullMessageBySeqList(context context.Context, data *Req) ([]byte, error) {
+func (g *GrpcHandler) PullMessageBySeqList(ctx context.Context, data *Req) ([]byte, error) {
 	req := sdkws.PullMessageBySeqsReq{}
 	if err := proto.Unmarshal(data.Data, &req); err != nil {
 		return nil, errs.WrapMsg(err, "err proto unmarshal", "action", "unmarshal", "dataType", "PullMessageBySeqsReq")
@@ -194,7 +194,7 @@ func (g GrpcHandler) PullMessageBySeqList(context context.Context, data *Req) ([
 	if err := g.validate.Struct(data); err != nil {
 		return nil, errs.WrapMsg(err, "validation failed", "action", "validate", "dataType", "PullMessageBySeqsReq")
 	}
-	resp, err := g.msgRpcClient.PullMessageBySeqList(context, &req)
+	resp, err := g.msgClient.MsgClient.PullMessageBySeqs(ctx, &req)
 	if err != nil {
 		return nil, err
 	}
@@ -205,7 +205,7 @@ func (g GrpcHandler) PullMessageBySeqList(context context.Context, data *Req) ([
 	return c, nil
 }
 
-func (g GrpcHandler) GetConversationsHasReadAndMaxSeq(context context.Context, data *Req) ([]byte, error) {
+func (g *GrpcHandler) GetConversationsHasReadAndMaxSeq(ctx context.Context, data *Req) ([]byte, error) {
 	req := msg.GetConversationsHasReadAndMaxSeqReq{}
 	if err := proto.Unmarshal(data.Data, &req); err != nil {
 		return nil, errs.WrapMsg(err, "err proto unmarshal", "action", "unmarshal", "dataType", "GetConversationsHasReadAndMaxSeq")
@@ -213,7 +213,7 @@ func (g GrpcHandler) GetConversationsHasReadAndMaxSeq(context context.Context, d
 	if err := g.validate.Struct(data); err != nil {
 		return nil, errs.WrapMsg(err, "validation failed", "action", "validate", "dataType", "GetConversationsHasReadAndMaxSeq")
 	}
-	resp, err := g.msgRpcClient.GetConversationsHasReadAndMaxSeq(context, &req)
+	resp, err := g.msgClient.MsgClient.GetConversationsHasReadAndMaxSeq(ctx, &req)
 	if err != nil {
 		return nil, err
 	}
@@ -224,7 +224,7 @@ func (g GrpcHandler) GetConversationsHasReadAndMaxSeq(context context.Context, d
 	return c, nil
 }
 
-func (g GrpcHandler) GetSeqMessage(context context.Context, data *Req) ([]byte, error) {
+func (g *GrpcHandler) GetSeqMessage(ctx context.Context, data *Req) ([]byte, error) {
 	req := msg.GetSeqMessageReq{}
 	if err := proto.Unmarshal(data.Data, &req); err != nil {
 		return nil, errs.WrapMsg(err, "error unmarshaling request", "action", "unmarshal", "dataType", "GetSeqMessage")
@@ -232,7 +232,7 @@ func (g GrpcHandler) GetSeqMessage(context context.Context, data *Req) ([]byte,
 	if err := g.validate.Struct(data); err != nil {
 		return nil, errs.WrapMsg(err, "validation failed", "action", "validate", "dataType", "GetSeqMessage")
 	}
-	resp, err := g.msgRpcClient.GetSeqMessage(context, &req)
+	resp, err := g.msgClient.MsgClient.GetSeqMessage(ctx, &req)
 	if err != nil {
 		return nil, err
 	}
@@ -243,12 +243,12 @@ func (g GrpcHandler) GetSeqMessage(context context.Context, data *Req) ([]byte,
 	return c, nil
 }
 
-func (g GrpcHandler) UserLogout(context context.Context, data *Req) ([]byte, error) {
+func (g *GrpcHandler) UserLogout(ctx context.Context, data *Req) ([]byte, error) {
 	req := push.DelUserPushTokenReq{}
 	if err := proto.Unmarshal(data.Data, &req); err != nil {
 		return nil, errs.WrapMsg(err, "error unmarshaling request", "action", "unmarshal", "dataType", "DelUserPushTokenReq")
 	}
-	resp, err := g.pushClient.DelUserPushToken(context, &req)
+	resp, err := g.pushClient.PushMsgServiceClient.DelUserPushToken(ctx, &req)
 	if err != nil {
 		return nil, err
 	}
@@ -259,7 +259,7 @@ func (g GrpcHandler) UserLogout(context context.Context, data *Req) ([]byte, err
 	return c, nil
 }
 
-func (g GrpcHandler) SetUserDeviceBackground(_ context.Context, data *Req) ([]byte, bool, error) {
+func (g *GrpcHandler) SetUserDeviceBackground(ctx context.Context, data *Req) ([]byte, bool, error) {
 	req := sdkws.SetAppBackgroundStatusReq{}
 	if err := proto.Unmarshal(data.Data, &req); err != nil {
 		return nil, false, errs.WrapMsg(err, "error unmarshaling request", "action", "unmarshal", "dataType", "SetAppBackgroundStatusReq")

internal/msggateway/online.go

@@ -87,7 +87,7 @@ func (ws *WsServer) ChangeOnlineStatus(concurrent int) {
 		opIdCtx := mcontext.SetOperationID(context.Background(), operationIDPrefix+strconv.FormatInt(count.Add(1), 10))
 		ctx, cancel := context.WithTimeout(opIdCtx, time.Second*5)
 		defer cancel()
-		if _, err := ws.userClient.Client.SetUserOnlineStatus(ctx, req); err != nil {
+		if err := ws.userClient.SetUserOnlineStatus(ctx, req); err != nil {
 			log.ZError(ctx, "update user online status", err)
 		}
 		for _, ss := range req.Status {

internal/msggateway/ws_server.go

@@ -3,6 +3,12 @@ package msggateway
 import (
 	"context"
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"net/http"
+	"sync"
+	"sync/atomic"
+	"time"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
 	pbAuth "github.com/openimsdk/protocol/auth"
@@ -31,7 +37,7 @@ type LongConnServer interface {
 	GetUserAllCons(userID string) ([]*Client, bool)
 	GetUserPlatformCons(userID string, platform int) ([]*Client, bool, bool)
 	Validate(s any) error
-	SetDiscoveryRegistry(client discovery.SvcDiscoveryRegistry, config *Config)
+	SetDiscoveryRegistry(ctx context.Context, client discovery.SvcDiscoveryRegistry, config *Config) error
 	KickUserConn(client *Client) error
 	UnRegister(c *Client)
 	SetKickHandlerInfo(i *kickHandler)
@@ -63,6 +69,8 @@ type WsServer struct {
 	//Encoder
 	MessageHandler
 	webhookClient *webhook.Client
+	userClient    *rpcli.UserClient
+	authClient    *rpcli.AuthClient
 }
 
 type kickHandler struct {
@@ -71,12 +79,28 @@ type kickHandler struct {
 	newClient  *Client
 }
 
-func (ws *WsServer) SetDiscoveryRegistry(disCov discovery.SvcDiscoveryRegistry, config *Config) {
+func (ws *WsServer) SetDiscoveryRegistry(ctx context.Context, disCov discovery.SvcDiscoveryRegistry, config *Config) error {
-	ws.MessageHandler = NewGrpcHandler(ws.validate, disCov, &config.Share.RpcRegisterName)
+	userConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.User)
-	u := rpcclient.NewUserRpcClient(disCov, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
+	if err != nil {
-	ws.authClient = rpcclient.NewAuth(disCov, config.Share.RpcRegisterName.Auth)
+		return err
-	ws.userClient = &u
+	}
+	pushConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.Push)
+	if err != nil {
+		return err
+	}
+	authConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.Auth)
+	if err != nil {
+		return err
+	}
+	msgConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.Msg)
+	if err != nil {
+		return err
+	}
+	ws.userClient = rpcli.NewUserClient(userConn)
+	ws.authClient = rpcli.NewAuthClient(authConn)
+	ws.MessageHandler = NewGrpcHandler(ws.validate, rpcli.NewMsgClient(msgConn), rpcli.NewPushMsgServiceClient(pushConn))
 	ws.disCov = disCov
+	return nil
 }
 
 //func (ws *WsServer) SetUserOnlineStatus(ctx context.Context, client *Client, status int32) {
@@ -311,7 +335,7 @@ func (ws *WsServer) multiTerminalLoginChecker(clientOK bool, oldClients []*Clien
 			[]string{newClient.ctx.GetOperationID(), newClient.ctx.GetUserID(),
 				constant.PlatformIDToName(newClient.PlatformID), newClient.ctx.GetConnID()},
 		)
-		if _, err := ws.authClient.KickTokens(ctx, kickTokens); err != nil {
+		if err := ws.authClient.KickTokens(ctx, kickTokens); err != nil {
 			log.ZWarn(newClient.ctx, "kickTokens err", err)
 		}
 	}
@@ -338,7 +362,12 @@ func (ws *WsServer) multiTerminalLoginChecker(clientOK bool, oldClients []*Clien
 			[]string{newClient.ctx.GetOperationID(), newClient.ctx.GetUserID(),
 				constant.PlatformIDToName(newClient.PlatformID), newClient.ctx.GetConnID()},
 		)
-		if _, err := ws.authClient.InvalidateToken(ctx, newClient.token, newClient.UserID, newClient.PlatformID); err != nil {
+		req := &pbAuth.InvalidateTokenReq{
+			PreservedToken: newClient.token,
+			UserID:         newClient.UserID,
+			PlatformID:     int32(newClient.PlatformID),
+		}
+		if err := ws.authClient.InvalidateToken(ctx, req); err != nil {
 			log.ZWarn(newClient.ctx, "InvalidateToken err", err, "userID", newClient.UserID,
 				"platformID", newClient.PlatformID)
 		}

internal/msgtransfer/init.go

@@ -23,6 +23,11 @@ import (
 	"os/signal"
 	"syscall"
 
+	"github.com/openimsdk/tools/discovery"
+	"github.com/openimsdk/tools/discovery/etcd"
+	"github.com/openimsdk/tools/utils/jsonutil"
+	"github.com/openimsdk/tools/utils/network"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
@@ -81,7 +86,6 @@ func Start(ctx context.Context, index int, config *Config) error {
 	}
 	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()),
 		grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
-
 	msgModel := redis.NewMsgCache(rdb)
 	msgDocModel, err := mgo.NewMsgMongo(mgocli.GetDB())
 	if err != nil {
@@ -101,9 +105,7 @@ func Start(ctx context.Context, index int, config *Config) error {
 	if err != nil {
 		return err
 	}
-	conversationRpcClient := rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation)
+	historyCH, err := NewOnlineHistoryRedisConsumerHandler(ctx, client, config, msgTransferDatabase)
-	groupRpcClient := rpcclient.NewGroupRpcClient(client, config.Share.RpcRegisterName.Group)
-	historyCH, err := NewOnlineHistoryRedisConsumerHandler(&config.KafkaConfig, msgTransferDatabase, &conversationRpcClient, &groupRpcClient)
 	if err != nil {
 		return err
 	}

internal/msgtransfer/online_history_msg_handler.go

@@ -18,6 +18,8 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/tools/discovery"
 	"strconv"
 	"strings"
 	"sync"
@@ -27,12 +29,13 @@ import (
 
 	"github.com/IBM/sarama"
 	"github.com/go-redis/redis"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/openimsdk/open-im-server/v3/pkg/tools/batcher"
 	"github.com/openimsdk/protocol/constant"
+	pbconv "github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
@@ -73,17 +76,30 @@ type OnlineHistoryRedisConsumerHandler struct {
 	groupRpcClient              *rpcclient.GroupRpcClient
 	conversationUserHasReadChan chan *userHasReadSeq
 	wg                          sync.WaitGroup
+
+	groupClient        *rpcli.GroupClient
+	conversationClient *rpcli.ConversationClient
 }
 
-func NewOnlineHistoryRedisConsumerHandler(kafkaConf *config.Kafka, database controller.MsgTransferDatabase,
+func NewOnlineHistoryRedisConsumerHandler(ctx context.Context, client discovery.SvcDiscoveryRegistry, config *Config, database controller.MsgTransferDatabase) (*OnlineHistoryRedisConsumerHandler, error) {
-	conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient) (*OnlineHistoryRedisConsumerHandler, error) {
+	kafkaConf := config.KafkaConfig
 	historyConsumerGroup, err := kafka.NewMConsumerGroup(kafkaConf.Build(), kafkaConf.ToRedisGroupID, []string{kafkaConf.ToRedisTopic}, false)
 	if err != nil {
 		return nil, err
 	}
+	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
+	if err != nil {
+		return nil, err
+	}
+	conversationConn, err := client.GetConn(ctx, config.Discovery.RpcService.Conversation)
+	if err != nil {
+		return nil, err
+	}
 	var och OnlineHistoryRedisConsumerHandler
 	och.msgTransferDatabase = database
 	och.conversationUserHasReadChan = make(chan *userHasReadSeq, hasReadChanBuffer)
+	och.groupClient = rpcli.NewGroupClient(groupConn)
+	och.conversationClient = rpcli.NewConversationClient(conversationConn)
 	och.wg.Add(1)
 
 	b := batcher.New[sarama.ConsumerMessage](
@@ -113,15 +129,13 @@ func (och *OnlineHistoryRedisConsumerHandler) do(ctx context.Context, channelID
 	ctx = mcontext.WithTriggerIDContext(ctx, val.TriggerID())
 	ctxMessages := och.parseConsumerMessages(ctx, val.Val())
 	ctx = withAggregationCtx(ctx, ctxMessages)
-	log.ZInfo(ctx, "msg arrived channel", "channel id", channelID, "msgList length", len(ctxMessages),
+	log.ZInfo(ctx, "msg arrived channel", "channel id", channelID, "msgList length", len(ctxMessages), "key", val.Key())
-		"key", val.Key())
 	och.doSetReadSeq(ctx, ctxMessages)
 
 	storageMsgList, notStorageMsgList, storageNotificationList, notStorageNotificationList :=
 		och.categorizeMessageLists(ctxMessages)
 	log.ZDebug(ctx, "number of categorized messages", "storageMsgList", len(storageMsgList), "notStorageMsgList",
-		len(notStorageMsgList), "storageNotificationList", len(storageNotificationList), "notStorageNotificationList",
+		len(notStorageMsgList), "storageNotificationList", len(storageNotificationList), "notStorageNotificationList", len(notStorageNotificationList))
-		len(notStorageNotificationList))
 
 	conversationIDMsg := msgprocessor.GetChatConversationIDByMsg(ctxMessages[0].message)
 	conversationIDNotification := msgprocessor.GetNotificationConversationIDByMsg(ctxMessages[0].message)
@@ -285,22 +299,27 @@ func (och *OnlineHistoryRedisConsumerHandler) handleMsg(ctx context.Context, key
 			case constant.ReadGroupChatType:
 				log.ZDebug(ctx, "group chat first create conversation", "conversationID",
 					conversationID)
-				userIDs, err := och.groupRpcClient.GetGroupMemberIDs(ctx, msg.GroupID)
+
+				userIDs, err := och.groupClient.GetGroupMemberUserIDs(ctx, msg.GroupID)
 				if err != nil {
 					log.ZWarn(ctx, "get group member ids error", err, "conversationID",
 						conversationID)
 				} else {
 					log.ZInfo(ctx, "GetGroupMemberIDs end")
 
-					if err := och.conversationRpcClient.GroupChatFirstCreateConversation(ctx,
+					if err := och.conversationClient.CreateGroupChatConversations(ctx, msg.GroupID, userIDs); err != nil {
-						msg.GroupID, userIDs); err != nil {
 						log.ZWarn(ctx, "single chat first create conversation error", err,
 							"conversationID", conversationID)
 					}
 				}
 			case constant.SingleChatType, constant.NotificationChatType:
-				if err := och.conversationRpcClient.SingleChatFirstCreateConversation(ctx, msg.RecvID,
+				req := &pbconv.CreateSingleChatConversationsReq{
-					msg.SendID, conversationID, msg.SessionType); err != nil {
+					RecvID:           msg.RecvID,
+					SendID:           msg.SendID,
+					ConversationID:   conversationID,
+					ConversationType: msg.SessionType,
+				}
+				if err := och.conversationClient.CreateSingleChatConversations(ctx, req); err != nil {
 					log.ZWarn(ctx, "single chat or notification first create conversation error", err,
 						"conversationID", conversationID, "sessionType", msg.SessionType)
 				}

internal/push/push.go

@@ -36,11 +36,6 @@ type Config struct {
 	runTimeEnv string
 }
 
-func (p pushServer) PushMsg(ctx context.Context, req *pbpush.PushMsgReq) (*pbpush.PushMsgResp, error) {
-	//todo reserved Interface
-	return nil, nil
-}
-
 func (p pushServer) DelUserPushToken(ctx context.Context,
 	req *pbpush.DelUserPushTokenReq) (resp *pbpush.DelUserPushTokenResp, err error) {
 	if err = p.database.DelFcmToken(ctx, req.UserID, int(req.PlatformID)); err != nil {
@@ -62,7 +57,7 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 
 	database := controller.NewPushDatabase(cacheModel, &config.KafkaConfig)
 
-	consumer, err := NewConsumerHandler(config, database, offlinePusher, rdb, client)
+	consumer, err := NewConsumerHandler(ctx, config, database, offlinePusher, rdb, client)
 	if err != nil {
 		return err
 	}

internal/push/push_handler.go

@@ -3,7 +3,7 @@ package push
 import (
 	"context"
 	"encoding/json"
-
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"math/rand"
 	"strconv"
 	"time"
@@ -46,9 +46,13 @@ type ConsumerHandler struct {
 	groupRpcClient         rpcclient.GroupRpcClient
 	webhookClient          *webhook.Client
 	config                 *Config
+	userClient             *rpcli.UserClient
+	groupClient            *rpcli.GroupClient
+	msgClient              *rpcli.MsgClient
+	conversationClient     *rpcli.ConversationClient
 }
 
-func NewConsumerHandler(config *Config, database controller.PushDatabase, offlinePusher offlinepush.OfflinePusher, rdb redis.UniversalClient,
+func NewConsumerHandler(ctx context.Context, config *Config, database controller.PushDatabase, offlinePusher offlinepush.OfflinePusher, rdb redis.UniversalClient,
 	client discovery.SvcDiscoveryRegistry) (*ConsumerHandler, error) {
 	var consumerHandler ConsumerHandler
 	var err error
@@ -57,20 +61,37 @@ func NewConsumerHandler(config *Config, database controller.PushDatabase, offlin
 	if err != nil {
 		return nil, err
 	}
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
+	if err != nil {
+		return nil, err
+	}
+	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
+	if err != nil {
+		return nil, err
+	}
+	msgConn, err := client.GetConn(ctx, config.Discovery.RpcService.Msg)
+	if err != nil {
+		return nil, err
+	}
+	conversationConn, err := client.GetConn(ctx, config.Discovery.RpcService.Conversation)
+	if err != nil {
+		return nil, err
+	}
+	consumerHandler.userClient = rpcli.NewUserClient(userConn)
+	consumerHandler.groupClient = rpcli.NewGroupClient(groupConn)
+	consumerHandler.msgClient = rpcli.NewMsgClient(msgConn)
+	consumerHandler.conversationClient = rpcli.NewConversationClient(conversationConn)
 
 	userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
 
 	consumerHandler.offlinePusher = offlinePusher
 	consumerHandler.onlinePusher = NewOnlinePusher(client, config)
-	consumerHandler.groupRpcClient = rpcclient.NewGroupRpcClient(client, config.Share.RpcRegisterName.Group)
+	consumerHandler.groupLocalCache = rpccache.NewGroupLocalCache(consumerHandler.groupClient, &config.LocalCacheConfig, rdb)
-	consumerHandler.groupLocalCache = rpccache.NewGroupLocalCache(consumerHandler.groupRpcClient, &config.LocalCacheConfig, rdb)
+	consumerHandler.conversationLocalCache = rpccache.NewConversationLocalCache(consumerHandler.conversationClient, &config.LocalCacheConfig, rdb)
-	consumerHandler.msgRpcClient = rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
-	consumerHandler.conversationRpcClient = rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation)
-	consumerHandler.conversationLocalCache = rpccache.NewConversationLocalCache(consumerHandler.conversationRpcClient, &config.LocalCacheConfig, rdb)
 	consumerHandler.webhookClient = webhook.NewWebhookClient(config.WebhooksConfig.URL)
 	consumerHandler.config = config
 	consumerHandler.pushDatabase = database
-	consumerHandler.onlineCache, err = rpccache.NewOnlineCache(userRpcClient, consumerHandler.groupLocalCache, rdb, config.RpcConfig.FullUserCache, nil)
+	consumerHandler.onlineCache, err = rpccache.NewOnlineCache(consumerHandler.userClient, consumerHandler.groupLocalCache, rdb, config.RpcConfig.FullUserCache, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -327,7 +348,7 @@ func (c *ConsumerHandler) groupMessagesHandler(ctx context.Context, groupID stri
 					ctx = mcontext.WithOpUserIDContext(ctx, c.config.Share.IMAdminUserID[0])
 				}
 				defer func(groupID string) {
-					if err = c.groupRpcClient.DismissGroup(ctx, groupID); err != nil {
+					if err := c.groupClient.DismissGroup(ctx, groupID, true); err != nil {
 						log.ZError(ctx, "DismissGroup Notification clear members", err, "groupID", groupID)
 					}
 				}(groupID)
@@ -353,10 +374,7 @@ func (c *ConsumerHandler) offlinePushMsg(ctx context.Context, msg *sdkws.MsgData
 
 func (c *ConsumerHandler) filterGroupMessageOfflinePush(ctx context.Context, groupID string, msg *sdkws.MsgData,
 	offlinePushUserIDs []string) (userIDs []string, err error) {
-
+	needOfflinePushUserIDs, err := c.conversationClient.GetConversationOfflinePushUserIDs(ctx, conversationutil.GenGroupConversationID(groupID), offlinePushUserIDs)
-	//todo local cache Obtain the difference set through local comparison.
-	needOfflinePushUserIDs, err := c.conversationRpcClient.GetConversationOfflinePushUserIDs(
-		ctx, conversationutil.GenGroupConversationID(groupID), offlinePushUserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -410,12 +428,11 @@ func (c *ConsumerHandler) getOfflinePushInfos(msg *sdkws.MsgData) (title, conten
 
 func (c *ConsumerHandler) DeleteMemberAndSetConversationSeq(ctx context.Context, groupID string, userIDs []string) error {
 	conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
-	maxSeq, err := c.msgRpcClient.GetConversationMaxSeq(ctx, conversationID)
+	maxSeq, err := c.msgClient.GetConversationMaxSeq(ctx, conversationID)
 	if err != nil {
 		return err
 	}
-	
+	return c.conversationClient.SetConversationMaxSeq(ctx, conversationID, userIDs, maxSeq)
-	return c.conversationRpcClient.SetConversationMaxSeq(ctx, userIDs, conversationID, maxSeq)
 }
 
 func unmarshalNotificationElem(bytes []byte, t any) error {
@@ -423,6 +440,5 @@ func unmarshalNotificationElem(bytes []byte, t any) error {
 	if err := json.Unmarshal(bytes, &notification); err != nil {
 		return err
 	}
-
 	return json.Unmarshal([]byte(notification.Detail), t)
 }

internal/rpc/auth/auth.go

@@ -17,6 +17,7 @@ package auth
 import (
 	"context"
 	"errors"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	redis2 "github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
@@ -28,7 +29,6 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	pbauth "github.com/openimsdk/protocol/auth"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msggateway"
@@ -45,6 +45,7 @@ type authServer struct {
 	userRpcClient  *rpcclient.UserRpcClient
 	RegisterCenter discovery.SvcDiscoveryRegistry
 	config         *Config
+	userClient     *rpcli.UserClient
 }
 
 type Config struct {
@@ -59,7 +60,10 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	if err != nil {
 		return err
 	}
-	userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
+	if err != nil {
+		return err
+	}
 	pbauth.RegisterAuthServer(server, &authServer{
 		userRpcClient:  &userRpcClient,
 		RegisterCenter: client,
@@ -70,7 +74,8 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 			config.Share.MultiLogin,
 			config.Share.IMAdminUserID,
 		),
-		config: config,
+		config:     config,
+		userClient: rpcli.NewUserClient(userConn),
 	})
 	return nil
 }
@@ -86,7 +91,7 @@ func (s *authServer) GetAdminToken(ctx context.Context, req *pbauth.GetAdminToke
 
 	}
 
-	if _, err := s.userRpcClient.GetUserInfo(ctx, req.UserID); err != nil {
+	if err := s.userClient.CheckUser(ctx, []string{req.UserID}); err != nil {
 		return nil, err
 	}
 
@@ -115,7 +120,7 @@ func (s *authServer) GetUserToken(ctx context.Context, req *pbauth.GetUserTokenR
 	if authverify.IsManagerUserID(req.UserID, s.config.Share.IMAdminUserID) {
 		return nil, errs.ErrNoPermission.WrapMsg("don't get Admin token")
 	}
-	if _, err := s.userRpcClient.GetUserInfo(ctx, req.UserID); err != nil {
+	if err := s.userClient.CheckUser(ctx, []string{req.UserID}); err != nil {
 		return nil, err
 	}
 	token, err := s.authDatabase.CreateToken(ctx, req.UserID, int(req.PlatformID))
@@ -156,10 +161,7 @@ func (s *authServer) parseToken(ctx context.Context, tokensString string) (claim
 	return nil, servererrs.ErrTokenNotExist.Wrap()
 }
 
-func (s *authServer) ParseToken(
+func (s *authServer) ParseToken(ctx context.Context, req *pbauth.ParseTokenReq) (resp *pbauth.ParseTokenResp, err error) {
-	ctx context.Context,
-	req *pbauth.ParseTokenReq,
-) (resp *pbauth.ParseTokenResp, err error) {
 	resp = &pbauth.ParseTokenResp{}
 	claims, err := s.parseToken(ctx, req.Token)
 	if err != nil {

internal/rpc/conversation/conversation.go

@@ -16,8 +16,7 @@ package conversation
 
 import (
 	"context"
-	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
-	pbmsg "github.com/openimsdk/protocol/msg"
 	"sort"
 	"time"
 
@@ -27,12 +26,12 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	dbModel "github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
+	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
 	"github.com/openimsdk/tools/db/redisutil"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/openimsdk/protocol/constant"
 	pbconversation "github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/sdkws"
@@ -53,6 +52,10 @@ type conversationServer struct {
 
 	conversationNotificationSender *ConversationNotificationSender
 	config                         *Config
+
+	userClient  *rpcli.UserClient
+	msgClient   *rpcli.MsgClient
+	groupClient *rpcli.GroupClient
 }
 
 type Config struct {
@@ -78,17 +81,27 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	if err != nil {
 		return err
 	}
-	groupRpcClient := rpcclient.NewGroupRpcClient(client, config.Share.RpcRegisterName.Group)
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
-	msgRpcClient := rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
+	if err != nil {
-	userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
+		return err
+	}
+	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
+	if err != nil {
+		return err
+	}
+	msgConn, err := client.GetConn(ctx, config.Discovery.RpcService.Msg)
+	if err != nil {
+		return err
+	}
+	msgClient := rpcli.NewMsgClient(msgConn)
 	localcache.InitLocalCache(&config.LocalCacheConfig)
 	pbconversation.RegisterConversationServer(server, &conversationServer{
-		msgRpcClient:                   &msgRpcClient,
+		conversationNotificationSender: NewConversationNotificationSender(&config.NotificationConfig, msgClient),
-		user:                           &userRpcClient,
-		conversationNotificationSender: NewConversationNotificationSender(&config.NotificationConfig, &msgRpcClient),
-		groupRpcClient:                 &groupRpcClient,
 		conversationDatabase: controller.NewConversationDatabase(conversationDB,
 			redis.NewConversationRedis(rdb, &config.LocalCacheConfig, redis.GetRocksCacheOptions(), conversationDB), mgocli.GetTx()),
+		userClient:  rpcli.NewUserClient(userConn),
+		groupClient: rpcli.NewGroupClient(groupConn),
+		msgClient:   msgClient,
 	})
 	return nil
 }
@@ -125,13 +138,12 @@ func (c *conversationServer) GetSortedConversationList(ctx context.Context, req
 	if len(conversations) == 0 {
 		return nil, errs.ErrRecordNotFound.Wrap()
 	}
-
+	maxSeqs, err := c.msgClient.GetMaxSeqs(ctx, conversationIDs)
-	maxSeqs, err := c.msgRpcClient.GetMaxSeqs(ctx, conversationIDs)
 	if err != nil {
 		return nil, err
 	}
 
-	chatLogs, err := c.msgRpcClient.GetMsgByConversationIDs(ctx, conversationIDs, maxSeqs)
+	chatLogs, err := c.msgClient.GetMsgByConversationIDs(ctx, conversationIDs, maxSeqs)
 	if err != nil {
 		return nil, err
 	}
@@ -141,7 +153,7 @@ func (c *conversationServer) GetSortedConversationList(ctx context.Context, req
 		return nil, err
 	}
 
-	hasReadSeqs, err := c.msgRpcClient.GetHasReadSeqs(ctx, req.UserID, conversationIDs)
+	hasReadSeqs, err := c.msgClient.GetHasReadSeqs(ctx, conversationIDs, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -230,7 +242,7 @@ func (c *conversationServer) SetConversations(ctx context.Context, req *pbconver
 	}
 
 	if req.Conversation.ConversationType == constant.WriteGroupChatType {
-		groupInfo, err := c.groupRpcClient.GetGroupInfo(ctx, req.Conversation.GroupID)
+		groupInfo, err := c.groupClient.GetGroupInfo(ctx, req.Conversation.GroupID)
 		if err != nil {
 			return nil, err
 		}
@@ -434,14 +446,14 @@ func (c *conversationServer) CreateGroupChatConversations(ctx context.Context, r
 		return nil, err
 	}
 	conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, req.GroupID)
-	if _, err := c.msgRpcClient.Client.SetUserConversationMaxSeq(ctx, &pbmsg.SetUserConversationMaxSeqReq{ConversationID: conversationID, OwnerUserID: req.UserIDs, MaxSeq: 0}); err != nil {
+	if err := c.msgClient.SetUserConversationMaxSeq(ctx, conversationID, req.UserIDs, 0); err != nil {
 		return nil, err
 	}
 	return &pbconversation.CreateGroupChatConversationsResp{}, nil
 }
 
 func (c *conversationServer) SetConversationMaxSeq(ctx context.Context, req *pbconversation.SetConversationMaxSeqReq) (*pbconversation.SetConversationMaxSeqResp, error) {
-	if _, err := c.msgRpcClient.Client.SetUserConversationMaxSeq(ctx, &pbmsg.SetUserConversationMaxSeqReq{ConversationID: req.ConversationID, OwnerUserID: req.OwnerUserID, MaxSeq: req.MaxSeq}); err != nil {
+	if err := c.msgClient.SetUserConversationMaxSeq(ctx, req.ConversationID, req.OwnerUserID, req.MaxSeq); err != nil {
 		return nil, err
 	}
 	if err := c.conversationDatabase.UpdateUsersConversationField(ctx, req.OwnerUserID, req.ConversationID,
@@ -455,7 +467,7 @@ func (c *conversationServer) SetConversationMaxSeq(ctx context.Context, req *pbc
 }
 
 func (c *conversationServer) SetConversationMinSeq(ctx context.Context, req *pbconversation.SetConversationMinSeqReq) (*pbconversation.SetConversationMinSeqResp, error) {
-	if _, err := c.msgRpcClient.Client.SetUserConversationMinSeq(ctx, &pbmsg.SetUserConversationMinSeqReq{ConversationID: req.ConversationID, OwnerUserID: req.OwnerUserID, MinSeq: req.MinSeq}); err != nil {
+	if err := c.msgClient.SetUserConversationMin(ctx, req.ConversationID, req.OwnerUserID, req.MinSeq); err != nil {
 		return nil, err
 	}
 	if err := c.conversationDatabase.UpdateUsersConversationField(ctx, req.OwnerUserID, req.ConversationID,
@@ -565,7 +577,7 @@ func (c *conversationServer) getConversationInfo(
 		}
 	}
 	if len(sendIDs) != 0 {
-		sendInfos, err := c.user.GetUsersInfo(ctx, sendIDs)
+		sendInfos, err := c.userClient.GetUsersInfo(ctx, sendIDs)
 		if err != nil {
 			return nil, err
 		}
@@ -574,7 +586,7 @@ func (c *conversationServer) getConversationInfo(
 		}
 	}
 	if len(groupIDs) != 0 {
-		groupInfos, err := c.groupRpcClient.GetGroupInfos(ctx, groupIDs, false)
+		groupInfos, err := c.groupClient.GetGroupsInfo(ctx, groupIDs)
 		if err != nil {
 			return nil, err
 		}
@@ -762,23 +774,22 @@ func (c *conversationServer) ClearUserConversationMsg(ctx context.Context, req *
 		if conversation.IsMsgDestruct == false || conversation.MsgDestructTime == 0 {
 			continue
 		}
-		rcpReq := &pbmsg.GetLastMessageSeqByTimeReq{ConversationID: conversation.ConversationID, Time: req.Timestamp - conversation.MsgDestructTime}
+		seq, err := c.msgClient.GetLastMessageSeqByTime(ctx, conversation.ConversationID, req.Timestamp-conversation.MsgDestructTime)
-		resp, err := pbmsg.GetLastMessageSeqByTime.Invoke(ctx, rcpReq)
 		if err != nil {
 			return nil, err
 		}
-		if resp.Seq <= 0 {
+		if seq <= 0 {
-			log.ZDebug(ctx, "ClearUserConversationMsg GetLastMessageSeqByTime seq <= 0", "index", i, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID, "msgDestructTime", conversation.MsgDestructTime, "seq", resp.Seq)
+			log.ZDebug(ctx, "ClearUserConversationMsg GetLastMessageSeqByTime seq <= 0", "index", i, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID, "msgDestructTime", conversation.MsgDestructTime, "seq", seq)
 			if err := c.setConversationMinSeqAndLatestMsgDestructTime(ctx, conversation.ConversationID, conversation.OwnerUserID, -1, latestMsgDestructTime); err != nil {
 				return nil, err
 			}
 			continue
 		}
-		resp.Seq++
+		seq++
-		if err := c.setConversationMinSeqAndLatestMsgDestructTime(ctx, conversation.ConversationID, conversation.OwnerUserID, resp.Seq, latestMsgDestructTime); err != nil {
+		if err := c.setConversationMinSeqAndLatestMsgDestructTime(ctx, conversation.ConversationID, conversation.OwnerUserID, seq, latestMsgDestructTime); err != nil {
 			return nil, err
 		}
-		log.ZDebug(ctx, "ClearUserConversationMsg set min seq", "index", i, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID, "seq", resp.Seq, "msgDestructTime", conversation.MsgDestructTime)
+		log.ZDebug(ctx, "ClearUserConversationMsg set min seq", "index", i, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID, "seq", seq, "msgDestructTime", conversation.MsgDestructTime)
 	}
 	return &pbconversation.ClearUserConversationMsgResp{Count: int32(len(conversations))}, nil
 }
@@ -788,8 +799,7 @@ func (c *conversationServer) setConversationMinSeqAndLatestMsgDestructTime(ctx c
 		"latest_msg_destruct_time": latestMsgDestructTime,
 	}
 	if minSeq >= 0 {
-		req := &pbmsg.SetUserConversationMinSeqReq{ConversationID: conversationID, OwnerUserID: []string{ownerUserID}, MinSeq: minSeq}
+		if err := c.msgClient.SetUserConversationMin(ctx, conversationID, []string{ownerUserID}, minSeq); err != nil {
-		if _, err := pbmsg.SetUserConversationMinSeqCaller.Invoke(ctx, req); err != nil {
 			return err
 		}
 		update["min_seq"] = minSeq

internal/rpc/conversation/notification.go

@@ -16,9 +16,11 @@ package conversation
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/protocol/msg"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/sdkws"
 )
@@ -27,8 +29,10 @@ type ConversationNotificationSender struct {
 	*rpcclient.NotificationSender
 }
 
-func NewConversationNotificationSender(conf *config.Notification, msgRpcClient *rpcclient.MessageRpcClient) *ConversationNotificationSender {
+func NewConversationNotificationSender(conf *config.Notification, msgClient *rpcli.MsgClient) *ConversationNotificationSender {
-	return &ConversationNotificationSender{rpcclient.NewNotificationSender(conf, rpcclient.WithRpcClient(msgRpcClient))}
+	return &ConversationNotificationSender{rpcclient.NewNotificationSender(conf, rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+		return msgClient.SendMsg(ctx, req)
+	}))}
 }
 
 // SetPrivate invote.

internal/rpc/group/group.go

@@ -17,6 +17,7 @@ package group
 import (
 	"context"
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"math/big"
 	"math/rand"
 	"strconv"
@@ -36,9 +37,7 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification/grouphash"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient/grouphash"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient/notification"
 	"github.com/openimsdk/protocol/constant"
 	pbconversation "github.com/openimsdk/protocol/conversation"
 	pbgroup "github.com/openimsdk/protocol/group"
@@ -58,13 +57,13 @@ import (
 
 type groupServer struct {
 	pbgroup.UnimplementedGroupServer
-	db                    controller.GroupDatabase
+	db                 controller.GroupDatabase
-	user                  rpcclient.UserRpcClient
+	notification       *NotificationSender
-	notification          *GroupNotificationSender
+	config             *Config
-	conversationRpcClient rpcclient.ConversationRpcClient
+	webhookClient      *webhook.Client
-	msgRpcClient          rpcclient.MessageRpcClient
+	userClient         *rpcli.UserClient
-	config                *Config
+	msgClient          *rpcli.MsgClient
-	webhookClient         *webhook.Client
+	conversationClient *rpcli.ConversationClient
 }
 
 type Config struct {
@@ -99,32 +98,33 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	if err != nil {
 		return err
 	}
-	userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
+
-	msgRpcClient := rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
+	//userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
-	conversationRpcClient := rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation)
+	//msgRpcClient := rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
-	var gs groupServer
+	//conversationRpcClient := rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation)
-	database := controller.NewGroupDatabase(rdb, &config.LocalCacheConfig, groupDB, groupMemberDB, groupRequestDB, mgocli.GetTx(), grouphash.NewGroupHashFromGroupServer(&gs))
+
-	gs.db = database
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
-	gs.user = userRpcClient
+	if err != nil {
-	gs.notification = NewGroupNotificationSender(
+		return err
-		database,
+	}
-		&msgRpcClient,
+	msgConn, err := client.GetConn(ctx, config.Discovery.RpcService.Msg)
-		&userRpcClient,
+	if err != nil {
-		&conversationRpcClient,
+		return err
-		config,
+	}
-		func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error) {
+	conversationConn, err := client.GetConn(ctx, config.Discovery.RpcService.Conversation)
-			users, err := userRpcClient.GetUsersInfo(ctx, userIDs)
+	if err != nil {
-			if err != nil {
+		return err
-				return nil, err
+	}
-			}
+	gs := groupServer{
-			return datautil.Slice(users, func(e *sdkws.UserInfo) notification.CommonUser { return e }), nil
+		config:             config,
-		},
+		webhookClient:      webhook.NewWebhookClient(config.WebhooksConfig.URL),
-	)
+		userClient:         rpcli.NewUserClient(userConn),
+		msgClient:          rpcli.NewMsgClient(msgConn),
+		conversationClient: rpcli.NewConversationClient(conversationConn),
+	}
+	gs.db = controller.NewGroupDatabase(rdb, &config.LocalCacheConfig, groupDB, groupMemberDB, groupRequestDB, mgocli.GetTx(), grouphash.NewGroupHashFromGroupServer(&gs))
+	gs.notification = NewNotificationSender(gs.db, config, gs.userClient, gs.msgClient, gs.conversationClient)
 	localcache.InitLocalCache(&config.LocalCacheConfig)
-	gs.conversationRpcClient = conversationRpcClient
-	gs.msgRpcClient = msgRpcClient
-	gs.config = config
-	gs.webhookClient = webhook.NewWebhookClient(config.WebhooksConfig.URL)
 	pbgroup.RegisterGroupServer(server, &gs)
 	return nil
 }
@@ -168,19 +168,6 @@ func (g *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
 	return nil
 }
 
-func (g *groupServer) GetPublicUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.PublicUserInfo, error) {
-	if len(userIDs) == 0 {
-		return map[string]*sdkws.PublicUserInfo{}, nil
-	}
-	users, err := g.user.GetPublicUserInfos(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	return datautil.SliceToMapAny(users, func(e *sdkws.PublicUserInfo) (string, *sdkws.PublicUserInfo) {
-		return e.UserID, e
-	}), nil
-}
-
 func (g *groupServer) IsNotFound(err error) bool {
 	return errs.ErrRecordNotFound.Is(specialerror.ErrCode(errs.Unwrap(err)))
 }
@@ -222,7 +209,6 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		return nil, errs.ErrArgs.WrapMsg("no group owner")
 	}
 	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, g.config.Share.IMAdminUserID); err != nil {
-
 		return nil, err
 	}
 	userIDs := append(append(req.MemberUserIDs, req.AdminUserIDs...), req.OwnerUserID)
@@ -235,7 +221,7 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		return nil, errs.ErrArgs.WrapMsg("group member repeated")
 	}
 
-	userMap, err := g.user.GetUsersInfoMap(ctx, userIDs)
+	userMap, err := g.userClient.GetUsersInfoMap(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -386,7 +372,7 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 		return nil, servererrs.ErrDismissedAlready.WrapMsg("group dismissed checking group status found it dismissed")
 	}
 
-	userMap, err := g.user.GetUsersInfoMap(ctx, req.InvitedUserIDs)
+	userMap, err := g.userClient.GetUsersInfoMap(ctx, req.InvitedUserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -697,7 +683,7 @@ func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 		userIDs = append(userIDs, gr.UserID)
 	}
 	userIDs = datautil.Distinct(userIDs)
-	userMap, err := g.user.GetPublicUserInfoMap(ctx, userIDs)
+	userMap, err := g.userClient.GetUsersInfoMap(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -809,7 +795,7 @@ func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 	} else if !g.IsNotFound(err) {
 		return nil, err
 	}
-	if _, err := g.user.GetPublicUserInfo(ctx, req.FromUserID); err != nil {
+	if err := g.userClient.CheckUser(ctx, []string{req.FromUserID}); err != nil {
 		return nil, err
 	}
 	var member *model.GroupMember
@@ -853,7 +839,7 @@ func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 }
 
 func (g *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq) (*pbgroup.JoinGroupResp, error) {
-	user, err := g.user.GetUserInfo(ctx, req.InviterUserID)
+	user, err := g.userClient.GetUserInfo(ctx, req.InviterUserID)
 	if err != nil {
 		return nil, err
 	}
@@ -959,12 +945,12 @@ func (g *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq)
 }
 
 func (g *groupServer) deleteMemberAndSetConversationSeq(ctx context.Context, groupID string, userIDs []string) error {
-	conevrsationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
+	conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
-	maxSeq, err := g.msgRpcClient.GetConversationMaxSeq(ctx, conevrsationID)
+	maxSeq, err := g.msgClient.GetConversationMaxSeq(ctx, conversationID)
 	if err != nil {
 		return err
 	}
-	return g.conversationRpcClient.SetConversationMaxSeq(ctx, userIDs, conevrsationID, maxSeq)
+	return g.conversationClient.SetConversationMaxSeq(ctx, conversationID, userIDs, maxSeq)
 }
 
 func (g *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInfoReq) (*pbgroup.SetGroupInfoResp, error) {
@@ -1040,7 +1026,7 @@ func (g *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 				return
 			}
 			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.GroupNotification}
-			if err := g.conversationRpcClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
+			if err := g.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
 				log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
 			}
 		}()
@@ -1153,8 +1139,7 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 				}
 
 				conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.GroupNotification}
-
+				if err := g.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
-				if err := g.conversationRpcClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
 					log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
 				}
 			}()
@@ -1306,7 +1291,7 @@ func (g *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbgroup.GetGr
 }
 
 func (g *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgroup.GetUserReqApplicationListReq) (*pbgroup.GetUserReqApplicationListResp, error) {
-	user, err := g.user.GetPublicUserInfo(ctx, req.UserID)
+	user, err := g.userClient.GetUserInfo(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -1762,7 +1747,7 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 		return nil, servererrs.ErrGroupIDNotFound.WrapMsg(strings.Join(ids, ","))
 	}
 
-	userMap, err := g.user.GetPublicUserInfoMap(ctx, req.UserIDs)
+	userMap, err := g.userClient.GetUsersInfoMap(ctx, req.UserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1793,7 +1778,7 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 				ownerUserID = owner.UserID
 			}
 
-			var userInfo *sdkws.PublicUserInfo
+			var userInfo *sdkws.UserInfo
 			if user, ok := userMap[e.UserID]; !ok {
 				userInfo = user
 			}
@@ -1839,7 +1824,7 @@ func (g *groupServer) GetSpecifiedUserGroupRequestInfo(ctx context.Context, req
 		return nil, err
 	}
 
-	userInfos, err := g.user.GetPublicUserInfos(ctx, []string{req.UserID})
+	userInfos, err := g.userClient.GetUsersInfo(ctx, []string{req.UserID})
 	if err != nil {
 		return nil, err
 	}

internal/rpc/group/notification.go

@@ -18,6 +18,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"time"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
@@ -26,8 +29,8 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/versionctx"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient/notification"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification/common_user"
 	"github.com/openimsdk/protocol/constant"
 	pbgroup "github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/msg"
@@ -47,36 +50,38 @@ const (
 	adminReceiver
 )
 
-func NewGroupNotificationSender(
+func NewNotificationSender(db controller.GroupDatabase, config *Config, userClient *rpcli.UserClient, msgClient *rpcli.MsgClient, conversationClient *rpcli.ConversationClient) *NotificationSender {
-	db controller.GroupDatabase,
+	return &NotificationSender{
-	msgRpcClient *rpcclient.MessageRpcClient,
+		NotificationSender: rpcclient.NewNotificationSender(&config.NotificationConfig,
-	userRpcClient *rpcclient.UserRpcClient,
+			rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
-	conversationRpcClient *rpcclient.ConversationRpcClient,
+				return msgClient.SendMsg(ctx, req)
-	config *Config,
+			}),
-	fn func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error),
+			rpcclient.WithUserRpcClient(userClient.GetUserInfo),
-) *GroupNotificationSender {
+		),
-	return &GroupNotificationSender{
+		getUsersInfo: func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error) {
-		NotificationSender: rpcclient.NewNotificationSender(&config.NotificationConfig, rpcclient.WithRpcClient(msgRpcClient), rpcclient.WithUserRpcClient(userRpcClient)),
+			users, err := userClient.GetUsersInfo(ctx, userIDs)
-		getUsersInfo:       fn,
+			if err != nil {
+				return nil, err
+			}
+			return datautil.Slice(users, func(e *sdkws.UserInfo) common_user.CommonUser { return e }), nil
+		},
 		db:                 db,
 		config:             config,
-
+		msgClient:          msgClient,
-		conversationRpcClient: conversationRpcClient,
+		conversationClient: conversationClient,
-		msgRpcClient:          msgRpcClient,
 	}
 }
 
-type GroupNotificationSender struct {
+type NotificationSender struct {
 	*rpcclient.NotificationSender
-	getUsersInfo func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error)
+	getUsersInfo       func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error)
-	db           controller.GroupDatabase
+	db                 controller.GroupDatabase
-	config       *Config
+	config             *Config
-
+	msgClient          *rpcli.MsgClient
-	conversationRpcClient *rpcclient.ConversationRpcClient
+	conversationClient *rpcli.ConversationClient
-	msgRpcClient          *rpcclient.MessageRpcClient
 }
 
-func (g *GroupNotificationSender) PopulateGroupMember(ctx context.Context, members ...*model.GroupMember) error {
+func (g *NotificationSender) PopulateGroupMember(ctx context.Context, members ...*model.GroupMember) error {
 	if len(members) == 0 {
 		return nil
 	}
@@ -91,7 +96,7 @@ func (g *GroupNotificationSender) PopulateGroupMember(ctx context.Context, membe
 		if err != nil {
 			return err
 		}
-		userMap := make(map[string]notification.CommonUser)
+		userMap := make(map[string]common_user.CommonUser)
 		for i, user := range users {
 			userMap[user.GetUserID()] = users[i]
 		}
@@ -111,7 +116,7 @@ func (g *GroupNotificationSender) PopulateGroupMember(ctx context.Context, membe
 	return nil
 }
 
-func (g *GroupNotificationSender) getUser(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
+func (g *NotificationSender) getUser(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
 	users, err := g.getUsersInfo(ctx, []string{userID})
 	if err != nil {
 		return nil, err
@@ -127,7 +132,7 @@ func (g *GroupNotificationSender) getUser(ctx context.Context, userID string) (*
 	}, nil
 }
 
-func (g *GroupNotificationSender) getGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+func (g *NotificationSender) getGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
 	gm, err := g.db.TakeGroup(ctx, groupID)
 	if err != nil {
 		return nil, err
@@ -148,7 +153,7 @@ func (g *GroupNotificationSender) getGroupInfo(ctx context.Context, groupID stri
 	return convert.Db2PbGroupInfo(gm, ownerUserID, num), nil
 }
 
-func (g *GroupNotificationSender) getGroupMembers(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) {
+func (g *NotificationSender) getGroupMembers(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) {
 	members, err := g.db.FindGroupMembers(ctx, groupID, userIDs)
 	if err != nil {
 		return nil, err
@@ -164,7 +169,7 @@ func (g *GroupNotificationSender) getGroupMembers(ctx context.Context, groupID s
 	return res, nil
 }
 
-func (g *GroupNotificationSender) getGroupMemberMap(ctx context.Context, groupID string, userIDs []string) (map[string]*sdkws.GroupMemberFullInfo, error) {
+func (g *NotificationSender) getGroupMemberMap(ctx context.Context, groupID string, userIDs []string) (map[string]*sdkws.GroupMemberFullInfo, error) {
 	members, err := g.getGroupMembers(ctx, groupID, userIDs)
 	if err != nil {
 		return nil, err
@@ -176,7 +181,7 @@ func (g *GroupNotificationSender) getGroupMemberMap(ctx context.Context, groupID
 	return m, nil
 }
 
-func (g *GroupNotificationSender) getGroupMember(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
+func (g *NotificationSender) getGroupMember(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
 	members, err := g.getGroupMembers(ctx, groupID, []string{userID})
 	if err != nil {
 		return nil, err
@@ -187,7 +192,7 @@ func (g *GroupNotificationSender) getGroupMember(ctx context.Context, groupID st
 	return members[0], nil
 }
 
-func (g *GroupNotificationSender) getGroupOwnerAndAdminUserID(ctx context.Context, groupID string) ([]string, error) {
+func (g *NotificationSender) getGroupOwnerAndAdminUserID(ctx context.Context, groupID string) ([]string, error) {
 	members, err := g.db.FindGroupMemberRoleLevels(ctx, groupID, []int32{constant.GroupOwner, constant.GroupAdmin})
 	if err != nil {
 		return nil, err
@@ -199,7 +204,7 @@ func (g *GroupNotificationSender) getGroupOwnerAndAdminUserID(ctx context.Contex
 	return datautil.Slice(members, fn), nil
 }
 
-func (g *GroupNotificationSender) groupMemberDB2PB(member *model.GroupMember, appMangerLevel int32) *sdkws.GroupMemberFullInfo {
+func (g *NotificationSender) groupMemberDB2PB(member *model.GroupMember, appMangerLevel int32) *sdkws.GroupMemberFullInfo {
 	return &sdkws.GroupMemberFullInfo{
 		GroupID:        member.GroupID,
 		UserID:         member.UserID,
@@ -216,7 +221,7 @@ func (g *GroupNotificationSender) groupMemberDB2PB(member *model.GroupMember, ap
 	}
 }
 
-/* func (g *GroupNotificationSender) getUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
+/* func (g *NotificationSender) getUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
 	users, err := g.getUsersInfo(ctx, userIDs)
 	if err != nil {
 		return nil, err
@@ -228,11 +233,11 @@ func (g *GroupNotificationSender) groupMemberDB2PB(member *model.GroupMember, ap
 	return result, nil
 } */
 
-func (g *GroupNotificationSender) fillOpUser(ctx context.Context, opUser **sdkws.GroupMemberFullInfo, groupID string) (err error) {
+func (g *NotificationSender) fillOpUser(ctx context.Context, opUser **sdkws.GroupMemberFullInfo, groupID string) (err error) {
 	return g.fillOpUserByUserID(ctx, mcontext.GetOpUserID(ctx), opUser, groupID)
 }
 
-func (g *GroupNotificationSender) fillOpUserByUserID(ctx context.Context, userID string, opUser **sdkws.GroupMemberFullInfo, groupID string) error {
+func (g *NotificationSender) fillOpUserByUserID(ctx context.Context, userID string, opUser **sdkws.GroupMemberFullInfo, groupID string) error {
 	if opUser == nil {
 		return errs.ErrInternalServer.WrapMsg("**sdkws.GroupMemberFullInfo is nil")
 	}
@@ -276,7 +281,7 @@ func (g *GroupNotificationSender) fillOpUserByUserID(ctx context.Context, userID
 	return nil
 }
 
-func (g *GroupNotificationSender) setVersion(ctx context.Context, version *uint64, versionID *string, collName string, id string) {
+func (g *NotificationSender) setVersion(ctx context.Context, version *uint64, versionID *string, collName string, id string) {
 	versions := versionctx.GetVersionLog(ctx).Get()
 	for _, coll := range versions {
 		if coll.Name == collName && coll.Doc.DID == id {
@@ -287,7 +292,7 @@ func (g *GroupNotificationSender) setVersion(ctx context.Context, version *uint6
 	}
 }
 
-func (g *GroupNotificationSender) setSortVersion(ctx context.Context, version *uint64, versionID *string, collName string, id string, sortVersion *uint64) {
+func (g *NotificationSender) setSortVersion(ctx context.Context, version *uint64, versionID *string, collName string, id string, sortVersion *uint64) {
 	versions := versionctx.GetVersionLog(ctx).Get()
 	for _, coll := range versions {
 		if coll.Name == collName && coll.Doc.DID == id {
@@ -302,7 +307,7 @@ func (g *GroupNotificationSender) setSortVersion(ctx context.Context, version *u
 	}
 }
 
-func (g *GroupNotificationSender) GroupCreatedNotification(ctx context.Context, tips *sdkws.GroupCreatedTips) {
+func (g *NotificationSender) GroupCreatedNotification(ctx context.Context, tips *sdkws.GroupCreatedTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -316,7 +321,7 @@ func (g *GroupNotificationSender) GroupCreatedNotification(ctx context.Context,
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupCreatedNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupInfoSetNotification(ctx context.Context, tips *sdkws.GroupInfoSetTips) {
+func (g *NotificationSender) GroupInfoSetNotification(ctx context.Context, tips *sdkws.GroupInfoSetTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -330,7 +335,7 @@ func (g *GroupNotificationSender) GroupInfoSetNotification(ctx context.Context,
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetNotification, tips, rpcclient.WithRpcGetUserName())
 }
 
-func (g *GroupNotificationSender) GroupInfoSetNameNotification(ctx context.Context, tips *sdkws.GroupInfoSetNameTips) {
+func (g *NotificationSender) GroupInfoSetNameNotification(ctx context.Context, tips *sdkws.GroupInfoSetNameTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -344,7 +349,7 @@ func (g *GroupNotificationSender) GroupInfoSetNameNotification(ctx context.Conte
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetNameNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupInfoSetAnnouncementNotification(ctx context.Context, tips *sdkws.GroupInfoSetAnnouncementTips) {
+func (g *NotificationSender) GroupInfoSetAnnouncementNotification(ctx context.Context, tips *sdkws.GroupInfoSetAnnouncementTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -358,7 +363,7 @@ func (g *GroupNotificationSender) GroupInfoSetAnnouncementNotification(ctx conte
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetAnnouncementNotification, tips, rpcclient.WithRpcGetUserName())
 }
 
-func (g *GroupNotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbgroup.JoinGroupReq) {
+func (g *NotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbgroup.JoinGroupReq) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -386,7 +391,7 @@ func (g *GroupNotificationSender) JoinGroupApplicationNotification(ctx context.C
 	}
 }
 
-func (g *GroupNotificationSender) MemberQuitNotification(ctx context.Context, member *sdkws.GroupMemberFullInfo) {
+func (g *NotificationSender) MemberQuitNotification(ctx context.Context, member *sdkws.GroupMemberFullInfo) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -403,7 +408,7 @@ func (g *GroupNotificationSender) MemberQuitNotification(ctx context.Context, me
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), member.GroupID, constant.MemberQuitNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupApplicationAcceptedNotification(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) {
+func (g *NotificationSender) GroupApplicationAcceptedNotification(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -436,7 +441,7 @@ func (g *GroupNotificationSender) GroupApplicationAcceptedNotification(ctx conte
 	}
 }
 
-func (g *GroupNotificationSender) GroupApplicationRejectedNotification(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) {
+func (g *NotificationSender) GroupApplicationRejectedNotification(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -469,7 +474,7 @@ func (g *GroupNotificationSender) GroupApplicationRejectedNotification(ctx conte
 	}
 }
 
-func (g *GroupNotificationSender) GroupOwnerTransferredNotification(ctx context.Context, req *pbgroup.TransferGroupOwnerReq) {
+func (g *NotificationSender) GroupOwnerTransferredNotification(ctx context.Context, req *pbgroup.TransferGroupOwnerReq) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -500,7 +505,7 @@ func (g *GroupNotificationSender) GroupOwnerTransferredNotification(ctx context.
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupOwnerTransferredNotification, tips)
 }
 
-func (g *GroupNotificationSender) MemberKickedNotification(ctx context.Context, tips *sdkws.MemberKickedTips) {
+func (g *NotificationSender) MemberKickedNotification(ctx context.Context, tips *sdkws.MemberKickedTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -514,7 +519,7 @@ func (g *GroupNotificationSender) MemberKickedNotification(ctx context.Context,
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.MemberKickedNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupApplicationAgreeMemberEnterNotification(ctx context.Context, groupID string, invitedOpUserID string, entrantUserID ...string) error {
+func (g *NotificationSender) GroupApplicationAgreeMemberEnterNotification(ctx context.Context, groupID string, invitedOpUserID string, entrantUserID ...string) error {
 	var err error
 	defer func() {
 		if err != nil {
@@ -524,20 +529,15 @@ func (g *GroupNotificationSender) GroupApplicationAgreeMemberEnterNotification(c
 
 	if !g.config.RpcConfig.EnableHistoryForNewMembers {
 		conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
-		maxSeq, err := g.msgRpcClient.GetConversationMaxSeq(ctx, conversationID)
+		maxSeq, err := g.msgClient.GetConversationMaxSeq(ctx, conversationID)
 		if err != nil {
 			return err
 		}
-		if _, err = g.msgRpcClient.SetUserConversationsMinSeq(ctx, &msg.SetUserConversationsMinSeqReq{
+		if err := g.msgClient.SetUserConversationsMinSeq(ctx, conversationID, entrantUserID, maxSeq); err != nil {
-			UserIDs:        entrantUserID,
-			ConversationID: conversationID,
-			Seq:            maxSeq,
-		}); err != nil {
 			return err
 		}
 	}
-
+	if err := g.conversationClient.CreateGroupChatConversations(ctx, groupID, entrantUserID); err != nil {
-	if err := g.conversationRpcClient.GroupChatFirstCreateConversation(ctx, groupID, entrantUserID); err != nil {
 		return err
 	}
 
@@ -573,7 +573,7 @@ func (g *GroupNotificationSender) GroupApplicationAgreeMemberEnterNotification(c
 	return nil
 }
 
-func (g *GroupNotificationSender) MemberEnterNotification(ctx context.Context, groupID string, entrantUserID string) error {
+func (g *NotificationSender) MemberEnterNotification(ctx context.Context, groupID string, entrantUserID string) error {
 	var err error
 	defer func() {
 		if err != nil {
@@ -583,23 +583,17 @@ func (g *GroupNotificationSender) MemberEnterNotification(ctx context.Context, g
 
 	if !g.config.RpcConfig.EnableHistoryForNewMembers {
 		conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
-		maxSeq, err := g.msgRpcClient.GetConversationMaxSeq(ctx, conversationID)
+		maxSeq, err := g.msgClient.GetConversationMaxSeq(ctx, conversationID)
 		if err != nil {
 			return err
 		}
-		if _, err = g.msgRpcClient.SetUserConversationsMinSeq(ctx, &msg.SetUserConversationsMinSeqReq{
+		if err := g.msgClient.SetUserConversationsMinSeq(ctx, conversationID, []string{entrantUserID}, maxSeq); err != nil {
-			UserIDs:        []string{entrantUserID},
-			ConversationID: conversationID,
-			Seq:            maxSeq,
-		}); err != nil {
 			return err
 		}
 	}
-
+	if err := g.conversationClient.CreateGroupChatConversations(ctx, groupID, []string{entrantUserID}); err != nil {
-	if err := g.conversationRpcClient.GroupChatFirstCreateConversation(ctx, groupID, []string{entrantUserID}); err != nil {
 		return err
 	}
-
 	var group *sdkws.GroupInfo
 	group, err = g.getGroupInfo(ctx, groupID)
 	if err != nil {
@@ -620,7 +614,7 @@ func (g *GroupNotificationSender) MemberEnterNotification(ctx context.Context, g
 	return nil
 }
 
-func (g *GroupNotificationSender) GroupDismissedNotification(ctx context.Context, tips *sdkws.GroupDismissedTips) {
+func (g *NotificationSender) GroupDismissedNotification(ctx context.Context, tips *sdkws.GroupDismissedTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -633,7 +627,7 @@ func (g *GroupNotificationSender) GroupDismissedNotification(ctx context.Context
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupDismissedNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupMemberMutedNotification(ctx context.Context, groupID, groupMemberUserID string, mutedSeconds uint32) {
+func (g *NotificationSender) GroupMemberMutedNotification(ctx context.Context, groupID, groupMemberUserID string, mutedSeconds uint32) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -661,7 +655,7 @@ func (g *GroupNotificationSender) GroupMemberMutedNotification(ctx context.Conte
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberMutedNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupMemberCancelMutedNotification(ctx context.Context, groupID, groupMemberUserID string) {
+func (g *NotificationSender) GroupMemberCancelMutedNotification(ctx context.Context, groupID, groupMemberUserID string) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -686,7 +680,7 @@ func (g *GroupNotificationSender) GroupMemberCancelMutedNotification(ctx context
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberCancelMutedNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupMutedNotification(ctx context.Context, groupID string) {
+func (g *NotificationSender) GroupMutedNotification(ctx context.Context, groupID string) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -714,7 +708,7 @@ func (g *GroupNotificationSender) GroupMutedNotification(ctx context.Context, gr
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMutedNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupCancelMutedNotification(ctx context.Context, groupID string) {
+func (g *NotificationSender) GroupCancelMutedNotification(ctx context.Context, groupID string) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -742,7 +736,7 @@ func (g *GroupNotificationSender) GroupCancelMutedNotification(ctx context.Conte
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupCancelMutedNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupMemberInfoSetNotification(ctx context.Context, groupID, groupMemberUserID string) {
+func (g *NotificationSender) GroupMemberInfoSetNotification(ctx context.Context, groupID, groupMemberUserID string) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -767,7 +761,7 @@ func (g *GroupNotificationSender) GroupMemberInfoSetNotification(ctx context.Con
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberInfoSetNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupMemberSetToAdminNotification(ctx context.Context, groupID, groupMemberUserID string) {
+func (g *NotificationSender) GroupMemberSetToAdminNotification(ctx context.Context, groupID, groupMemberUserID string) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -791,7 +785,7 @@ func (g *GroupNotificationSender) GroupMemberSetToAdminNotification(ctx context.
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberSetToAdminNotification, tips)
 }
 
-func (g *GroupNotificationSender) GroupMemberSetToOrdinaryUserNotification(ctx context.Context, groupID, groupMemberUserID string) {
+func (g *NotificationSender) GroupMemberSetToOrdinaryUserNotification(ctx context.Context, groupID, groupMemberUserID string) {
 	var err error
 	defer func() {
 		if err != nil {

internal/rpc/msg/clear.go

@@ -2,23 +2,13 @@ package msg
 
 import (
 	"context"
-	"strings"
-	"time"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
-	pbconversation "github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/msg"
-	"github.com/openimsdk/protocol/wrapperspb"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/mcontext"
+	"strings"
-	"github.com/openimsdk/tools/utils/datautil"
-	"github.com/openimsdk/tools/utils/idutil"
-	"github.com/openimsdk/tools/utils/stringutil"
-	"golang.org/x/sync/errgroup"
 )
 
-// hard delete in Database.
+// DestructMsgs hard delete in Database.
 func (m *msgServer) DestructMsgs(ctx context.Context, req *msg.DestructMsgsReq) (*msg.DestructMsgsResp, error) {
 	if err := authverify.CheckAdmin(ctx, m.config.Share.IMAdminUserID); err != nil {
 		return nil, err
@@ -61,67 +51,6 @@ func (m *msgServer) DestructMsgs(ctx context.Context, req *msg.DestructMsgsReq)
 	return &msg.DestructMsgsResp{Count: int32(len(docs))}, nil
 }
 
-// soft delete for user self
-func (m *msgServer) ClearMsg(ctx context.Context, req *msg.ClearMsgReq) (*msg.ClearMsgResp, error) {
-	temp := convert.ConversationsPb2DB(req.Conversations)
-
-	batchNum := 100
-
-	errg, _ := errgroup.WithContext(ctx)
-	errg.SetLimit(100)
-
-	for i := 0; i < len(temp); i += batchNum {
-		batch := temp[i:min(i+batchNum, len(temp))]
-
-		errg.Go(func() error {
-			for _, conversation := range batch {
-				handleCtx := mcontext.NewCtx(stringutil.GetSelfFuncName() + "-" + idutil.OperationIDGenerator() + "-" + conversation.ConversationID + "-" + conversation.OwnerUserID)
-				log.ZDebug(handleCtx, "User MsgsDestruct",
-					"conversationID", conversation.ConversationID,
-					"ownerUserID", conversation.OwnerUserID,
-					"msgDestructTime", conversation.MsgDestructTime,
-					"lastMsgDestructTime", conversation.LatestMsgDestructTime)
-
-				seqs, err := m.MsgDatabase.ClearUserMsgs(handleCtx, conversation.OwnerUserID, conversation.ConversationID, conversation.MsgDestructTime, conversation.LatestMsgDestructTime)
-				if err != nil {
-					log.ZError(handleCtx, "user msg destruct failed", err, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID)
-					continue
-				}
-
-				if len(seqs) > 0 {
-					minseq := datautil.Max(seqs...)
-
-					// update
-					if err := m.Conversation.UpdateConversation(handleCtx,
-						&pbconversation.UpdateConversationReq{
-							UserIDs:               []string{conversation.OwnerUserID},
-							ConversationID:        conversation.ConversationID,
-							LatestMsgDestructTime: wrapperspb.Int64(time.Now().UnixMilli()),
-							MinSeq:                wrapperspb.Int64(minseq),
-						}); err != nil {
-						log.ZError(handleCtx, "updateUsersConversationField failed", err, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID)
-						continue
-					}
-
-					if err := m.Conversation.SetConversationMinSeq(handleCtx, []string{conversation.OwnerUserID}, conversation.ConversationID, minseq); err != nil {
-						return err
-					}
-
-					// if you need Notify SDK client userseq is update.
-					// m.msgNotificationSender.UserDeleteMsgsNotification(handleCtx, conversation.OwnerUserID, conversation.ConversationID, seqs)
-				}
-			}
-			return nil
-		})
-	}
-
-	if err := errg.Wait(); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
 func (m *msgServer) GetLastMessageSeqByTime(ctx context.Context, req *msg.GetLastMessageSeqByTimeReq) (*msg.GetLastMessageSeqByTimeResp, error) {
 	seq, err := m.MsgDatabase.GetLastMessageSeqByTime(ctx, req.ConversationID, req.Time)
 	if err != nil {

internal/rpc/msg/delete.go

@@ -74,19 +74,13 @@ func (m *msgServer) DeleteMsgs(ctx context.Context, req *msg.DeleteMsgsReq) (*ms
 		if err := m.MsgDatabase.DeleteMsgsPhysicalBySeqs(ctx, req.ConversationID, req.Seqs); err != nil {
 			return nil, err
 		}
-		conversations, err := m.Conversation.GetConversationsByConversationID(ctx, []string{req.ConversationID})
+		conv, err := m.conversationClient.GetConversationsByConversationID(ctx, req.ConversationID)
 		if err != nil {
 			return nil, err
 		}
 		tips := &sdkws.DeleteMsgsTips{UserID: req.UserID, ConversationID: req.ConversationID, Seqs: req.Seqs}
-		m.notificationSender.NotificationWithSessionType(
+		m.notificationSender.NotificationWithSessionType(ctx, req.UserID, m.conversationAndGetRecvID(conv, req.UserID),
-			ctx,
+			constant.DeleteMsgsNotification, conv.ConversationType, tips)
-			req.UserID,
-			m.conversationAndGetRecvID(conversations[0], req.UserID),
-			constant.DeleteMsgsNotification,
-			conversations[0].ConversationType,
-			tips,
-		)
 	} else {
 		if err := m.MsgDatabase.DeleteUserMsgsBySeqs(ctx, req.UserID, req.ConversationID, req.Seqs); err != nil {
 			return nil, err
@@ -121,7 +115,7 @@ func (m *msgServer) DeleteMsgPhysical(ctx context.Context, req *msg.DeleteMsgPhy
 }
 
 func (m *msgServer) clearConversation(ctx context.Context, conversationIDs []string, userID string, deleteSyncOpt *msg.DeleteSyncOpt) error {
-	conversations, err := m.Conversation.GetConversationsByConversationID(ctx, conversationIDs)
+	conversations, err := m.conversationClient.GetConversationsByConversationIDs(ctx, conversationIDs)
 	if err != nil {
 		return err
 	}
@@ -144,7 +138,7 @@ func (m *msgServer) clearConversation(ctx context.Context, conversationIDs []str
 		}
 		ownerUserIDs := []string{userID}
 		for conversationID, seq := range setSeqs {
-			if err := m.Conversation.SetConversationMinSeq(ctx, ownerUserIDs, conversationID, seq); err != nil {
+			if err := m.conversationClient.SetConversationMinSeq(ctx, conversationID, ownerUserIDs, seq); err != nil {
 				return err
 			}
 		}

internal/rpc/msg/notification.go

@@ -17,7 +17,7 @@ package msg
 import (
 	"context"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/sdkws"
 )

internal/rpc/msg/send.go

@@ -113,19 +113,14 @@ func (m *msgServer) setConversationAtInfo(nctx context.Context, msg *sdkws.MsgDa
 			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.AtAll}
 		} else { // @Everyone and @other people
 			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.AtAllAtMe}
-
+			if err := m.conversationClient.SetConversations(ctx, atUserID, conversation); err != nil {
-			err = m.Conversation.SetConversations(ctx, atUserID, conversation)
-			if err != nil {
 				log.ZWarn(ctx, "SetConversations", err, "userID", atUserID, "conversation", conversation)
 			}
-
 			memberUserIDList = datautil.Single(atUserID, memberUserIDList)
 		}
 
 		conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.AtAll}
-
+		if err := m.conversationClient.SetConversations(ctx, memberUserIDList, conversation); err != nil {
-		err = m.Conversation.SetConversations(ctx, memberUserIDList, conversation)
-		if err != nil {
 			log.ZWarn(ctx, "SetConversations", err, "userID", memberUserIDList, "conversation", conversation)
 		}
 
@@ -133,8 +128,7 @@ func (m *msgServer) setConversationAtInfo(nctx context.Context, msg *sdkws.MsgDa
 	}
 	conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.AtMe}
 
-	err := m.Conversation.SetConversations(ctx, msg.AtUserIDList, conversation)
+	if err := m.conversationClient.SetConversations(ctx, msg.AtUserIDList, conversation); err != nil {
-	if err != nil {
 		log.ZWarn(ctx, "SetConversations", err, msg.AtUserIDList, conversation)
 	}
 }

internal/rpc/msg/server.go

@@ -16,6 +16,8 @@ package msg
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
@@ -25,8 +27,8 @@ import (
 	"github.com/openimsdk/tools/db/redisutil"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/msg"
@@ -35,39 +37,39 @@ import (
 )
 
 type MessageInterceptorFunc func(ctx context.Context, globalConfig *Config, req *msg.SendMsgReq) (*sdkws.MsgData, error)
-type (
-	// MessageInterceptorChain defines a chain of message interceptor functions.
-	MessageInterceptorChain []MessageInterceptorFunc
 
-	// MsgServer encapsulates dependencies required for message handling.
+// MessageInterceptorChain defines a chain of message interceptor functions.
-	msgServer struct {
+type MessageInterceptorChain []MessageInterceptorFunc
-		RegisterCenter         discovery.SvcDiscoveryRegistry   // Service discovery registry for service registration.
-		MsgDatabase            controller.CommonMsgDatabase     // Interface for message database operations.
-		Conversation           *rpcclient.ConversationRpcClient // RPC client for conversation service.
-		UserLocalCache         *rpccache.UserLocalCache         // Local cache for user data.
-		FriendLocalCache       *rpccache.FriendLocalCache       // Local cache for friend data.
-		GroupLocalCache        *rpccache.GroupLocalCache        // Local cache for group data.
-		ConversationLocalCache *rpccache.ConversationLocalCache // Local cache for conversation data.
-		Handlers               MessageInterceptorChain          // Chain of handlers for processing messages.
-		notificationSender     *rpcclient.NotificationSender    // RPC client for sending notifications.
-		msgNotificationSender  *MsgNotificationSender           // RPC client for sending msg notifications.
-		config                 *Config                          // Global configuration settings.
-		webhookClient          *webhook.Client
-		msg.UnimplementedMsgServer
-	}
 
-	Config struct {
+type Config struct {
-		RpcConfig          config.Msg
+	RpcConfig          config.Msg
-		RedisConfig        config.Redis
+	RedisConfig        config.Redis
-		MongodbConfig      config.Mongo
+	MongodbConfig      config.Mongo
-		KafkaConfig        config.Kafka
+	KafkaConfig        config.Kafka
-		NotificationConfig config.Notification
+	NotificationConfig config.Notification
-		Share              config.Share
+	Share              config.Share
-		WebhooksConfig     config.Webhooks
+	WebhooksConfig     config.Webhooks
-		LocalCacheConfig   config.LocalCache
+	LocalCacheConfig   config.LocalCache
-		Discovery          config.Discovery
+	Discovery          config.Discovery
-	}
+}
-)
+
+// MsgServer encapsulates dependencies required for message handling.
+type msgServer struct {
+	msg.UnimplementedMsgServer
+	RegisterCenter         discovery.SvcDiscoveryRegistry // Service discovery registry for service registration.
+	MsgDatabase            controller.CommonMsgDatabase   // Interface for message database operations.
+	StreamMsgDatabase      controller.StreamMsgDatabase
+	UserLocalCache         *rpccache.UserLocalCache         // Local cache for user data.
+	FriendLocalCache       *rpccache.FriendLocalCache       // Local cache for friend data.
+	GroupLocalCache        *rpccache.GroupLocalCache        // Local cache for group data.
+	ConversationLocalCache *rpccache.ConversationLocalCache // Local cache for conversation data.
+	Handlers               MessageInterceptorChain          // Chain of handlers for processing messages.
+	notificationSender     *rpcclient.NotificationSender    // RPC client for sending notifications.
+	msgNotificationSender  *MsgNotificationSender           // RPC client for sending msg notifications.
+	config                 *Config                          // Global configuration settings.
+	webhookClient          *webhook.Client
+	conversationClient     *rpcli.ConversationClient
+}
 
 func (m *msgServer) addInterceptorHandler(interceptorFunc ...MessageInterceptorFunc) {
 	m.Handlers = append(m.Handlers, interceptorFunc...)
@@ -106,16 +108,34 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	if err != nil {
 		return err
 	}
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
+	if err != nil {
+		return err
+	}
+	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
+	if err != nil {
+		return err
+	}
+	friendConn, err := client.GetConn(ctx, config.Discovery.RpcService.Friend)
+	if err != nil {
+		return err
+	}
+	conversationConn, err := client.GetConn(ctx, config.Discovery.RpcService.Conversation)
+	if err != nil {
+		return err
+	}
+	conversationClient := rpcli.NewConversationClient(conversationConn)
 	s := &msgServer{
 		Conversation:           &conversationClient,
 		MsgDatabase:            msgDatabase,
 		RegisterCenter:         client,
-		UserLocalCache:         rpccache.NewUserLocalCache(userRpcClient, &config.LocalCacheConfig, rdb),
+		UserLocalCache:         rpccache.NewUserLocalCache(rpcli.NewUserClient(userConn), &config.LocalCacheConfig, rdb),
-		GroupLocalCache:        rpccache.NewGroupLocalCache(groupRpcClient, &config.LocalCacheConfig, rdb),
+		GroupLocalCache:        rpccache.NewGroupLocalCache(rpcli.NewGroupClient(groupConn), &config.LocalCacheConfig, rdb),
 		ConversationLocalCache: rpccache.NewConversationLocalCache(conversationClient, &config.LocalCacheConfig, rdb),
-		FriendLocalCache:       rpccache.NewFriendLocalCache(friendRpcClient, &config.LocalCacheConfig, rdb),
+		FriendLocalCache:       rpccache.NewFriendLocalCache(rpcli.NewRelationClient(friendConn), &config.LocalCacheConfig, rdb),
 		config:                 config,
 		webhookClient:          webhook.NewWebhookClient(config.WebhooksConfig.URL),
+		conversationClient:     conversationClient,
 	}
 
 	s.notificationSender = rpcclient.NewNotificationSender(&config.NotificationConfig, rpcclient.WithLocalSendMsg(s.SendMsg))

internal/rpc/msg/stream_msg.go

@@ -0,0 +1,115 @@
+package msg
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/protocol/msg"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/errs"
+)
+
+const StreamDeadlineTime = time.Second * 60 * 10
+
+func (m *msgServer) handlerStreamMsg(ctx context.Context, msgData *sdkws.MsgData) error {
+	now := time.Now()
+	val := &model.StreamMsg{
+		ClientMsgID:    msgData.ClientMsgID,
+		ConversationID: msgprocessor.GetConversationIDByMsg(msgData),
+		UserID:         msgData.SendID,
+		CreateTime:     now,
+		DeadlineTime:   now.Add(StreamDeadlineTime),
+	}
+	return m.StreamMsgDatabase.CreateStreamMsg(ctx, val)
+}
+
+func (m *msgServer) getStreamMsg(ctx context.Context, clientMsgID string) (*model.StreamMsg, error) {
+	res, err := m.StreamMsgDatabase.GetStreamMsg(ctx, clientMsgID)
+	if err != nil {
+		return nil, err
+	}
+	now := time.Now()
+	if !res.End && res.DeadlineTime.Before(now) {
+		res.End = true
+		res.DeadlineTime = now
+		_ = m.StreamMsgDatabase.AppendStreamMsg(ctx, res.ClientMsgID, 0, nil, true, now)
+	}
+	return res, nil
+}
+
+func (m *msgServer) AppendStreamMsg(ctx context.Context, req *msg.AppendStreamMsgReq) (*msg.AppendStreamMsgResp, error) {
+	res, err := m.getStreamMsg(ctx, req.ClientMsgID)
+	if err != nil {
+		return nil, err
+	}
+	if res.End {
+		return nil, errs.ErrNoPermission.WrapMsg("stream msg is end")
+	}
+	if len(res.Packets) < int(req.StartIndex) {
+		return nil, errs.ErrNoPermission.WrapMsg("start index is invalid")
+	}
+	if val := len(res.Packets) - int(req.StartIndex); val > 0 {
+		exist := res.Packets[int(req.StartIndex):]
+		for i, s := range exist {
+			if len(req.Packets) == 0 {
+				break
+			}
+			if s != req.Packets[i] {
+				return nil, errs.ErrNoPermission.WrapMsg(fmt.Sprintf("packet %d has been written and is inconsistent", i))
+			}
+			req.StartIndex++
+			req.Packets = req.Packets[1:]
+		}
+	}
+	if len(req.Packets) == 0 && res.End == req.End {
+		return &msg.AppendStreamMsgResp{}, nil
+	}
+	deadlineTime := time.Now().Add(StreamDeadlineTime)
+	if err := m.StreamMsgDatabase.AppendStreamMsg(ctx, req.ClientMsgID, int(req.StartIndex), req.Packets, req.End, deadlineTime); err != nil {
+		return nil, err
+	}
+	conversation, err := m.conversationClient.GetConversation(ctx, res.ConversationID, res.UserID)
+	if err != nil {
+		return nil, err
+	}
+	tips := &sdkws.StreamMsgTips{
+		ConversationID: res.ConversationID,
+		ClientMsgID:    res.ClientMsgID,
+		StartIndex:     req.StartIndex,
+		Packets:        req.Packets,
+		End:            req.End,
+	}
+	var (
+		recvID      string
+		sessionType int32
+	)
+	if conversation.GroupID == "" {
+		sessionType = constant.SingleChatType
+		recvID = conversation.UserID
+	} else {
+		sessionType = constant.ReadGroupChatType
+		recvID = conversation.GroupID
+	}
+	m.msgNotificationSender.StreamMsgNotification(ctx, res.UserID, recvID, sessionType, tips)
+	return &msg.AppendStreamMsgResp{}, nil
+}
+
+func (m *msgServer) GetStreamMsg(ctx context.Context, req *msg.GetStreamMsgReq) (*msg.GetStreamMsgResp, error) {
+	res, err := m.getStreamMsg(ctx, req.ClientMsgID)
+	if err != nil {
+		return nil, err
+	}
+	return &msg.GetStreamMsgResp{
+		ClientMsgID:    res.ClientMsgID,
+		ConversationID: res.ConversationID,
+		UserID:         res.UserID,
+		Packets:        res.Packets,
+		End:            res.End,
+		CreateTime:     res.CreateTime.UnixMilli(),
+		DeadlineTime:   res.DeadlineTime.UnixMilli(),
+	}, nil
+}

internal/rpc/relation/black.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/errs"
@@ -39,7 +40,7 @@ func (s *friendServer) GetPaginationBlacks(ctx context.Context, req *relation.Ge
 		return nil, err
 	}
 	resp = &relation.GetPaginationBlacksResp{}
-	resp.Blacks, err = convert.BlackDB2Pb(ctx, blacks, s.userRpcClient.GetUsersInfoMap)
+	resp.Blacks, err = convert.BlackDB2Pb(ctx, blacks, s.userClient.GetUsersInfoMap)
 	if err != nil {
 		return nil, err
 	}
@@ -81,9 +82,7 @@ func (s *friendServer) AddBlack(ctx context.Context, req *relation.AddBlackReq)
 	if err := s.webhookBeforeAddBlack(ctx, &s.config.WebhooksConfig.BeforeAddBlack, req); err != nil {
 		return nil, err
 	}
-
+	if err := s.userClient.CheckUser(ctx, []string{req.OwnerUserID, req.BlackUserID}); err != nil {
-	_, err := s.userRpcClient.GetUsersInfo(ctx, []string{req.OwnerUserID, req.BlackUserID})
-	if err != nil {
 		return nil, err
 	}
 	black := model.Black{
@@ -114,7 +113,7 @@ func (s *friendServer) GetSpecifiedBlacks(ctx context.Context, req *relation.Get
 		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
 	}
 
-	userMap, err := s.userRpcClient.GetPublicUserInfoMap(ctx, req.UserIDList)
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.UserIDList)
 	if err != nil {
 		return nil, err
 	}
@@ -132,13 +131,26 @@ func (s *friendServer) GetSpecifiedBlacks(ctx context.Context, req *relation.Get
 		Blacks: make([]*sdkws.BlackInfo, 0, len(req.UserIDList)),
 	}
 
+	toPublcUser := func(userID string) *sdkws.PublicUserInfo {
+		v, ok := userMap[userID]
+		if !ok {
+			return nil
+		}
+		return &sdkws.PublicUserInfo{
+			UserID:   v.UserID,
+			Nickname: v.Nickname,
+			FaceURL:  v.FaceURL,
+			Ex:       v.Ex,
+		}
+	}
+
 	for _, userID := range req.UserIDList {
 		if black := blackMap[userID]; black != nil {
 			resp.Blacks = append(resp.Blacks,
 				&sdkws.BlackInfo{
 					OwnerUserID:    black.OwnerUserID,
 					CreateTime:     black.CreateTime.UnixMilli(),
-					BlackUserInfo:  userMap[userID],
+					BlackUserInfo:  toPublcUser(userID),
 					AddSource:      black.AddSource,
 					OperatorUserID: black.OperatorUserID,
 					Ex:             black.Ex,

internal/rpc/relation/friend.go

@@ -16,6 +16,7 @@ package relation
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/tools/mq/memamq"
 
@@ -31,7 +32,6 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/protocol/sdkws"
@@ -44,15 +44,14 @@ import (
 
 type friendServer struct {
 	relation.UnimplementedFriendServer
-	db                    controller.FriendDatabase
+	db                 controller.FriendDatabase
-	blackDatabase         controller.BlackDatabase
+	blackDatabase      controller.BlackDatabase
-	userRpcClient         *rpcclient.UserRpcClient
+	notificationSender *FriendNotificationSender
-	notificationSender    *FriendNotificationSender
+	RegisterCenter     discovery.SvcDiscoveryRegistry
-	conversationRpcClient rpcclient.ConversationRpcClient
+	config             *Config
-	RegisterCenter        discovery.SvcDiscoveryRegistry
+	webhookClient      *webhook.Client
-	config                *Config
+	queue              *memamq.MemoryQueue
-	webhookClient         *webhook.Client
+	userClient         *rpcli.UserClient
-	queue                 *memamq.MemoryQueue
 }
 
 type Config struct {
@@ -92,15 +91,21 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		return err
 	}
 
-	// Initialize RPC clients
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
-	userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
+	if err != nil {
-	msgRpcClient := rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
+		return err
+	}
+	msgConn, err := client.GetConn(ctx, config.Discovery.RpcService.Msg)
+	if err != nil {
+		return err
+	}
+	userClient := rpcli.NewUserClient(userConn)
 
 	// Initialize notification sender
 	notificationSender := NewFriendNotificationSender(
 		&config.NotificationConfig,
-		&msgRpcClient,
+		rpcli.NewMsgClient(msgConn),
-		WithRpcFunc(userRpcClient.GetUsersInfo),
+		WithRpcFunc(userClient.GetUsersInfo),
 	)
 	localcache.InitLocalCache(&config.LocalCacheConfig)
 
@@ -116,13 +121,12 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 			blackMongoDB,
 			redis.NewBlackCacheRedis(rdb, &config.LocalCacheConfig, blackMongoDB, redis.GetRocksCacheOptions()),
 		),
-		userRpcClient:         &userRpcClient,
+		notificationSender: notificationSender,
-		notificationSender:    notificationSender,
+		RegisterCenter:     client,
-		RegisterCenter:        client,
+		config:             config,
-		conversationRpcClient: rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation),
+		webhookClient:      webhook.NewWebhookClient(config.WebhooksConfig.URL),
-		config:                config,
+		queue:              memamq.NewMemoryQueue(16, 1024*1024),
-		webhookClient:         webhook.NewWebhookClient(config.WebhooksConfig.URL),
+		userClient:         userClient,
-		queue:                 memamq.NewMemoryQueue(16, 1024*1024),
 	})
 	return nil
 }
@@ -139,7 +143,7 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *relation.Apply
 	if err = s.webhookBeforeAddFriend(ctx, &s.config.WebhooksConfig.BeforeAddFriend, req); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
-	if _, err := s.userRpcClient.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}); err != nil {
+	if err := s.userClient.CheckUser(ctx, []string{req.ToUserID, req.FromUserID}); err != nil {
 		return nil, err
 	}
 
@@ -163,7 +167,8 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *relation.ImportFr
 	if err := authverify.CheckAdmin(ctx, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
-	if _, err := s.userRpcClient.GetUsersInfo(ctx, append([]string{req.OwnerUserID}, req.FriendUserIDs...)); err != nil {
+
+	if err := s.userClient.CheckUser(ctx, append([]string{req.OwnerUserID}, req.FriendUserIDs...)); err != nil {
 		return nil, err
 	}
 	if datautil.Contain(req.OwnerUserID, req.FriendUserIDs...) {
@@ -304,7 +309,7 @@ func (s *friendServer) getFriend(ctx context.Context, ownerUserID string, friend
 	if err != nil {
 		return nil, err
 	}
-	return convert.FriendsDB2Pb(ctx, friends, s.userRpcClient.GetUsersInfoMap)
+	return convert.FriendsDB2Pb(ctx, friends, s.userClient.GetUsersInfoMap)
 }
 
 // Get the list of friend requests sent out proactively.
@@ -316,7 +321,7 @@ func (s *friendServer) GetDesignatedFriendsApply(ctx context.Context,
 		return nil, err
 	}
 	resp = &relation.GetDesignatedFriendsApplyResp{}
-	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userRpcClient.GetUsersInfoMap)
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userClient.GetUsersInfoMap)
 	if err != nil {
 		return nil, err
 	}
@@ -335,7 +340,7 @@ func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *rel
 	}
 
 	resp = &relation.GetPaginationFriendsApplyToResp{}
-	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userRpcClient.GetUsersInfoMap)
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userClient.GetUsersInfoMap)
 	if err != nil {
 		return nil, err
 	}
@@ -357,7 +362,7 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *r
 		return nil, err
 	}
 
-	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userRpcClient.GetUsersInfoMap)
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userClient.GetUsersInfoMap)
 	if err != nil {
 		return nil, err
 	}
@@ -388,7 +393,7 @@ func (s *friendServer) GetPaginationFriends(ctx context.Context, req *relation.G
 	}
 
 	resp = &relation.GetPaginationFriendsResp{}
-	resp.FriendsInfo, err = convert.FriendsDB2Pb(ctx, friends, s.userRpcClient.GetUsersInfoMap)
+	resp.FriendsInfo, err = convert.FriendsDB2Pb(ctx, friends, s.userClient.GetUsersInfoMap)
 	if err != nil {
 		return nil, err
 	}
@@ -421,7 +426,7 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relatio
 		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
 	}
 
-	userMap, err := s.userRpcClient.GetUsersInfoMap(ctx, req.UserIDList)
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.UserIDList)
 	if err != nil {
 		return nil, err
 	}
@@ -525,18 +530,3 @@ func (s *friendServer) UpdateFriends(
 	s.notificationSender.FriendsInfoUpdateNotification(ctx, req.OwnerUserID, req.FriendUserIDs)
 	return resp, nil
 }
-
-func (s *friendServer) GetIncrementalFriendsApplyTo(ctx context.Context, req *relation.GetIncrementalFriendsApplyToReq) (*relation.GetIncrementalFriendsApplyToResp, error) {
-	// TODO implement me
-	return nil, nil
-}
-
-func (s *friendServer) GetIncrementalFriendsApplyFrom(ctx context.Context, req *relation.GetIncrementalFriendsApplyFromReq) (*relation.GetIncrementalFriendsApplyFromResp, error) {
-	// TODO implement me
-	return nil, nil
-}
-
-func (s *friendServer) GetIncrementalBlacks(ctx context.Context, req *relation.GetIncrementalBlacksReq) (*relation.GetIncrementalBlacksResp, error) {
-	// TODO implement me
-	return nil, nil
-}

internal/rpc/relation/notification.go

@@ -16,6 +16,9 @@ package relation
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/protocol/msg"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/versionctx"
 
@@ -24,8 +27,8 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient/notification"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification/common_user"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/protocol/sdkws"
@@ -35,7 +38,7 @@ import (
 type FriendNotificationSender struct {
 	*rpcclient.NotificationSender
 	// Target not found err
-	getUsersInfo func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error)
+	getUsersInfo func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error)
 	// db controller
 	db controller.FriendDatabase
 }
@@ -52,7 +55,7 @@ func WithDBFunc(
 	fn func(ctx context.Context, userIDs []string) (users []*relationtb.User, err error),
 ) friendNotificationSenderOptions {
 	return func(s *FriendNotificationSender) {
-		f := func(ctx context.Context, userIDs []string) (result []notification.CommonUser, err error) {
+		f := func(ctx context.Context, userIDs []string) (result []common_user.CommonUser, err error) {
 			users, err := fn(ctx, userIDs)
 			if err != nil {
 				return nil, err
@@ -70,7 +73,7 @@ func WithRpcFunc(
 	fn func(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error),
 ) friendNotificationSenderOptions {
 	return func(s *FriendNotificationSender) {
-		f := func(ctx context.Context, userIDs []string) (result []notification.CommonUser, err error) {
+		f := func(ctx context.Context, userIDs []string) (result []common_user.CommonUser, err error) {
 			users, err := fn(ctx, userIDs)
 			if err != nil {
 				return nil, err
@@ -84,13 +87,11 @@ func WithRpcFunc(
 	}
 }
 
-func NewFriendNotificationSender(
+func NewFriendNotificationSender(conf *config.Notification, msgClient *rpcli.MsgClient, opts ...friendNotificationSenderOptions) *FriendNotificationSender {
-	conf *config.Notification,
-	msgRpcClient *rpcclient.MessageRpcClient,
-	opts ...friendNotificationSenderOptions,
-) *FriendNotificationSender {
 	f := &FriendNotificationSender{
-		NotificationSender: rpcclient.NewNotificationSender(conf, rpcclient.WithRpcClient(msgRpcClient)),
+		NotificationSender: rpcclient.NewNotificationSender(conf, rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+			return msgClient.SendMsg(ctx, req)
+		})),
 	}
 	for _, opt := range opts {
 		opt(f)

internal/rpc/third/log.go

@@ -19,10 +19,9 @@ import (
 	"crypto/rand"
 	"time"
 
-	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/third"
 	"github.com/openimsdk/tools/errs"
@@ -149,7 +148,7 @@ func (t *thirdServer) SearchLogs(ctx context.Context, req *third.SearchLogsReq)
 	for _, log := range logs {
 		userIDs = append(userIDs, log.UserID)
 	}
-	userMap, err := t.userRpcClient.GetUsersInfoMap(ctx, userIDs)
+	userMap, err := t.userClient.GetUsersInfoMap(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}

internal/rpc/third/third.go

@@ -17,6 +17,9 @@ package third
 import (
 	"context"
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"time"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
@@ -45,6 +48,7 @@ type thirdServer struct {
 	defaultExpire time.Duration
 	config        *Config
 	s3            s3.Interface
+	userClient    *rpcli.UserClient
 }
 
 type Config struct {
@@ -96,6 +100,10 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	if err != nil {
 		return err
 	}
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
+	if err != nil {
+		return err
+	}
 	localcache.InitLocalCache(&config.LocalCacheConfig)
 	third.RegisterThirdServer(server, &thirdServer{
 		thirdDatabase: controller.NewThirdDatabase(redis.NewThirdCache(rdb), logdb),
@@ -104,6 +112,7 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		defaultExpire: time.Hour * 24 * 7,
 		config:        config,
 		s3:            o,
+		userClient:    rpcli.NewUserClient(userConn),
 	})
 	return nil
 }

internal/rpc/user/notification.go

@@ -16,18 +16,21 @@ package user
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/protocol/msg"
+
 	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient/notification"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification/common_user"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/sdkws"
 )
 
 type UserNotificationSender struct {
 	*rpcclient.NotificationSender
-	getUsersInfo func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error)
+	getUsersInfo func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error)
 	// db controller
 	db controller.UserDatabase
 }
@@ -44,7 +47,7 @@ func WithUserFunc(
 	fn func(ctx context.Context, userIDs []string) (users []*relationtb.User, err error),
 ) userNotificationSenderOptions {
 	return func(u *UserNotificationSender) {
-		f := func(ctx context.Context, userIDs []string) (result []notification.CommonUser, err error) {
+		f := func(ctx context.Context, userIDs []string) (result []common_user.CommonUser, err error) {
 			users, err := fn(ctx, userIDs)
 			if err != nil {
 				return nil, err
@@ -58,9 +61,11 @@ func WithUserFunc(
 	}
 }
 
-func NewUserNotificationSender(config *Config, msgRpcClient *rpcclient.MessageRpcClient, opts ...userNotificationSenderOptions) *UserNotificationSender {
+func NewUserNotificationSender(config *Config, msgClient *rpcli.MsgClient, opts ...userNotificationSenderOptions) *UserNotificationSender {
 	f := &UserNotificationSender{
-		NotificationSender: rpcclient.NewNotificationSender(&config.NotificationConfig, rpcclient.WithRpcClient(msgRpcClient)),
+		NotificationSender: rpcclient.NewNotificationSender(&config.NotificationConfig, rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+			return msgClient.SendMsg(ctx, req)
+		})),
 	}
 	for _, opt := range opts {
 		opt(f)

internal/rpc/user/user.go

@@ -17,6 +17,7 @@ package user
 import (
 	"context"
 	"errors"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"math/rand"
 	"strings"
 	"sync"
@@ -62,6 +63,8 @@ type userServer struct {
 	RegisterCenter           registry.SvcDiscoveryRegistry
 	config                   *Config
 	webhookClient            *webhook.Client
+	groupClient              *rpcli.GroupClient
+	relationClient           *rpcli.RelationClient
 }
 
 type Config struct {
@@ -94,6 +97,19 @@ func Start(ctx context.Context, config *Config, client registry.SvcDiscoveryRegi
 	if err != nil {
 		return err
 	}
+	msgConn, err := client.GetConn(ctx, config.Discovery.RpcService.Msg)
+	if err != nil {
+		return err
+	}
+	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
+	if err != nil {
+		return err
+	}
+	friendConn, err := client.GetConn(ctx, config.Discovery.RpcService.Friend)
+	if err != nil {
+		return err
+	}
+	msgClient := rpcli.NewMsgClient(msgConn)
 	userCache := redis.NewUserCacheRedis(rdb, &config.LocalCacheConfig, userDB, redis.GetRocksCacheOptions())
 	database := controller.NewUserDatabase(userDB, userCache, mgocli.GetTx())
 	friendRpcClient := rpcclient.NewFriendRpcClient(client, config.Share.RpcRegisterName.Friend)
@@ -104,12 +120,13 @@ func Start(ctx context.Context, config *Config, client registry.SvcDiscoveryRegi
 		online:                   redis.NewUserOnline(rdb),
 		db:                       database,
 		RegisterCenter:           client,
-		friendRpcClient:          &friendRpcClient,
+		friendNotificationSender: relation.NewFriendNotificationSender(&config.NotificationConfig, msgClient, relation.WithDBFunc(database.FindWithError)),
-		groupRpcClient:           &groupRpcClient,
+		userNotificationSender:   NewUserNotificationSender(config, msgClient, WithUserFunc(database.FindWithError)),
-		friendNotificationSender: relation.NewFriendNotificationSender(&config.NotificationConfig, &msgRpcClient, relation.WithDBFunc(database.FindWithError)),
-		userNotificationSender:   NewUserNotificationSender(config, &msgRpcClient, WithUserFunc(database.FindWithError)),
 		config:                   config,
 		webhookClient:            webhook.NewWebhookClient(config.WebhooksConfig.URL),
+
+		groupClient:    rpcli.NewGroupClient(groupConn),
+		relationClient: rpcli.NewRelationClient(friendConn),
 	}
 	pbuser.RegisterUserServer(server, u)
 	return u.db.InitOnce(context.Background(), users)
@@ -641,7 +658,7 @@ func (s *userServer) NotificationUserInfoUpdate(ctx context.Context, userID stri
 	wg.Add(len(es))
 	go func() {
 		defer wg.Done()
-		_, es[0] = s.groupRpcClient.Client.NotificationUserInfoUpdate(ctx, &group.NotificationUserInfoUpdateReq{
+		_, es[0] = s.groupClient.NotificationUserInfoUpdate(ctx, &group.NotificationUserInfoUpdateReq{
 			UserID:      userID,
 			OldUserInfo: oldUserInfo,
 			NewUserInfo: newUserInfo,
@@ -650,7 +667,7 @@ func (s *userServer) NotificationUserInfoUpdate(ctx context.Context, userID stri
 
 	go func() {
 		defer wg.Done()
-		_, es[1] = s.friendRpcClient.Client.NotificationUserInfoUpdate(ctx, &friendpb.NotificationUserInfoUpdateReq{
+		_, es[1] = s.relationClient.NotificationUserInfoUpdate(ctx, &friendpb.NotificationUserInfoUpdateReq{
 			UserID:      userID,
 			OldUserInfo: oldUserInfo,
 			NewUserInfo: newUserInfo,

pkg/common/convert/group.go

@@ -80,9 +80,18 @@ func Db2PbGroupMember(m *model.GroupMember) *sdkws.GroupMemberFullInfo {
 	}
 }
 
-func Db2PbGroupRequest(m *model.GroupRequest, user *sdkws.PublicUserInfo, group *sdkws.GroupInfo) *sdkws.GroupRequest {
+func Db2PbGroupRequest(m *model.GroupRequest, user *sdkws.UserInfo, group *sdkws.GroupInfo) *sdkws.GroupRequest {
+	var pu *sdkws.PublicUserInfo
+	if user != nil {
+		pu = &sdkws.PublicUserInfo{
+			UserID:   user.UserID,
+			Nickname: user.Nickname,
+			FaceURL:  user.FaceURL,
+			Ex:       user.Ex,
+		}
+	}
 	return &sdkws.GroupRequest{
-		UserInfo:      user,
+		UserInfo:      pu,
 		GroupInfo:     group,
 		HandleResult:  m.HandleResult,
 		ReqMsg:        m.ReqMsg,

pkg/common/startrpc/start.go

@@ -28,6 +28,14 @@ import (
 	"syscall"
 	"time"
 
+	conf "github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	"github.com/openimsdk/tools/discovery/etcd"
+	"github.com/openimsdk/tools/utils/datautil"
+	"github.com/openimsdk/tools/utils/jsonutil"
+	"google.golang.org/grpc/status"
+
+	"github.com/openimsdk/tools/utils/runtimeenv"
+
 	kdisc "github.com/openimsdk/open-im-server/v3/pkg/common/discoveryregister"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/tools/discovery"
@@ -68,13 +76,9 @@ func Start[T any](ctx context.Context, discovery *config.Discovery, prometheusCo
 
 	defer client.Close()
 	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
-	registerIP, err = network.GetRpcRegisterIP(registerIP)
-	if err != nil {
-		return err
-	}
 
-	//var reg *prometheus.Registry
+	// var reg *prometheus.Registry
-	//var metric *grpcprometheus.ServerMetrics
+	// var metric *grpcprometheus.ServerMetrics
 	if prometheusConfig.Enable {
 		//cusMetrics := prommetrics.GetGrpcCusMetrics(rpcRegisterName, share)
 		//reg, metric, _ = prommetrics.NewGrpcPromObj(cusMetrics)

pkg/notification/common_user/common.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package notification
+package common_user
 
 type CommonUser interface {
 	GetNickname() string

pkg/notification/msg.go

@@ -271,15 +271,17 @@ func WithLocalSendMsg(sendMsg func(ctx context.Context, req *msg.SendMsgReq) (*m
 	}
 }
 
-func WithRpcClient(msgRpcClient *MessageRpcClient) NotificationSenderOptions {
+func WithRpcClient(sendMsg func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error)) NotificationSenderOptions {
 	return func(s *NotificationSender) {
-		s.sendMsg = msgRpcClient.SendMsg
+		s.sendMsg = func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+			return sendMsg(ctx, req)
+		}
 	}
 }
 
-func WithUserRpcClient(userRpcClient *UserRpcClient) NotificationSenderOptions {
+func WithUserRpcClient(getUserInfo func(ctx context.Context, userID string) (*sdkws.UserInfo, error)) NotificationSenderOptions {
 	return func(s *NotificationSender) {
-		s.getUserInfo = userRpcClient.GetUserInfo
+		s.getUserInfo = getUserInfo
 	}
 }
 

pkg/rpccache/conversation.go

@@ -19,7 +19,7 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	pbconversation "github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
@@ -32,7 +32,7 @@ const (
 	conversationWorkerCount = 20
 )
 
-func NewConversationLocalCache(client rpcclient.ConversationRpcClient, localCache *config.LocalCache, cli redis.UniversalClient) *ConversationLocalCache {
+func NewConversationLocalCache(client *rpcli.ConversationClient, localCache *config.LocalCache, cli redis.UniversalClient) *ConversationLocalCache {
 	lc := localCache.Conversation
 	log.ZDebug(context.Background(), "ConversationLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
 	x := &ConversationLocalCache{
@@ -52,7 +52,7 @@ func NewConversationLocalCache(client rpcclient.ConversationRpcClient, localCach
 }
 
 type ConversationLocalCache struct {
-	client rpcclient.ConversationRpcClient
+	client *rpcli.ConversationClient
 	local  localcache.Cache[[]byte]
 }
 
@@ -76,7 +76,7 @@ func (c *ConversationLocalCache) getConversationIDs(ctx context.Context, ownerUs
 	var cache cacheProto[pbconversation.GetConversationIDsResp]
 	return cache.Unmarshal(c.local.Get(ctx, cachekey.GetConversationIDsKey(ownerUserID), func(ctx context.Context) ([]byte, error) {
 		log.ZDebug(ctx, "ConversationLocalCache getConversationIDs rpc", "ownerUserID", ownerUserID)
-		return cache.Marshal(c.client.Client.GetConversationIDs(ctx, &pbconversation.GetConversationIDsReq{UserID: ownerUserID}))
+		return cache.Marshal(c.client.ConversationClient.GetConversationIDs(ctx, &pbconversation.GetConversationIDsReq{UserID: ownerUserID}))
 	}))
 }
 
@@ -92,7 +92,7 @@ func (c *ConversationLocalCache) GetConversation(ctx context.Context, userID, co
 	var cache cacheProto[pbconversation.Conversation]
 	return cache.Unmarshal(c.local.Get(ctx, cachekey.GetConversationKey(userID, conversationID), func(ctx context.Context) ([]byte, error) {
 		log.ZDebug(ctx, "ConversationLocalCache GetConversation rpc", "userID", userID, "conversationID", conversationID)
-		return cache.Marshal(c.client.GetConversation(ctx, userID, conversationID))
+		return cache.Marshal(c.client.GetConversation(ctx, conversationID, userID))
 	}))
 }
 
@@ -149,7 +149,7 @@ func (c *ConversationLocalCache) getConversationNotReceiveMessageUserIDs(ctx con
 	var cache cacheProto[pbconversation.GetConversationNotReceiveMessageUserIDsResp]
 	return cache.Unmarshal(c.local.Get(ctx, cachekey.GetConversationNotReceiveMessageUserIDsKey(conversationID), func(ctx context.Context) ([]byte, error) {
 		log.ZDebug(ctx, "ConversationLocalCache getConversationNotReceiveMessageUserIDs rpc", "conversationID", conversationID)
-		return cache.Marshal(c.client.Client.GetConversationNotReceiveMessageUserIDs(ctx, &pbconversation.GetConversationNotReceiveMessageUserIDsReq{ConversationID: conversationID}))
+		return cache.Marshal(c.client.ConversationClient.GetConversationNotReceiveMessageUserIDs(ctx, &pbconversation.GetConversationNotReceiveMessageUserIDsReq{ConversationID: conversationID}))
 	}))
 }
 

pkg/rpccache/friend.go

@@ -17,6 +17,7 @@ package rpccache
 import (
 	"context"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/relation"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -26,7 +27,7 @@ import (
 	"github.com/redis/go-redis/v9"
 )
 
-func NewFriendLocalCache(client rpcclient.FriendRpcClient, localCache *config.LocalCache, cli redis.UniversalClient) *FriendLocalCache {
+func NewFriendLocalCache(client *rpcli.RelationClient, localCache *config.LocalCache, cli redis.UniversalClient) *FriendLocalCache {
 	lc := localCache.Friend
 	log.ZDebug(context.Background(), "FriendLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
 	x := &FriendLocalCache{
@@ -46,7 +47,7 @@ func NewFriendLocalCache(client rpcclient.FriendRpcClient, localCache *config.Lo
 }
 
 type FriendLocalCache struct {
-	client rpcclient.FriendRpcClient
+	client *rpcli.RelationClient
 	local  localcache.Cache[[]byte]
 }
 
@@ -70,7 +71,7 @@ func (f *FriendLocalCache) isFriend(ctx context.Context, possibleFriendUserID, u
 	var cache cacheProto[relation.IsFriendResp]
 	return cache.Unmarshal(f.local.GetLink(ctx, cachekey.GetIsFriendKey(possibleFriendUserID, userID), func(ctx context.Context) ([]byte, error) {
 		log.ZDebug(ctx, "FriendLocalCache isFriend rpc", "possibleFriendUserID", possibleFriendUserID, "userID", userID)
-		return cache.Marshal(f.client.Client.IsFriend(ctx, &relation.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID}))
+		return cache.Marshal(f.client.FriendClient.IsFriend(ctx, &relation.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID}))
 	}, cachekey.GetFriendIDsKey(possibleFriendUserID)))
 }
 
@@ -96,6 +97,6 @@ func (f *FriendLocalCache) isBlack(ctx context.Context, possibleBlackUserID, use
 	var cache cacheProto[relation.IsBlackResp]
 	return cache.Unmarshal(f.local.GetLink(ctx, cachekey.GetIsBlackIDsKey(possibleBlackUserID, userID), func(ctx context.Context) ([]byte, error) {
 		log.ZDebug(ctx, "FriendLocalCache IsBlack rpc", "possibleBlackUserID", possibleBlackUserID, "userID", userID)
-		return cache.Marshal(f.client.Client.IsBlack(ctx, &relation.IsBlackReq{UserID1: possibleBlackUserID, UserID2: userID}))
+		return cache.Marshal(f.client.FriendClient.IsBlack(ctx, &relation.IsBlackReq{UserID1: possibleBlackUserID, UserID2: userID}))
 	}, cachekey.GetBlackIDsKey(userID)))
 }

pkg/rpccache/group.go

@@ -17,6 +17,7 @@ package rpccache
 import (
 	"context"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/tools/utils/datautil"
 
@@ -29,7 +30,7 @@ import (
 	"github.com/redis/go-redis/v9"
 )
 
-func NewGroupLocalCache(client rpcclient.GroupRpcClient, localCache *config.LocalCache, cli redis.UniversalClient) *GroupLocalCache {
+func NewGroupLocalCache(client *rpcli.GroupClient, localCache *config.LocalCache, cli redis.UniversalClient) *GroupLocalCache {
 	lc := localCache.Group
 	log.ZDebug(context.Background(), "GroupLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
 	x := &GroupLocalCache{
@@ -49,7 +50,7 @@ func NewGroupLocalCache(client rpcclient.GroupRpcClient, localCache *config.Loca
 }
 
 type GroupLocalCache struct {
-	client rpcclient.GroupRpcClient
+	client *rpcli.GroupClient
 	local  localcache.Cache[[]byte]
 }
 
@@ -65,7 +66,7 @@ func (g *GroupLocalCache) getGroupMemberIDs(ctx context.Context, groupID string)
 	var cache cacheProto[group.GetGroupMemberUserIDsResp]
 	return cache.Unmarshal(g.local.Get(ctx, cachekey.GetGroupMemberIDsKey(groupID), func(ctx context.Context) ([]byte, error) {
 		log.ZDebug(ctx, "GroupLocalCache getGroupMemberIDs rpc", "groupID", groupID)
-		return cache.Marshal(g.client.Client.GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{GroupID: groupID}))
+		return cache.Marshal(g.client.GroupClient.GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{GroupID: groupID}))
 	}))
 }
 

pkg/rpccache/online.go

@@ -3,6 +3,7 @@ package rpccache
 import (
 	"context"
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/user"
 	"math/rand"
@@ -22,10 +23,10 @@ import (
 	"github.com/redis/go-redis/v9"
 )
 
-func NewOnlineCache(user rpcclient.UserRpcClient, group *GroupLocalCache, rdb redis.UniversalClient, fullUserCache bool, fn func(ctx context.Context, userID string, platformIDs []int32)) (*OnlineCache, error) {
+func NewOnlineCache(client *rpcli.UserClient, group *GroupLocalCache, rdb redis.UniversalClient, fullUserCache bool, fn func(ctx context.Context, userID string, platformIDs []int32)) (*OnlineCache, error) {
 	l := &sync.Mutex{}
 	x := &OnlineCache{
-		user:          user,
+		client:        client,
 		group:         group,
 		fullUserCache: fullUserCache,
 		Lock:          l,
@@ -65,8 +66,8 @@ const (
 )
 
 type OnlineCache struct {
-	user  rpcclient.UserRpcClient
+	client *rpcli.UserClient
-	group *GroupLocalCache
+	group  *GroupLocalCache
 
 	// fullUserCache if enabled, caches the online status of all users using mapCache;
 	// otherwise, only a portion of users' online statuses (regardless of whether they are online) will be cached using lruCache.
@@ -112,7 +113,7 @@ func (o *OnlineCache) initUsersOnlineStatus(ctx context.Context) (err error) {
 	cursor := uint64(0)
 	for resp == nil || resp.NextCursor != 0 {
 		if err = retryOperation(func() error {
-			resp, err = o.user.GetAllOnlineUsers(ctx, cursor)
+			resp, err = o.client.GetAllOnlineUsers(ctx, cursor)
 			if err != nil {
 				return err
 			}
@@ -186,7 +187,7 @@ func (o *OnlineCache) doSubscribe(ctx context.Context, rdb redis.UniversalClient
 
 func (o *OnlineCache) getUserOnlinePlatform(ctx context.Context, userID string) ([]int32, error) {
 	platformIDs, err := o.lruCache.Get(userID, func() ([]int32, error) {
-		return o.user.GetUserOnlinePlatform(ctx, userID)
+		return o.client.GetUserOnlinePlatform(ctx, userID)
 	})
 	if err != nil {
 		log.ZError(ctx, "OnlineCache GetUserOnlinePlatform", err, "userID", userID)
@@ -227,8 +228,7 @@ func (o *OnlineCache) GetUserOnline(ctx context.Context, userID string) (bool, e
 func (o *OnlineCache) getUserOnlinePlatformBatch(ctx context.Context, userIDs []string) (map[string][]int32, error) {
 	platformIDsMap, err := o.lruCache.GetBatch(userIDs, func(missingUsers []string) (map[string][]int32, error) {
 		platformIDsMap := make(map[string][]int32)
-
+		usersStatus, err := o.client.GetUsersOnlinePlatform(ctx, missingUsers)
-		usersStatus, err := o.user.GetUsersOnlinePlatform(ctx, missingUsers)
 		if err != nil {
 			return nil, err
 		}

pkg/rpccache/subscriber.go

@@ -17,7 +17,6 @@ package rpccache
 import (
 	"context"
 	"encoding/json"
-
 	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
 )

pkg/rpccache/user.go

@@ -16,11 +16,11 @@ package rpccache
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/protocol/user"
 	"github.com/openimsdk/tools/errs"
@@ -28,7 +28,7 @@ import (
 	"github.com/redis/go-redis/v9"
 )
 
-func NewUserLocalCache(client rpcclient.UserRpcClient, localCache *config.LocalCache, cli redis.UniversalClient) *UserLocalCache {
+func NewUserLocalCache(client *rpcli.UserClient, localCache *config.LocalCache, cli redis.UniversalClient) *UserLocalCache {
 	lc := localCache.User
 	log.ZDebug(context.Background(), "UserLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
 	x := &UserLocalCache{
@@ -48,7 +48,7 @@ func NewUserLocalCache(client rpcclient.UserRpcClient, localCache *config.LocalC
 }
 
 type UserLocalCache struct {
-	client rpcclient.UserRpcClient
+	client *rpcli.UserClient
 	local  localcache.Cache[[]byte]
 }
 
@@ -88,7 +88,7 @@ func (u *UserLocalCache) getUserGlobalMsgRecvOpt(ctx context.Context, userID str
 	var cache cacheProto[user.GetGlobalRecvMessageOptResp]
 	return cache.Unmarshal(u.local.Get(ctx, cachekey.GetUserGlobalRecvMsgOptKey(userID), func(ctx context.Context) ([]byte, error) {
 		log.ZDebug(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt rpc", "userID", userID)
-		return cache.Marshal(u.client.Client.GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{UserID: userID}))
+		return cache.Marshal(u.client.UserClient.GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{UserID: userID}))
 	}))
 }
 

pkg/rpcclient/doc.go

@@ -1,15 +0,0 @@
-// Copyright © 2024 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package rpcclient // import "github.com/openimsdk/open-im-server/v3/pkg/rpcclient"

pkg/rpcclient/grouphash/doc.go

@@ -1,15 +0,0 @@
-// Copyright © 2024 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package grouphash // import "github.com/openimsdk/open-im-server/v3/pkg/rpcclient/grouphash"

pkg/rpcclient/notification/doc.go

@@ -1,15 +0,0 @@
-// Copyright © 2024 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package notification // import "github.com/openimsdk/open-im-server/v3/pkg/rpcclient/notification"

pkg/rpcli/auth.go

@@ -0,0 +1,30 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/protocol/auth"
+	"google.golang.org/grpc"
+)
+
+func NewAuthClient(cc grpc.ClientConnInterface) *AuthClient {
+	return &AuthClient{auth.NewAuthClient(cc)}
+}
+
+type AuthClient struct {
+	auth.AuthClient
+}
+
+func (x *AuthClient) KickTokens(ctx context.Context, tokens []string) error {
+	if len(tokens) == 0 {
+		return nil
+	}
+	return ignoreResp(x.AuthClient.KickTokens(ctx, &auth.KickTokensReq{Tokens: tokens}))
+}
+
+func (x *AuthClient) InvalidateToken(ctx context.Context, req *auth.InvalidateTokenReq) error {
+	return ignoreResp(x.AuthClient.InvalidateToken(ctx, req))
+}
+
+func (x *AuthClient) ParseToken(ctx context.Context, token string) (*auth.ParseTokenResp, error) {
+	return x.AuthClient.ParseToken(ctx, &auth.ParseTokenReq{Token: token})
+}

pkg/rpcli/conversation.go

@@ -0,0 +1,94 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/protocol/conversation"
+	"google.golang.org/grpc"
+)
+
+func NewConversationClient(cc grpc.ClientConnInterface) *ConversationClient {
+	return &ConversationClient{conversation.NewConversationClient(cc)}
+}
+
+type ConversationClient struct {
+	conversation.ConversationClient
+}
+
+func (x *ConversationClient) SetConversationMaxSeq(ctx context.Context, conversationID string, ownerUserIDs []string, maxSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &conversation.SetConversationMaxSeqReq{ConversationID: conversationID, OwnerUserID: ownerUserIDs, MaxSeq: maxSeq}
+	return ignoreResp(x.ConversationClient.SetConversationMaxSeq(ctx, req))
+}
+
+func (x *ConversationClient) SetConversations(ctx context.Context, ownerUserIDs []string, info *conversation.ConversationReq) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &conversation.SetConversationsReq{UserIDs: ownerUserIDs, Conversation: info}
+	return ignoreResp(x.ConversationClient.SetConversations(ctx, req))
+}
+
+func (x *ConversationClient) GetConversationsByConversationIDs(ctx context.Context, conversationIDs []string) ([]*conversation.Conversation, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &conversation.GetConversationsByConversationIDReq{ConversationIDs: conversationIDs}
+	return extractField(ctx, x.ConversationClient.GetConversationsByConversationID, req, (*conversation.GetConversationsByConversationIDResp).GetConversations)
+}
+
+func (x *ConversationClient) GetConversationsByConversationID(ctx context.Context, conversationID string) (*conversation.Conversation, error) {
+	return firstValue(x.GetConversationsByConversationIDs(ctx, []string{conversationID}))
+}
+
+func (x *ConversationClient) SetConversationMinSeq(ctx context.Context, conversationID string, ownerUserIDs []string, minSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &conversation.SetConversationMinSeqReq{ConversationID: conversationID, OwnerUserID: ownerUserIDs, MinSeq: minSeq}
+	return ignoreResp(x.ConversationClient.SetConversationMinSeq(ctx, req))
+}
+
+func (x *ConversationClient) GetConversation(ctx context.Context, conversationID string, ownerUserID string) (*conversation.Conversation, error) {
+	req := &conversation.GetConversationReq{ConversationID: conversationID, OwnerUserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetConversation, req, (*conversation.GetConversationResp).GetConversation)
+}
+
+func (x *ConversationClient) GetConversations(ctx context.Context, conversationIDs []string, ownerUserID string) ([]*conversation.Conversation, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &conversation.GetConversationsReq{ConversationIDs: conversationIDs, OwnerUserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetConversations, req, (*conversation.GetConversationsResp).GetConversations)
+}
+
+func (x *ConversationClient) GetConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
+	req := &conversation.GetConversationIDsReq{UserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetConversationIDs, req, (*conversation.GetConversationIDsResp).GetConversationIDs)
+}
+
+func (x *ConversationClient) GetPinnedConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
+	req := &conversation.GetPinnedConversationIDsReq{UserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetPinnedConversationIDs, req, (*conversation.GetPinnedConversationIDsResp).GetConversationIDs)
+}
+
+func (x *ConversationClient) CreateGroupChatConversations(ctx context.Context, groupID string, userIDs []string) error {
+	if len(userIDs) == 0 {
+		return nil
+	}
+	req := &conversation.CreateGroupChatConversationsReq{GroupID: groupID, UserIDs: userIDs}
+	return ignoreResp(x.ConversationClient.CreateGroupChatConversations(ctx, req))
+}
+
+func (x *ConversationClient) CreateSingleChatConversations(ctx context.Context, req *conversation.CreateSingleChatConversationsReq) error {
+	return ignoreResp(x.ConversationClient.CreateSingleChatConversations(ctx, req))
+}
+
+func (x *ConversationClient) GetConversationOfflinePushUserIDs(ctx context.Context, conversationID string, userIDs []string) ([]string, error) {
+	if len(userIDs) == 0 {
+		return nil, nil
+	}
+	req := &conversation.GetConversationOfflinePushUserIDsReq{ConversationID: conversationID, UserIDs: userIDs}
+	return extractField(ctx, x.ConversationClient.GetConversationOfflinePushUserIDs, req, (*conversation.GetConversationOfflinePushUserIDsResp).GetUserIDs)
+}

pkg/rpcli/group.go

@@ -0,0 +1,48 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/protocol/group"
+	"github.com/openimsdk/protocol/sdkws"
+	"google.golang.org/grpc"
+)
+
+func NewGroupClient(cc grpc.ClientConnInterface) *GroupClient {
+	return &GroupClient{group.NewGroupClient(cc)}
+}
+
+type GroupClient struct {
+	group.GroupClient
+}
+
+func (x *GroupClient) GetGroupsInfo(ctx context.Context, groupIDs []string) ([]*sdkws.GroupInfo, error) {
+	if len(groupIDs) == 0 {
+		return nil, nil
+	}
+	req := &group.GetGroupsInfoReq{GroupIDs: groupIDs}
+	return extractField(ctx, x.GroupClient.GetGroupsInfo, req, (*group.GetGroupsInfoResp).GetGroupInfos)
+}
+
+func (x *GroupClient) GetGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+	return firstValue(x.GetGroupsInfo(ctx, []string{groupID}))
+}
+
+func (x *GroupClient) GetGroupInfoCache(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+	req := &group.GetGroupInfoCacheReq{GroupID: groupID}
+	return extractField(ctx, x.GroupClient.GetGroupInfoCache, req, (*group.GetGroupInfoCacheResp).GetGroupInfo)
+}
+
+func (x *GroupClient) GetGroupMemberCache(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
+	req := &group.GetGroupMemberCacheReq{GroupID: groupID, GroupMemberID: userID}
+	return extractField(ctx, x.GroupClient.GetGroupMemberCache, req, (*group.GetGroupMemberCacheResp).GetMember)
+}
+
+func (x *GroupClient) DismissGroup(ctx context.Context, groupID string, deleteMember bool) error {
+	req := &group.DismissGroupReq{GroupID: groupID, DeleteMember: deleteMember}
+	return ignoreResp(x.GroupClient.DismissGroup(ctx, req))
+}
+
+func (x *GroupClient) GetGroupMemberUserIDs(ctx context.Context, groupID string) ([]string, error) {
+	req := &group.GetGroupMemberUserIDsReq{GroupID: groupID}
+	return extractField(ctx, x.GroupClient.GetGroupMemberUserIDs, req, (*group.GetGroupMemberUserIDsResp).GetUserIDs)
+}

pkg/rpcli/msg.go

@@ -0,0 +1,90 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/protocol/msg"
+	"github.com/openimsdk/protocol/sdkws"
+	"google.golang.org/grpc"
+)
+
+func NewMsgClient(cc grpc.ClientConnInterface) *MsgClient {
+	return &MsgClient{msg.NewMsgClient(cc)}
+}
+
+type MsgClient struct {
+	msg.MsgClient
+}
+
+func (x *MsgClient) GetMaxSeqs(ctx context.Context, conversationIDs []string) (map[string]int64, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetMaxSeqsReq{ConversationIDs: conversationIDs}
+	return extractField(ctx, x.MsgClient.GetMaxSeqs, req, (*msg.SeqsInfoResp).GetMaxSeqs)
+}
+
+func (x *MsgClient) GetMsgByConversationIDs(ctx context.Context, conversationIDs []string, maxSeqs map[string]int64) (map[string]*sdkws.MsgData, error) {
+	if len(conversationIDs) == 0 || len(maxSeqs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetMsgByConversationIDsReq{ConversationIDs: conversationIDs, MaxSeqs: maxSeqs}
+	return extractField(ctx, x.MsgClient.GetMsgByConversationIDs, req, (*msg.GetMsgByConversationIDsResp).GetMsgDatas)
+}
+
+func (x *MsgClient) GetHasReadSeqs(ctx context.Context, conversationIDs []string, userID string) (map[string]int64, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetHasReadSeqsReq{ConversationIDs: conversationIDs, UserID: userID}
+	return extractField(ctx, x.MsgClient.GetHasReadSeqs, req, (*msg.SeqsInfoResp).GetMaxSeqs)
+}
+
+func (x *MsgClient) SetUserConversationMaxSeq(ctx context.Context, conversationID string, ownerUserIDs []string, maxSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &msg.SetUserConversationMaxSeqReq{ConversationID: conversationID, OwnerUserID: ownerUserIDs, MaxSeq: maxSeq}
+	return ignoreResp(x.MsgClient.SetUserConversationMaxSeq(ctx, req))
+}
+
+func (x *MsgClient) SetUserConversationMin(ctx context.Context, conversationID string, ownerUserIDs []string, minSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &msg.SetUserConversationsMinSeqReq{ConversationID: conversationID, UserIDs: ownerUserIDs, Seq: minSeq}
+	return ignoreResp(x.MsgClient.SetUserConversationsMinSeq(ctx, req))
+}
+
+func (x *MsgClient) GetLastMessageSeqByTime(ctx context.Context, conversationID string, lastTime int64) (int64, error) {
+	req := &msg.GetLastMessageSeqByTimeReq{ConversationID: conversationID, Time: lastTime}
+	return extractField(ctx, x.MsgClient.GetLastMessageSeqByTime, req, (*msg.GetLastMessageSeqByTimeResp).GetSeq)
+}
+
+func (x *MsgClient) GetConversationMaxSeq(ctx context.Context, conversationID string) (int64, error) {
+	req := &msg.GetConversationMaxSeqReq{ConversationID: conversationID}
+	return extractField(ctx, x.MsgClient.GetConversationMaxSeq, req, (*msg.GetConversationMaxSeqResp).GetMaxSeq)
+}
+
+func (x *MsgClient) GetActiveConversation(ctx context.Context, conversationIDs []string) ([]*msg.ActiveConversation, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetActiveConversationReq{ConversationIDs: conversationIDs}
+	return extractField(ctx, x.MsgClient.GetActiveConversation, req, (*msg.GetActiveConversationResp).GetConversations)
+}
+
+func (x *MsgClient) GetSeqMessage(ctx context.Context, userID string, conversations []*msg.ConversationSeqs) (map[string]*sdkws.PullMsgs, error) {
+	if len(conversations) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetSeqMessageReq{UserID: userID, Conversations: conversations}
+	return extractField(ctx, x.MsgClient.GetSeqMessage, req, (*msg.GetSeqMessageResp).GetMsgs)
+}
+
+func (x *MsgClient) SetUserConversationsMinSeq(ctx context.Context, conversationID string, userIDs []string, seq int64) error {
+	if len(userIDs) == 0 {
+		return nil
+	}
+	req := &msg.SetUserConversationsMinSeqReq{ConversationID: conversationID, UserIDs: userIDs, Seq: seq}
+	return ignoreResp(x.MsgClient.SetUserConversationsMinSeq(ctx, req))
+}

pkg/rpcli/msggateway.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"github.com/openimsdk/protocol/msggateway"
+	"google.golang.org/grpc"
+)
+
+func NewMsgGatewayClient(cc grpc.ClientConnInterface) *MsgGatewayClient {
+	return &MsgGatewayClient{msggateway.NewMsgGatewayClient(cc)}
+}
+
+type MsgGatewayClient struct {
+	msggateway.MsgGatewayClient
+}

pkg/rpcli/push.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"github.com/openimsdk/protocol/push"
+	"google.golang.org/grpc"
+)
+
+func NewPushMsgServiceClient(cc grpc.ClientConnInterface) *PushMsgServiceClient {
+	return &PushMsgServiceClient{push.NewPushMsgServiceClient(cc)}
+}
+
+type PushMsgServiceClient struct {
+	push.PushMsgServiceClient
+}

pkg/rpcli/relation.go

@@ -0,0 +1,23 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/protocol/relation"
+	"google.golang.org/grpc"
+)
+
+func NewRelationClient(cc grpc.ClientConnInterface) *RelationClient {
+	return &RelationClient{relation.NewFriendClient(cc)}
+}
+
+type RelationClient struct {
+	relation.FriendClient
+}
+
+func (x *RelationClient) GetFriendsInfo(ctx context.Context, ownerUserID string, friendUserIDs []string) ([]*relation.FriendInfoOnly, error) {
+	if len(friendUserIDs) == 0 {
+		return nil, nil
+	}
+	req := &relation.GetFriendInfoReq{OwnerUserID: ownerUserID, FriendUserIDs: friendUserIDs}
+	return extractField(ctx, x.FriendClient.GetFriendInfo, req, (*relation.GetFriendInfoResp).GetFriendInfos)
+}

pkg/rpcli/rtc.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"github.com/openimsdk/protocol/rtc"
+	"google.golang.org/grpc"
+)
+
+func NewRtcServiceClient(cc grpc.ClientConnInterface) *RtcServiceClient {
+	return &RtcServiceClient{rtc.NewRtcServiceClient(cc)}
+}
+
+type RtcServiceClient struct {
+	rtc.RtcServiceClient
+}

pkg/rpcli/third.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"github.com/openimsdk/protocol/third"
+	"google.golang.org/grpc"
+)
+
+func NewThirdClient(cc grpc.ClientConnInterface) *ThirdClient {
+	return &ThirdClient{third.NewThirdClient(cc)}
+}
+
+type ThirdClient struct {
+	third.ThirdClient
+}

pkg/rpcli/tool.go

@@ -0,0 +1,32 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/tools/errs"
+	"google.golang.org/grpc"
+)
+
+func extractField[A, B, C any](ctx context.Context, fn func(ctx context.Context, req *A, opts ...grpc.CallOption) (*B, error), req *A, get func(*B) C) (C, error) {
+	resp, err := fn(ctx, req)
+	if err != nil {
+		var c C
+		return c, err
+	}
+	return get(resp), nil
+}
+
+func firstValue[A any](val []A, err error) (A, error) {
+	if err != nil {
+		var a A
+		return a, err
+	}
+	if len(val) == 0 {
+		var a A
+		return a, errs.ErrRecordNotFound.WrapMsg("record not found")
+	}
+	return val[0], nil
+}
+
+func ignoreResp(_ any, err error) error {
+	return err
+}

pkg/rpcli/user.go

@@ -0,0 +1,95 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/protocol/user"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/utils/datautil"
+	"google.golang.org/grpc"
+)
+
+func NewUserClient(cc grpc.ClientConnInterface) *UserClient {
+	return &UserClient{user.NewUserClient(cc)}
+}
+
+type UserClient struct {
+	user.UserClient
+}
+
+func (x *UserClient) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
+	if len(userIDs) == 0 {
+		return nil, nil
+	}
+	req := &user.GetDesignateUsersReq{UserIDs: userIDs}
+	return extractField(ctx, x.UserClient.GetDesignateUsers, req, (*user.GetDesignateUsersResp).GetUsersInfo)
+}
+
+func (x *UserClient) GetUserInfo(ctx context.Context, userID string) (*sdkws.UserInfo, error) {
+	return firstValue(x.GetUsersInfo(ctx, []string{userID}))
+}
+
+func (x *UserClient) CheckUser(ctx context.Context, userIDs []string) error {
+	if len(userIDs) == 0 {
+		return nil
+	}
+	users, err := x.GetUsersInfo(ctx, userIDs)
+	if err != nil {
+		return err
+	}
+	if len(users) != len(userIDs) {
+		return errs.ErrRecordNotFound.WrapMsg("user not found")
+	}
+	return nil
+}
+
+func (x *UserClient) GetUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
+	users, err := x.GetUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	return datautil.SliceToMap(users, func(e *sdkws.UserInfo) string {
+		return e.UserID
+	}), nil
+}
+
+func (x *UserClient) GetAllOnlineUsers(ctx context.Context, cursor uint64) (*user.GetAllOnlineUsersResp, error) {
+	req := &user.GetAllOnlineUsersReq{Cursor: cursor}
+	return x.UserClient.GetAllOnlineUsers(ctx, req)
+}
+
+func (x *UserClient) GetUsersOnlinePlatform(ctx context.Context, userIDs []string) ([]*user.OnlineStatus, error) {
+	if len(userIDs) == 0 {
+		return nil, nil
+	}
+	req := &user.GetUserStatusReq{UserIDs: userIDs}
+	return extractField(ctx, x.UserClient.GetUserStatus, req, (*user.GetUserStatusResp).GetStatusList)
+
+}
+
+func (x *UserClient) GetUserOnlinePlatform(ctx context.Context, userID string) ([]int32, error) {
+	status, err := x.GetUsersOnlinePlatform(ctx, []string{userID})
+	if err != nil {
+		return nil, err
+	}
+	if len(status) == 0 {
+		return nil, nil
+	}
+	return status[0].PlatformIDs, nil
+}
+
+func (x *UserClient) SetUserOnlineStatus(ctx context.Context, req *user.SetUserOnlineStatusReq) error {
+	if len(req.Status) == 0 {
+		return nil
+	}
+	return ignoreResp(x.UserClient.SetUserOnlineStatus(ctx, req))
+}
+
+func (x *UserClient) GetNotificationByID(ctx context.Context, userID string) error {
+	return ignoreResp(x.UserClient.GetNotificationAccount(ctx, &user.GetNotificationAccountReq{UserID: userID}))
+}
+
+func (x *UserClient) GetAllUserIDs(ctx context.Context, pageNumber, showNumber int32) ([]string, error) {
+	req := &user.GetAllUserIDReq{Pagination: &sdkws.RequestPagination{PageNumber: pageNumber, ShowNumber: showNumber}}
+	return extractField(ctx, x.UserClient.GetAllUserID, req, (*user.GetAllUserIDResp).GetUserIDs)
+}