grpc conn reuse

pkg/common/config/config.go

@@ -173,7 +173,6 @@ type config struct {
 		OpenImGroupName          string `yaml:"openImGroupName"`
 		OpenImAuthName           string `yaml:"openImAuthName"`
 		OpenImConversationName   string `yaml:"openImConversationName"`
-		OpenImCacheName          string `yaml:"openImCacheName"`
 		OpenImRtcName            string `yaml:"openImRtcName"`
 		OpenImThirdName          string `yaml:"openImThirdName"`
 	}

pkg/common/db/localcache/conversation.go

@@ -7,13 +7,14 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
+	"google.golang.org/grpc"
 )
 
 type ConversationLocalCache struct {
 	lock                              sync.Mutex
 	SuperGroupRecvMsgNotNotifyUserIDs map[string]Hash
 	ConversationIDs                   map[string]Hash
-	client                            discoveryregistry.SvcDiscoveryRegistry
+	conn                              *grpc.ClientConn
 }
 
 type Hash struct {
@@ -22,19 +23,19 @@ type Hash struct {
 }
 
 func NewConversationLocalCache(client discoveryregistry.SvcDiscoveryRegistry) *ConversationLocalCache {
+	conn, err := client.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImConversationName)
+	if err != nil {
+		panic(err)
+	}
 	return &ConversationLocalCache{
 		SuperGroupRecvMsgNotNotifyUserIDs: make(map[string]Hash),
 		ConversationIDs:                   make(map[string]Hash),
-		client:                            client,
+		conn:                              conn,
 	}
 }
 
 func (g *ConversationLocalCache) GetRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) {
-	conn, err := g.client.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName)
-	if err != nil {
-		return nil, err
-	}
-	client := conversation.NewConversationClient(conn)
+	client := conversation.NewConversationClient(g.conn)
 	resp, err := client.GetRecvMsgNotNotifyUserIDs(ctx, &conversation.GetRecvMsgNotNotifyUserIDsReq{
 		GroupID: groupID,
 	})
@@ -45,11 +46,7 @@ func (g *ConversationLocalCache) GetRecvMsgNotNotifyUserIDs(ctx context.Context,
 }
 
 func (g *ConversationLocalCache) GetConversationIDs(ctx context.Context, userID string) ([]string, error) {
-	conn, err := g.client.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName)
-	if err != nil {
-		return nil, err
-	}
-	client := conversation.NewConversationClient(conn)
+	client := conversation.NewConversationClient(g.conn)
 	resp, err := client.GetUserConversationIDsHash(ctx, &conversation.GetUserConversationIDsHashReq{
 		OwnerUserID: userID,
 	})

pkg/common/db/localcache/group.go

@@ -8,12 +8,13 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	"google.golang.org/grpc"
 )
 
 type GroupLocalCache struct {
-	lock   sync.Mutex
-	cache  map[string]GroupMemberIDsHash
-	client discoveryregistry.SvcDiscoveryRegistry
+	lock  sync.Mutex
+	cache map[string]GroupMemberIDsHash
+	conn  *grpc.ClientConn
 }
 
 type GroupMemberIDsHash struct {
@@ -22,20 +23,20 @@ type GroupMemberIDsHash struct {
 }
 
 func NewGroupLocalCache(client discoveryregistry.SvcDiscoveryRegistry) *GroupLocalCache {
+	conn, err := client.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImGroupName)
+	if err != nil {
+		panic(err)
+	}
 	return &GroupLocalCache{
-		cache:  make(map[string]GroupMemberIDsHash, 0),
-		client: client,
+		cache: make(map[string]GroupMemberIDsHash, 0),
+		conn:  conn,
 	}
 }
 
 func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) {
 	g.lock.Lock()
 	defer g.lock.Unlock()
-	conn, err := g.client.GetConn(ctx, config.Config.RpcRegisterName.OpenImGroupName)
-	if err != nil {
-		return nil, err
-	}
-	client := group.NewGroupClient(conn)
+	client := group.NewGroupClient(g.conn)
 	resp, err := client.GetGroupAbstractInfo(ctx, &group.GetGroupAbstractInfoReq{
 		GroupIDs: []string{groupID},
 	})

pkg/rpcclient/conversation.go

@@ -6,34 +6,31 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
+	"google.golang.org/grpc"
 )
 
 type ConversationClient struct {
-	*MetaClient
+	conn *grpc.ClientConn
 }
 
-func NewConversationClient(zk discoveryRegistry.SvcDiscoveryRegistry) *ConversationClient {
-	return &ConversationClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImConversationName)}
+func NewConversationClient(discov discoveryRegistry.SvcDiscoveryRegistry) *ConversationClient {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImConversationName)
+	if err != nil {
+		panic(err)
+	}
+	return &ConversationClient{conn: conn}
 }
 
 func (c *ConversationClient) ModifyConversationField(ctx context.Context, req *pbConversation.ModifyConversationFieldReq) error {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).ModifyConversationField(ctx, req)
+	_, err := pbConversation.NewConversationClient(c.conn).ModifyConversationField(ctx, req)
 	return err
 }
 
 func (c *ConversationClient) GetSingleConversationRecvMsgOpt(ctx context.Context, userID, conversationID string) (int32, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return 0, err
-	}
 	var req pbConversation.GetConversationReq
 	req.OwnerUserID = userID
 	req.ConversationID = conversationID
-	conversation, err := pbConversation.NewConversationClient(cc).GetConversation(ctx, &req)
+	conversation, err := pbConversation.NewConversationClient(c.conn).GetConversation(ctx, &req)
 	if err != nil {
 		return 0, err
 	}
@@ -41,55 +38,31 @@ func (c *ConversationClient) GetSingleConversationRecvMsgOpt(ctx context.Context
 }
 
 func (c *ConversationClient) SingleChatFirstCreateConversation(ctx context.Context, recvID, sendID string) error {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).CreateSingleChatConversations(ctx, &pbConversation.CreateSingleChatConversationsReq{RecvID: recvID, SendID: sendID})
+	_, err := pbConversation.NewConversationClient(c.conn).CreateSingleChatConversations(ctx, &pbConversation.CreateSingleChatConversationsReq{RecvID: recvID, SendID: sendID})
 	return err
 }
 
 func (c *ConversationClient) GroupChatFirstCreateConversation(ctx context.Context, groupID string, userIDs []string) error {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).CreateGroupChatConversations(ctx, &pbConversation.CreateGroupChatConversationsReq{UserIDs: userIDs, GroupID: groupID})
+	_, err := pbConversation.NewConversationClient(c.conn).CreateGroupChatConversations(ctx, &pbConversation.CreateGroupChatConversationsReq{UserIDs: userIDs, GroupID: groupID})
 	return err
 }
 
 func (c *ConversationClient) DelGroupChatConversations(ctx context.Context, ownerUserIDs []string, groupID string, maxSeq int64) error {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).DelGroupChatConversations(ctx, &pbConversation.DelGroupChatConversationsReq{OwnerUserID: ownerUserIDs, GroupID: groupID, MaxSeq: maxSeq})
+	_, err := pbConversation.NewConversationClient(c.conn).DelGroupChatConversations(ctx, &pbConversation.DelGroupChatConversationsReq{OwnerUserID: ownerUserIDs, GroupID: groupID, MaxSeq: maxSeq})
 	return err
 }
 
 func (c *ConversationClient) GetConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).GetConversationIDs(ctx, &pbConversation.GetConversationIDsReq{UserID: ownerUserID})
+	resp, err := pbConversation.NewConversationClient(c.conn).GetConversationIDs(ctx, &pbConversation.GetConversationIDsReq{UserID: ownerUserID})
 	return resp.ConversationIDs, err
 }
 
 func (c *ConversationClient) GetConversation(ctx context.Context, ownerUserID, conversationID string) (*pbConversation.Conversation, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).GetConversation(ctx, &pbConversation.GetConversationReq{OwnerUserID: ownerUserID, ConversationID: conversationID})
+	resp, err := pbConversation.NewConversationClient(c.conn).GetConversation(ctx, &pbConversation.GetConversationReq{OwnerUserID: ownerUserID, ConversationID: conversationID})
 	return resp.Conversation, err
 }
 
 func (c *ConversationClient) GetConversationByConversationID(ctx context.Context, conversationID string) (*pbConversation.Conversation, error) {
-	cc, err := c.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).GetConversationByConversationID(ctx, &pbConversation.GetConversationByConversationIDReq{ConversationID: conversationID})
+	resp, err := pbConversation.NewConversationClient(c.conn).GetConversationByConversationID(ctx, &pbConversation.GetConversationByConversationIDReq{ConversationID: conversationID})
 	return resp.Conversation, err
 }

pkg/rpcclient/friend.go

@@ -7,22 +7,23 @@ import (
 	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"google.golang.org/grpc"
 )
 
 type FriendClient struct {
-	*MetaClient
+	conn *grpc.ClientConn
 }
 
-func NewFriendClient(zk discoveryRegistry.SvcDiscoveryRegistry) *FriendClient {
-	return &FriendClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImFriendName)}
+func NewFriendClient(discov discoveryRegistry.SvcDiscoveryRegistry) *FriendClient {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImFriendName)
+	if err != nil {
+		panic(err)
+	}
+	return &FriendClient{conn: conn}
 }
 
 func (f *FriendClient) GetFriendsInfo(ctx context.Context, ownerUserID, friendUserID string) (resp *sdkws.FriendInfo, err error) {
-	cc, err := f.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	r, err := friend.NewFriendClient(cc).GetDesignatedFriends(ctx, &friend.GetDesignatedFriendsReq{OwnerUserID: ownerUserID, FriendUserIDs: []string{friendUserID}})
+	r, err := friend.NewFriendClient(f.conn).GetDesignatedFriends(ctx, &friend.GetDesignatedFriendsReq{OwnerUserID: ownerUserID, FriendUserIDs: []string{friendUserID}})
 	if err != nil {
 		return nil, err
 	}
@@ -32,11 +33,7 @@ func (f *FriendClient) GetFriendsInfo(ctx context.Context, ownerUserID, friendUs
 
 // possibleFriendUserID是否在userID的好友中
 func (f *FriendClient) IsFriend(ctx context.Context, possibleFriendUserID, userID string) (bool, error) {
-	cc, err := f.getConn(ctx)
-	if err != nil {
-		return false, err
-	}
-	resp, err := friend.NewFriendClient(cc).IsFriend(ctx, &friend.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID})
+	resp, err := friend.NewFriendClient(f.conn).IsFriend(ctx, &friend.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID})
 	if err != nil {
 		return false, err
 	}
@@ -45,12 +42,8 @@ func (f *FriendClient) IsFriend(ctx context.Context, possibleFriendUserID, userI
 }
 
 func (f *FriendClient) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error) {
-	cc, err := f.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
 	req := friend.GetFriendIDsReq{UserID: ownerUserID}
-	resp, err := friend.NewFriendClient(cc).GetFriendIDs(ctx, &req)
+	resp, err := friend.NewFriendClient(f.conn).GetFriendIDs(ctx, &req)
 	if err != nil {
 		return nil, err
 	}

pkg/rpcclient/group.go

@@ -11,27 +11,23 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"google.golang.org/grpc"
 )
 
 type GroupClient struct {
-	MetaClient
+	conn *grpc.ClientConn
 }
 
-func NewGroupClient(client discoveryregistry.SvcDiscoveryRegistry) *GroupClient {
-	return &GroupClient{
-		MetaClient: MetaClient{
-			client:          client,
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
-		},
+func NewGroupClient(discov discoveryregistry.SvcDiscoveryRegistry) *GroupClient {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImGroupName)
+	if err != nil {
+		panic(err)
 	}
+	return &GroupClient{conn: conn}
 }
 
 func (g *GroupClient) GetGroupInfos(ctx context.Context, groupIDs []string, complete bool) ([]*sdkws.GroupInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupsInfo(ctx, &group.GetGroupsInfoReq{
+	resp, err := group.NewGroupClient(g.conn).GetGroupsInfo(ctx, &group.GetGroupsInfoReq{
 		GroupIDs: groupIDs,
 	})
 	if err != nil {
@@ -66,11 +62,7 @@ func (g *GroupClient) GetGroupInfoMap(ctx context.Context, groupIDs []string, co
 }
 
 func (g *GroupClient) GetGroupMemberInfos(ctx context.Context, groupID string, userIDs []string, complete bool) ([]*sdkws.GroupMemberFullInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMembersInfo(ctx, &group.GetGroupMembersInfoReq{
+	resp, err := group.NewGroupClient(g.conn).GetGroupMembersInfo(ctx, &group.GetGroupMembersInfoReq{
 		GroupID: groupID,
 		UserIDs: userIDs,
 	})
@@ -106,11 +98,7 @@ func (g *GroupClient) GetGroupMemberInfoMap(ctx context.Context, groupID string,
 }
 
 func (g *GroupClient) GetOwnerAndAdminInfos(ctx context.Context, groupID string) ([]*sdkws.GroupMemberFullInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
+	resp, err := group.NewGroupClient(g.conn).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
 		GroupID:    groupID,
 		RoleLevels: []int32{constant.GroupOwner, constant.GroupAdmin},
 	})
@@ -121,11 +109,7 @@ func (g *GroupClient) GetOwnerAndAdminInfos(ctx context.Context, groupID string)
 }
 
 func (g *GroupClient) GetOwnerInfo(ctx context.Context, groupID string) (*sdkws.GroupMemberFullInfo, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
+	resp, err := group.NewGroupClient(g.conn).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
 		GroupID:    groupID,
 		RoleLevels: []int32{constant.GroupOwner},
 	})
@@ -133,11 +117,7 @@ func (g *GroupClient) GetOwnerInfo(ctx context.Context, groupID string) (*sdkws.
 }
 
 func (g *GroupClient) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) {
-	cc, err := g.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{
+	resp, err := group.NewGroupClient(g.conn).GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{
 		GroupID: groupID,
 	})
 	if err != nil {

pkg/rpcclient/meta.go

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

pkg/rpcclient/msg.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
 	// "google.golang.org/protobuf/proto"
 )
@@ -98,37 +99,29 @@ func newSessionTypeConf() map[int32]int32 {
 }
 
 type MsgClient struct {
-	*MetaClient
+	conn *grpc.ClientConn
 }
 
 func NewMsgClient(discov discoveryregistry.SvcDiscoveryRegistry) *MsgClient {
-	return &MsgClient{MetaClient: NewMetaClient(discov, config.Config.RpcRegisterName.OpenImMsgName)}
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName)
+	if err != nil {
+		panic(err)
+	}
+	return &MsgClient{conn: conn}
 }
 
 func (m *MsgClient) SendMsg(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
-	cc, err := m.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).SendMsg(ctx, req)
+	resp, err := msg.NewMsgClient(m.conn).SendMsg(ctx, req)
 	return resp, err
 }
 
 func (m *MsgClient) GetMaxSeq(ctx context.Context, req *sdkws.GetMaxSeqReq) (*sdkws.GetMaxSeqResp, error) {
-	cc, err := m.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).GetMaxSeq(ctx, req)
+	resp, err := msg.NewMsgClient(m.conn).GetMaxSeq(ctx, req)
 	return resp, err
 }
 
 func (m *MsgClient) PullMessageBySeqList(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
-	cc, err := m.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).PullMessageBySeqs(ctx, req)
+	resp, err := msg.NewMsgClient(m.conn).PullMessageBySeqs(ctx, req)
 	return resp, err
 }
 

pkg/rpcclient/notification/common.go

@@ -0,0 +1,15 @@
+package notification
+
+type CommonUser interface {
+	GetNickname() string
+	GetFaceURL() string
+	GetUserID() string
+	GetEx() string
+}
+
+type CommonGroup interface {
+	GetNickname() string
+	GetFaceURL() string
+	GetGroupID() string
+	GetEx() string
+}

pkg/rpcclient/notification/friend.go

@@ -16,7 +16,7 @@ import (
 type FriendNotificationSender struct {
 	*rpcclient.NotificationSender
 	// 找不到报错
-	getUsersInfo func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error)
+	getUsersInfo func(ctx context.Context, userIDs []string) ([]CommonUser, error)
 	// db controller
 	db controller.FriendDatabase
 }
@@ -31,7 +31,7 @@ func WithFriendDB(db controller.FriendDatabase) friendNotificationSenderOptions
 
 func WithDBFunc(fn func(ctx context.Context, userIDs []string) (users []*relationTb.UserModel, err error)) friendNotificationSenderOptions {
 	return func(s *FriendNotificationSender) {
-		f := func(ctx context.Context, userIDs []string) (result []rpcclient.CommonUser, err error) {
+		f := func(ctx context.Context, userIDs []string) (result []CommonUser, err error) {
 			users, err := fn(ctx, userIDs)
 			if err != nil {
 				return nil, err
@@ -47,7 +47,7 @@ func WithDBFunc(fn func(ctx context.Context, userIDs []string) (users []*relatio
 
 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 []rpcclient.CommonUser, err error) {
+		f := func(ctx context.Context, userIDs []string) (result []CommonUser, err error) {
 			users, err := fn(ctx, userIDs)
 			if err != nil {
 				return nil, err

pkg/rpcclient/notification/group.go

@@ -17,7 +17,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )
 
-func NewGroupNotificationSender(db controller.GroupDatabase, sdr discoveryregistry.SvcDiscoveryRegistry, fn func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error)) *GroupNotificationSender {
+func NewGroupNotificationSender(db controller.GroupDatabase, sdr discoveryregistry.SvcDiscoveryRegistry, fn func(ctx context.Context, userIDs []string) ([]CommonUser, error)) *GroupNotificationSender {
 	return &GroupNotificationSender{
 		NotificationSender: rpcclient.NewNotificationSender(rpcclient.WithDiscov(sdr)),
 		getUsersInfo:       fn,
@@ -27,7 +27,7 @@ func NewGroupNotificationSender(db controller.GroupDatabase, sdr discoveryregist
 
 type GroupNotificationSender struct {
 	*rpcclient.NotificationSender
-	getUsersInfo func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error)
+	getUsersInfo func(ctx context.Context, userIDs []string) ([]CommonUser, error)
 	db           controller.GroupDatabase
 }
 

pkg/rpcclient/push.go

@@ -6,27 +6,23 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
+	"google.golang.org/grpc"
 )
 
 type PushClient struct {
-	MetaClient
+	conn *grpc.ClientConn
 }
 
-func NewPushClient(client discoveryregistry.SvcDiscoveryRegistry) *PushClient {
-	return &PushClient{
-		MetaClient: MetaClient{
-			client:          client,
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImPushName,
-		},
+func NewPushClient(discov discoveryregistry.SvcDiscoveryRegistry) *PushClient {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImPushName)
+	if err != nil {
+		panic(err)
 	}
+	return &PushClient{conn: conn}
 }
 
 func (p *PushClient) DelUserPushToken(ctx context.Context, req *push.DelUserPushTokenReq) (*push.DelUserPushTokenResp, error) {
-	cc, err := p.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := push.NewPushMsgServiceClient(cc).DelUserPushToken(ctx, req)
+	resp, err := push.NewPushMsgServiceClient(p.conn).DelUserPushToken(ctx, req)
 	if err != nil {
 		return nil, err
 	}

pkg/rpcclient/user.go

@@ -11,27 +11,23 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"google.golang.org/grpc"
 )
 
 type UserClient struct {
-	MetaClient
+	conn *grpc.ClientConn
 }
 
-func NewUserClient(client discoveryregistry.SvcDiscoveryRegistry) *UserClient {
-	return &UserClient{
-		MetaClient: MetaClient{
-			client:          client,
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImUserName,
-		},
+func NewUserClient(discov discoveryregistry.SvcDiscoveryRegistry) *UserClient {
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImUserName)
+	if err != nil {
+		panic(err)
 	}
+	return &UserClient{conn: conn}
 }
 
 func (u *UserClient) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
-	cc, err := u.getConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := user.NewUserClient(cc).GetDesignateUsers(ctx, &user.GetDesignateUsersReq{
+	resp, err := user.NewUserClient(u.conn).GetDesignateUsers(ctx, &user.GetDesignateUsersReq{
 		UserIDs: userIDs,
 	})
 	if err != nil {
@@ -97,11 +93,7 @@ func (u *UserClient) GetPublicUserInfoMap(ctx context.Context, userIDs []string,
 }
 
 func (u *UserClient) GetUserGlobalMsgRecvOpt(ctx context.Context, userID string) (int32, error) {
-	cc, err := u.getConn(ctx)
-	if err != nil {
-		return 0, err
-	}
-	resp, err := user.NewUserClient(cc).GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{
+	resp, err := user.NewUserClient(u.conn).GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{
 		UserID: userID,
 	})
 	if err != nil {