AUTH

internal/rpc/auth/auth.go

@@ -20,7 +20,7 @@ import (
 
 type authServer struct {
 	authDatabase   controller.AuthDatabase
-	userRpcClient  *rpcclient.UserClient
+	userRpcClient  *rpcclient.UserRpcClient
 	RegisterCenter discoveryregistry.SvcDiscoveryRegistry
 }
 
@@ -29,8 +29,9 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	if err != nil {
 		return err
 	}
+	userRpcClient := rpcclient.NewUserRpcClient(client)
 	pbAuth.RegisterAuthServer(server, &authServer{
-		userRpcClient:  rpcclient.NewUserClient(client),
+		userRpcClient:  &userRpcClient,
 		RegisterCenter: client,
 		authDatabase:   controller.NewAuthDatabase(cache.NewMsgCacheModel(rdb), config.Config.TokenPolicy.AccessSecret, config.Config.TokenPolicy.AccessExpire),
 	})

internal/rpc/conversation/conversaion.go

@@ -21,10 +21,10 @@ import (
 )
 
 type conversationServer struct {
-	groupRpcClient                 *rpcclient.GroupClient
+	groupRpcClient                 *rpcclient.GroupRpcClient
 	conversationDatabase           controller.ConversationDatabase
 	conversationNotificationSender *notification.ConversationNotificationSender
-	msgRpcClient                   *rpcclient.MsgClient
+	msgRpcClient                   *rpcclient.MessageRpcClient
 }
 
 func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
@@ -40,10 +40,12 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 		return err
 	}
 	conversationDB := relation.NewConversationGorm(db)
+	groupRpcClient := rpcclient.NewGroupRpcClient(client)
+	msgRpcClient := rpcclient.NewMessageRpcClient(client)
 	pbConversation.RegisterConversationServer(server, &conversationServer{
 		conversationNotificationSender: notification.NewConversationNotificationSender(client),
-		groupRpcClient:                 rpcclient.NewGroupClient(client),
-		msgRpcClient:                   rpcclient.NewMsgClient(client),
+		groupRpcClient:                 &groupRpcClient,
+		msgRpcClient:                   &msgRpcClient,
 		conversationDatabase:           controller.NewConversationDatabase(conversationDB, cache.NewConversationRedis(rdb, cache.GetDefaultOpt(), conversationDB), tx.NewGorm(db)),
 	})
 	return nil

internal/rpc/friend/friend.go

@@ -25,7 +25,7 @@ import (
 type friendServer struct {
 	friendDatabase     controller.FriendDatabase
 	blackDatabase      controller.BlackDatabase
-	userRpcClient      *rpcclient.UserClient
+	userRpcClient      *rpcclient.UserRpcClient
 	notificationSender *notification.FriendNotificationSender
 	RegisterCenter     registry.SvcDiscoveryRegistry
 }
@@ -44,12 +44,12 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	}
 	blackDB := relation.NewBlackGorm(db)
 	friendDB := relation.NewFriendGorm(db)
-	userRpcClient := rpcclient.NewUserClient(client)
+	userRpcClient := rpcclient.NewUserRpcClient(client)
 	notificationSender := notification.NewFriendNotificationSender(client, notification.WithRpcFunc(userRpcClient.GetUsersInfo))
 	pbfriend.RegisterFriendServer(server, &friendServer{
 		friendDatabase:     controller.NewFriendDatabase(friendDB, relation.NewFriendRequestGorm(db), cache.NewFriendCacheRedis(rdb, friendDB, cache.GetDefaultOpt()), tx.NewGorm(db)),
 		blackDatabase:      controller.NewBlackDatabase(blackDB, cache.NewBlackCacheRedis(rdb, blackDB, cache.GetDefaultOpt())),
-		userRpcClient:      userRpcClient,
+		userRpcClient:      &userRpcClient,
 		notificationSender: notificationSender,
 		RegisterCenter:     client,
 	})

internal/rpc/msg/server.go

@@ -22,11 +22,10 @@ type msgServer struct {
 	RegisterCenter         discoveryregistry.SvcDiscoveryRegistry
 	MsgDatabase            controller.CommonMsgDatabase
 	ExtendMsgDatabase      controller.ExtendMsgDatabase
-	Group                  *rpcclient.GroupClient
-	User                   *rpcclient.UserClient
-	Conversation           *rpcclient.ConversationClient
-	friend                 *rpcclient.FriendClient
-	black                  *rpcclient.BlackClient
+	Group                  *rpcclient.GroupRpcClient
+	User                   *rpcclient.UserRpcClient
+	Conversation           *rpcclient.ConversationRpcClient
+	friend                 *rpcclient.FriendRpcClient
 	GroupLocalCache        *localcache.GroupLocalCache
 	ConversationLocalCache *localcache.ConversationLocalCache
 	MessageLocker          MessageLocker
@@ -67,17 +66,20 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	extendMsgCacheModel := cache.NewExtendMsgSetCacheRedis(rdb, extendMsgModel, cache.GetDefaultOpt())
 	extendMsgDatabase := controller.NewExtendMsgDatabase(extendMsgModel, extendMsgCacheModel, tx.NewMongo(mongo.GetClient()))
 	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, cacheModel)
+	conversationClient := rpcclient.NewConversationRpcClient(client)
+	userRpcClient := rpcclient.NewUserRpcClient(client)
+	groupRpcClient := rpcclient.NewGroupRpcClient(client)
+	friendRpcClient := rpcclient.NewFriendRpcClient(client)
 	s := &msgServer{
-		Conversation:           rpcclient.NewConversationClient(client),
-		User:                   rpcclient.NewUserClient(client),
-		Group:                  rpcclient.NewGroupClient(client),
+		Conversation:           &conversationClient,
+		User:                   &userRpcClient,
+		Group:                  &groupRpcClient,
 		MsgDatabase:            msgDatabase,
 		ExtendMsgDatabase:      extendMsgDatabase,
 		RegisterCenter:         client,
 		GroupLocalCache:        localcache.NewGroupLocalCache(client),
 		ConversationLocalCache: localcache.NewConversationLocalCache(client),
-		black:                  rpcclient.NewBlackClient(client),
-		friend:                 rpcclient.NewFriendClient(client),
+		friend:                 &friendRpcClient,
 		MessageLocker:          NewLockerMessage(cacheModel),
 	}
 	s.notificationSender = rpcclient.NewNotificationSender(rpcclient.WithLocalSendMsg(s.SendMsg))

internal/rpc/msg/verify.go

@@ -44,7 +44,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 		if data.MsgData.ContentType <= constant.NotificationEnd && data.MsgData.ContentType >= constant.NotificationBegin {
 			return nil
 		}
-		black, err := m.black.IsBlocked(ctx, data.MsgData.SendID, data.MsgData.RecvID)
+		black, err := m.friend.IsBlocked(ctx, data.MsgData.SendID, data.MsgData.RecvID)
 		if err != nil {
 			return err
 		}

internal/rpc/user/user.go

@@ -28,7 +28,7 @@ import (
 type userServer struct {
 	controller.UserDatabase
 	notificationSender *notification.FriendNotificationSender
-	friendRpcClient    *rpcclient.FriendClient
+	friendRpcClient    *rpcclient.FriendRpcClient
 	RegisterCenter     registry.SvcDiscoveryRegistry
 }
 
@@ -54,10 +54,11 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	userDB := relation.NewUserGorm(db)
 	cache := cache.NewUserCacheRedis(rdb, userDB, cache.GetDefaultOpt())
 	database := controller.NewUserDatabase(userDB, cache, tx.NewGorm(db))
+	friendRpcClient := rpcclient.NewFriendRpcClient(client)
 	u := &userServer{
 		UserDatabase:       database,
 		RegisterCenter:     client,
-		friendRpcClient:    rpcclient.NewFriendClient(client),
+		friendRpcClient:    &friendRpcClient,
 		notificationSender: notification.NewFriendNotificationSender(client, notification.WithDBFunc(database.FindWithError)),
 	}
 	pbuser.RegisterUserServer(server, u)