grpc conn reuse

internal/api/conversation.go

@@ -8,22 +8,23 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
 	"github.com/gin-gonic/gin"
+	"google.golang.org/grpc"
 )
 
 func NewConversation(c discoveryregistry.SvcDiscoveryRegistry) *Conversation {
-	return &Conversation{c: c}
+	conn, err := c.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImConversationName)
+	if err != nil {
+		panic(err)
+	}
+	return &Conversation{conn: conn}
 }
 
 type Conversation struct {
-	c discoveryregistry.SvcDiscoveryRegistry
+	conn *grpc.ClientConn
 }
 
 func (o *Conversation) client(ctx context.Context) (conversation.ConversationClient, error) {
-	conn, err := o.c.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName)
+	return conversation.NewConversationClient(o.conn), nil
-	if err != nil {
-		return nil, err
-	}
-	return conversation.NewConversationClient(conn), nil
 }
 
 func (o *Conversation) GetAllConversations(c *gin.Context) {

internal/api/friend.go

@@ -7,24 +7,25 @@ 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/friend"
+	"google.golang.org/grpc"
 
 	"github.com/gin-gonic/gin"
 )
 
 func NewFriend(c discoveryregistry.SvcDiscoveryRegistry) *Friend {
-	return &Friend{c: c}
+	conn, err := c.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImFriendName)
+	if err != nil {
+		panic(err)
+	}
+	return &Friend{conn: conn}
 }
 
 type Friend struct {
-	c discoveryregistry.SvcDiscoveryRegistry
+	conn *grpc.ClientConn
 }
 
 func (o *Friend) client(ctx context.Context) (friend.FriendClient, error) {
-	conn, err := o.c.GetConn(ctx, config.Config.RpcRegisterName.OpenImFriendName)
+	return friend.NewFriendClient(o.conn), nil
-	if err != nil {
-		return nil, err
-	}
-	return friend.NewFriendClient(conn), nil
 }
 
 func (o *Friend) ApplyToAddFriend(c *gin.Context) {

internal/api/group.go

@@ -5,28 +5,27 @@ import (
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	"google.golang.org/grpc"
 
 	"github.com/gin-gonic/gin"
 )
 
 func NewGroup(c discoveryregistry.SvcDiscoveryRegistry) *Group {
-	return &Group{c: c}
+	conn, err := c.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImGroupName)
+	if err != nil {
+		panic(err)
+	}
+	return &Group{conn: conn}
 }
 
 type Group struct {
-	c discoveryregistry.SvcDiscoveryRegistry
+	conn *grpc.ClientConn
 }
 
 func (o *Group) client(ctx context.Context) (group.GroupClient, error) {
-	conn, err := o.c.GetConn(ctx, config.Config.RpcRegisterName.OpenImGroupName)
+	return group.NewGroupClient(o.conn), nil
-	if err != nil {
-		return nil, err
-	}
-	log.ZDebug(ctx, "get conn", "local", o.c.GetClientLocalConns())
-	return group.NewGroupClient(conn), nil
 }
 
 func (o *Group) NewCreateGroup(c *gin.Context) {

internal/api/msg.go

@@ -17,15 +17,20 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/go-playground/validator/v10"
 	"github.com/mitchellh/mapstructure"
+	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
 )
 
 func NewMsg(c discoveryregistry.SvcDiscoveryRegistry) *Message {
-	return &Message{c: c, validate: validator.New()}
+	conn, err := c.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName)
+	if err != nil {
+		panic(err)
+	}
+	return &Message{conn: conn, validate: validator.New()}
 }
 
 type Message struct {
-	c        discoveryregistry.SvcDiscoveryRegistry
+	conn     *grpc.ClientConn
 	validate *validator.Validate
 }
 
@@ -104,11 +109,7 @@ func (m Message) newUserSendMsgReq(c *gin.Context, params *apistruct.ManagementS
 }
 
 func (m *Message) client(ctx context.Context) (msg.MsgClient, error) {
-	conn, err := m.c.GetConn(ctx, config.Config.RpcRegisterName.OpenImMsgName)
+	return msg.NewMsgClient(m.conn), nil
-	if err != nil {
-		return nil, err
-	}
-	return msg.NewMsgClient(conn), nil
 }
 
 func (m *Message) GetSeq(c *gin.Context) {
@@ -208,12 +209,7 @@ func (m *Message) SendMessage(c *gin.Context) {
 		return
 	}
 	pbReq := m.newUserSendMsgReq(c, &params)
-	conn, err := m.c.GetConn(c, config.Config.RpcRegisterName.OpenImMsgName)
+	client := msg.NewMsgClient(m.conn)
-	if err != nil {
-		apiresp.GinError(c, errs.ErrInternalServer)
-		return
-	}
-	client := msg.NewMsgClient(conn)
 	var status int
 	respPb, err := client.SendMsg(c, pbReq)
 	if err != nil {

internal/api/third.go

@@ -14,22 +14,23 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/third"
 	"github.com/gin-gonic/gin"
+	"google.golang.org/grpc"
 )
 
-func NewThird(c discoveryregistry.SvcDiscoveryRegistry) *Third {
+func NewThird(discov discoveryregistry.SvcDiscoveryRegistry) *Third {
-	return &Third{c: c}
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImThirdName)
+	if err != nil {
+		panic(err)
+	}
+	return &Third{conn: conn}
 }
 
 type Third struct {
-	c discoveryregistry.SvcDiscoveryRegistry
+	conn *grpc.ClientConn
 }
 
 func (o *Third) client(ctx context.Context) (third.ThirdClient, error) {
-	conn, err := o.c.GetConn(ctx, config.Config.RpcRegisterName.OpenImThirdName)
+	return third.NewThirdClient(o.conn), nil
-	if err != nil {
-		return nil, err
-	}
-	return third.NewThirdClient(conn), nil
 }
 
 func (o *Third) ApplyPut(c *gin.Context) {

internal/api/user.go

@@ -7,6 +7,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apistruct"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"google.golang.org/grpc"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
@@ -15,20 +16,20 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func NewUser(client discoveryregistry.SvcDiscoveryRegistry) *User {
+func NewUser(discov discoveryregistry.SvcDiscoveryRegistry) *User {
-	return &User{c: client}
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImThirdName)
+	if err != nil {
+		panic(err)
+	}
+	return &User{conn: conn}
 }
 
 type User struct {
-	c discoveryregistry.SvcDiscoveryRegistry
+	conn *grpc.ClientConn
 }
 
 func (u *User) client(ctx context.Context) (user.UserClient, error) {
-	conn, err := u.c.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
+	return user.NewUserClient(u.conn), nil
-	if err != nil {
-		return nil, err
-	}
-	return user.NewUserClient(conn), nil
 }
 
 func (u *User) UserRegister(c *gin.Context) {
@@ -58,6 +59,7 @@ func (u *User) AccountCheck(c *gin.Context) {
 func (u *User) GetUsers(c *gin.Context) {
 	a2r.Call(user.UserClient.GetPaginationUsers, u.client, c)
 }
+
 func (u *User) GetUsersOnlineStatus(c *gin.Context) {
 	params := apistruct.ManagementSendMsgReq{}
 	if err := c.BindJSON(&params); err != nil {
@@ -68,5 +70,4 @@ func (u *User) GetUsersOnlineStatus(c *gin.Context) {
 		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
 		return
 	}
-
 }

internal/rpc/group/group.go

@@ -54,12 +54,12 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	pbGroup.RegisterGroupServer(server, &groupServer{
 		GroupDatabase: database,
 		User:          user,
-		Notification: notification.NewGroupNotificationSender(database, client, func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error) {
+		Notification: notification.NewGroupNotificationSender(database, client, func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error) {
 			users, err := user.GetUsersInfo(ctx, userIDs)
 			if err != nil {
 				return nil, err
 			}
-			return utils.Slice(users, func(e *sdkws.UserInfo) rpcclient.CommonUser { return e }), nil
+			return utils.Slice(users, func(e *sdkws.UserInfo) notification.CommonUser { return e }), nil
 		}),
 		conversationRpcClient: rpcclient.NewConversationClient(client),
 		msgRpcClient:          rpcclient.NewMsgClient(client),

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)
+	client := conversation.NewConversationClient(g.conn)
-	if err != nil {
-		return nil, err
-	}
-	client := conversation.NewConversationClient(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)
+	client := conversation.NewConversationClient(g.conn)
-	if err != nil {
-		return nil, err
-	}
-	client := conversation.NewConversationClient(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
+	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,
+		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)
+	client := group.NewGroupClient(g.conn)
-	if err != nil {
-		return nil, err
-	}
-	client := group.NewGroupClient(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 {
+func NewConversationClient(discov discoveryRegistry.SvcDiscoveryRegistry) *ConversationClient {
-	return &ConversationClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImConversationName)}
+	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)
+	_, err := pbConversation.NewConversationClient(c.conn).ModifyConversationField(ctx, req)
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).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)
+	_, err := pbConversation.NewConversationClient(c.conn).CreateSingleChatConversations(ctx, &pbConversation.CreateSingleChatConversationsReq{RecvID: recvID, SendID: sendID})
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).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)
+	_, err := pbConversation.NewConversationClient(c.conn).CreateGroupChatConversations(ctx, &pbConversation.CreateGroupChatConversationsReq{UserIDs: userIDs, GroupID: groupID})
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).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)
+	_, err := pbConversation.NewConversationClient(c.conn).DelGroupChatConversations(ctx, &pbConversation.DelGroupChatConversationsReq{OwnerUserID: ownerUserIDs, GroupID: groupID, MaxSeq: maxSeq})
-	if err != nil {
-		return err
-	}
-	_, err = pbConversation.NewConversationClient(cc).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)
+	resp, err := pbConversation.NewConversationClient(c.conn).GetConversationIDs(ctx, &pbConversation.GetConversationIDsReq{UserID: ownerUserID})
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).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)
+	resp, err := pbConversation.NewConversationClient(c.conn).GetConversation(ctx, &pbConversation.GetConversationReq{OwnerUserID: ownerUserID, ConversationID: conversationID})
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).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)
+	resp, err := pbConversation.NewConversationClient(c.conn).GetConversationByConversationID(ctx, &pbConversation.GetConversationByConversationIDReq{ConversationID: conversationID})
-	if err != nil {
-		return nil, err
-	}
-	resp, err := pbConversation.NewConversationClient(cc).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 {
+func NewFriendClient(discov discoveryRegistry.SvcDiscoveryRegistry) *FriendClient {
-	return &FriendClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImFriendName)}
+	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)
+	r, err := friend.NewFriendClient(f.conn).GetDesignatedFriends(ctx, &friend.GetDesignatedFriendsReq{OwnerUserID: ownerUserID, FriendUserIDs: []string{friendUserID}})
-	if err != nil {
-		return nil, err
-	}
-	r, err := friend.NewFriendClient(cc).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)
+	resp, err := friend.NewFriendClient(f.conn).IsFriend(ctx, &friend.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID})
-	if err != nil {
-		return false, err
-	}
-	resp, err := friend.NewFriendClient(cc).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 {
+func NewGroupClient(discov discoveryregistry.SvcDiscoveryRegistry) *GroupClient {
-	return &GroupClient{
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImGroupName)
-		MetaClient: MetaClient{
+	if err != nil {
-			client:          client,
+		panic(err)
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
-		},
 	}
+	return &GroupClient{conn: conn}
 }
 
 func (g *GroupClient) GetGroupInfos(ctx context.Context, groupIDs []string, complete bool) ([]*sdkws.GroupInfo, error) {
-	cc, err := g.getConn(ctx)
+	resp, err := group.NewGroupClient(g.conn).GetGroupsInfo(ctx, &group.GetGroupsInfoReq{
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).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)
+	resp, err := group.NewGroupClient(g.conn).GetGroupMembersInfo(ctx, &group.GetGroupMembersInfoReq{
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).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)
+	resp, err := group.NewGroupClient(g.conn).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).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)
+	resp, err := group.NewGroupClient(g.conn).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).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)
+	resp, err := group.NewGroupClient(g.conn).GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{
-	if err != nil {
-		return nil, err
-	}
-	resp, err := group.NewGroupClient(cc).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)
+	resp, err := msg.NewMsgClient(m.conn).SendMsg(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).SendMsg(ctx, req)
 	return resp, err
 }
 
 func (m *MsgClient) GetMaxSeq(ctx context.Context, req *sdkws.GetMaxSeqReq) (*sdkws.GetMaxSeqResp, error) {
-	cc, err := m.getConn(ctx)
+	resp, err := msg.NewMsgClient(m.conn).GetMaxSeq(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).GetMaxSeq(ctx, req)
 	return resp, err
 }
 
 func (m *MsgClient) PullMessageBySeqList(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
-	cc, err := m.getConn(ctx)
+	resp, err := msg.NewMsgClient(m.conn).PullMessageBySeqs(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).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 {
+func NewPushClient(discov discoveryregistry.SvcDiscoveryRegistry) *PushClient {
-	return &PushClient{
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImPushName)
-		MetaClient: MetaClient{
+	if err != nil {
-			client:          client,
+		panic(err)
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImPushName,
-		},
 	}
+	return &PushClient{conn: conn}
 }
 
 func (p *PushClient) DelUserPushToken(ctx context.Context, req *push.DelUserPushTokenReq) (*push.DelUserPushTokenResp, error) {
-	cc, err := p.getConn(ctx)
+	resp, err := push.NewPushMsgServiceClient(p.conn).DelUserPushToken(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := push.NewPushMsgServiceClient(cc).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 {
+func NewUserClient(discov discoveryregistry.SvcDiscoveryRegistry) *UserClient {
-	return &UserClient{
+	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImUserName)
-		MetaClient: MetaClient{
+	if err != nil {
-			client:          client,
+		panic(err)
-			rpcRegisterName: config.Config.RpcRegisterName.OpenImUserName,
-		},
 	}
+	return &UserClient{conn: conn}
 }
 
 func (u *UserClient) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
-	cc, err := u.getConn(ctx)
+	resp, err := user.NewUserClient(u.conn).GetDesignateUsers(ctx, &user.GetDesignateUsersReq{
-	if err != nil {
-		return nil, err
-	}
-	resp, err := user.NewUserClient(cc).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)
+	resp, err := user.NewUserClient(u.conn).GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{
-	if err != nil {
-		return 0, err
-	}
-	resp, err := user.NewUserClient(cc).GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{
 		UserID: userID,
 	})
 	if err != nil {